From 825524d01662233fc80181e4b745a828e799b1c2 Mon Sep 17 00:00:00 2001 From: Tim Shannon Date: Tue, 10 Feb 2015 14:24:22 -0600 Subject: [PATCH 01/26] Changed library to build statically and be 'go-gettable' by including some files created during the c make process, and removing the main.c file as it created a double declaration. Also changed cmark.h to reference local headers. The result is users of the library should be able to simply go get this libray and it should work. The downside is the cmark code needed a little modification, and is now included entirely in this repository. So for future cmark updates we'll need to repeat this process after syncing the c code. Worth it in my opinion. --- CMakeLists.txt | 149 + bench.h | 27 + blocks.c | 878 +++ buffer.c | 381 ++ buffer.h | 113 + case_fold_switch.inc | 2637 ++++++++ chunk.h | 110 + cmark.c | 24 + cmark.h | 556 ++ cmark_ctype.c | 53 + cmark_ctype.h | 24 + cmark_export.h | 35 + cmark_version.h | 7 + cmark_version.h.in | 7 + commonmark.go | 2 +- config.h | 23 + config.h.in | 23 + debug.h | 36 + houdini.h | 52 + houdini_href_e.c | 107 + houdini_html_e.c | 81 + houdini_html_u.c | 116 + html.c | 323 + html_unescape.gperf | 2130 +++++++ html_unescape.h | 13375 +++++++++++++++++++++++++++++++++++++++++ inlines.c | 1031 ++++ inlines.h | 19 + iterator.c | 146 + iterator.h | 25 + libcmark.pc.in | 10 + man.c | 250 + node.c | 871 +++ node.h | 79 + parser.h | 28 + references.c | 154 + references.h | 37 + scanners.c | 12391 ++++++++++++++++++++++++++++++++++++++ scanners.h | 39 + scanners.re | 236 + utf8.c | 453 ++ utf8.h | 22 + xml.c | 174 + 42 files changed, 37233 insertions(+), 1 deletion(-) create mode 100644 CMakeLists.txt create mode 100644 bench.h create mode 100644 blocks.c create mode 100644 buffer.c create mode 100644 buffer.h create mode 100644 case_fold_switch.inc create mode 100644 chunk.h create mode 100644 cmark.c create mode 100644 cmark.h create mode 100644 cmark_ctype.c create mode 100644 cmark_ctype.h create mode 100644 cmark_export.h create mode 100644 cmark_version.h create mode 100644 cmark_version.h.in create mode 100644 config.h create mode 100644 config.h.in create mode 100644 debug.h create mode 100644 houdini.h create mode 100644 houdini_href_e.c create mode 100644 houdini_html_e.c create mode 100644 houdini_html_u.c create mode 100644 html.c create mode 100644 html_unescape.gperf create mode 100644 html_unescape.h create mode 100644 inlines.c create mode 100644 inlines.h create mode 100644 iterator.c create mode 100644 iterator.h create mode 100644 libcmark.pc.in create mode 100644 man.c create mode 100644 node.c create mode 100644 node.h create mode 100644 parser.h create mode 100644 references.c create mode 100644 references.h create mode 100644 scanners.c create mode 100644 scanners.h create mode 100644 scanners.re create mode 100644 utf8.c create mode 100644 utf8.h create mode 100644 xml.c diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..2179c08 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,149 @@ +cmake_minimum_required(VERSION 2.8) +set(LIBRARY "libcmark") +set(HEADERS + cmark.h + parser.h + buffer.h + node.h + iterator.h + chunk.h + references.h + debug.h + bench.h + utf8.h + scanners.h + inlines.h + html_unescape.h + houdini.h + cmark_ctype.h + ) +set(LIBRARY_SOURCES + cmark.c + node.c + iterator.c + blocks.c + inlines.c + scanners.c + scanners.re + utf8.c + buffer.c + references.c + man.c + xml.c + html.c + html_unescape.gperf + houdini_href_e.c + houdini_html_e.c + houdini_html_u.c + cmark_ctype.c + ${HEADERS} + ) + +set(PROGRAM "cmark") +set(PROGRAM_SOURCES + ${LIBRARY_SOURCES} + main.c + ) + +include_directories(. ${CMAKE_CURRENT_BINARY_DIR}) + +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmark_version.h.in + ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h) + +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc @ONLY) +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc + DESTINATION lib/pkgconfig) + +include (GenerateExportHeader) + +add_executable(${PROGRAM} ${PROGRAM_SOURCES}) +add_compiler_export_flags() + +# Disable the PUBLIC declarations when compiling the executable: +set_target_properties(${PROGRAM} PROPERTIES + COMPILE_FLAGS -DCMARK_STATIC_DEFINE) + +# Check integrity of node structure when compiled as debug: +set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -pg -DCMARK_DEBUG_NODES") +set(CMAKE_LINKER_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -pg") + +set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -pg") +set(CMAKE_LINKER_PROFILE "${CMAKE_LINKER_FLAGS_RELEASE} -pg") + +if (${CMAKE_MAJOR_VERSION} GREATER 1 AND ${CMAKE_MINOR_VERSION} GREATER 8) + set(CMAKE_C_VISIBILITY_PRESET hidden) + set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) +elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") +endif () + +add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES}) +# Include minor version in soname as long as major version is 0. +set_target_properties(${LIBRARY} PROPERTIES + OUTPUT_NAME "cmark" + SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR} + VERSION ${PROJECT_VERSION}) + +set_property(TARGET ${LIBRARY} + APPEND PROPERTY MACOSX_RPATH true) + +generate_export_header(${LIBRARY} + BASE_NAME ${PROJECT_NAME}) + +if (MSVC) + set_property(TARGET ${PROGRAM} + APPEND PROPERTY LINK_FLAGS /INCREMENTAL:NO) +endif(MSVC) + +install(TARGETS ${PROGRAM} ${LIBRARY} + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ) + +install(FILES + cmark.h + ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h + ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h + DESTINATION include + ) + +# Feature tests +include(CheckIncludeFile) +include(CheckCSourceCompiles) +include(CheckSymbolExists) +CHECK_INCLUDE_FILE(stdbool.h HAVE_STDBOOL_H) +CHECK_C_SOURCE_COMPILES( + "int main() { __builtin_expect(0,0); return 0; }" + HAVE___BUILTIN_EXPECT) +CHECK_C_SOURCE_COMPILES(" + int f(void) __attribute__ (()); + int main() { return 0; } +" HAVE___ATTRIBUTE__) +CHECK_SYMBOL_EXISTS(va_copy stdarg.h HAVE_VA_COPY) + +CONFIGURE_FILE( + ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in + ${CMAKE_CURRENT_BINARY_DIR}/config.h) + +# Always compile with warnings +if(MSVC) + # Force to always compile with W4 + if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") + else() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4") + endif() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127 /wd4244 /wd4267 /wd4706 /wd4800 /D_CRT_SECURE_NO_WARNINGS") +elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=c99 -pedantic") +endif() + +# Compile as C++ under MSVC +if(MSVC) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /TP") +endif() + +if($ENV{TIMER}) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DTIMER=1") +endif($ENV{TIMER}) diff --git a/bench.h b/bench.h new file mode 100644 index 0000000..bbea2c6 --- /dev/null +++ b/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/blocks.c b/blocks.c new file mode 100644 index 0000000..806f7a6 --- /dev/null +++ b/blocks.c @@ -0,0 +1,878 @@ +#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 cmark_node. +static cmark_node* make_document() +{ + cmark_node *e = make_block(NODE_DOCUMENT, 1, 1); + return e; +} + +cmark_parser *cmark_parser_new() +{ + 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; + + 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 cmark_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 cmark_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 cmark_node that can accept this child, + // then back up til we hit a cmark_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 cmark_node and all children, recursively, parsing +// string content into inline content where appropriate. +static void process_inlines(cmark_node* root, cmark_reference_map *refmap) +{ + 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); + } + } + } + + 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); + + return parser->root; +} + +cmark_node *cmark_parse_file(FILE *f) +{ + unsigned char buffer[4096]; + cmark_parser *parser = cmark_parser_new(); + 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) +{ + cmark_parser *parser = cmark_parser_new(); + 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; + cmark_node* cur = parser->current; + bool blank = false; + int first_nonspace; + int indent; + cmark_chunk input; + + 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 cmark_node, try to parse the associated line start. + // bail out on failure: container will point to the last matching cmark_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 cmark_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); + } + + // unless last matched container is code cmark_node, 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 (cur->type != NODE_PARAGRAPH && !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; + } + } + + // 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 (cur != last_matched_container && + container == last_matched_container && + !blank && + cur->type == NODE_PARAGRAPH && + cmark_strbuf_len(&cur->string_content) > 0) { + + add_line(cur, &input, offset); + + } else { // not a lazy continuation + + // finalize any blocks that were not matched and set cur to container: + while (cur != last_matched_container) { + cur = finalize(parser, cur); + assert(cur != 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); + cmark_strbuf_free(parser->curline); +#if CMARK_DEBUG_NODES + if (cmark_node_check(parser->root, stderr)) { + abort(); + } +#endif + return parser->root; +} diff --git a/buffer.c b/buffer.c new file mode 100644 index 0000000..0df6561 --- /dev/null +++ b/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/buffer.h b/buffer.h new file mode 100644 index 0000000..fb9f910 --- /dev/null +++ b/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/case_fold_switch.inc b/case_fold_switch.inc new file mode 100644 index 0000000..70fdd75 --- /dev/null +++ b/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/chunk.h b/chunk.h new file mode 100644 index 0000000..54c4b16 --- /dev/null +++ b/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/cmark.c b/cmark.c new file mode 100644 index 0000000..2ec9be9 --- /dev/null +++ b/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) +{ + cmark_node *doc; + char *result; + + doc = cmark_parse_document(text, len); + + result = cmark_render_html(doc, CMARK_OPT_DEFAULT); + cmark_node_free(doc); + + return result; +} + diff --git a/cmark.h b/cmark.h new file mode 100644 index 0000000..64d8d47 --- /dev/null +++ b/cmark.h @@ -0,0 +1,556 @@ +#ifndef CMARK_H +#define CMARK_H + +#include +#include "cmark_export.h" +#include "cmark_version.h" + +#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); + +/** ## 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); + * + * Streaming interface: + * + * cmark_parser *parser = cmark_parser_new(); + * 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(); + +/** 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); + +/** Parse a CommonMark document in file 'f', returning a pointer to + * a tree of nodes. + */ +CMARK_EXPORT +cmark_node *cmark_parse_file(FILE *f); + +/** + * ## Rendering + */ + +/** Render a 'node' tree as XML. + */ +CMARK_EXPORT +char *cmark_render_xml(cmark_node *root, long 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, long options); + +/** Render a 'node' tree as a groff man page, without the header. + */ +CMARK_EXPORT +char *cmark_render_man(cmark_node *root, long 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 + +/** + * ## 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 NODE_LINK_LABEL CMARK_NODE_LINK_LABEL +#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_ctype.c b/cmark_ctype.c new file mode 100644 index 0000000..5de8199 --- /dev/null +++ b/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/cmark_ctype.h b/cmark_ctype.h new file mode 100644 index 0000000..f803946 --- /dev/null +++ b/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/cmark_export.h b/cmark_export.h new file mode 100644 index 0000000..1102c36 --- /dev/null +++ b/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/cmark_version.h b/cmark_version.h new file mode 100644 index 0000000..f86b6aa --- /dev/null +++ b/cmark_version.h @@ -0,0 +1,7 @@ +#ifndef CMARK_VERSION_H +#define CMARK_VERSION_H + +#define CMARK_VERSION ((0 << 16) | (17 << 8) | 0) +#define CMARK_VERSION_STRING "0.17.0" + +#endif diff --git a/cmark_version.h.in b/cmark_version.h.in new file mode 100644 index 0000000..41de3ac --- /dev/null +++ b/cmark_version.h.in @@ -0,0 +1,7 @@ +#ifndef CMARK_VERSION_H +#define CMARK_VERSION_H + +#define CMARK_VERSION ((@PROJECT_VERSION_MAJOR@ << 16) | (@PROJECT_VERSION_MINOR@ << 8) | @PROJECT_VERSION_PATCH@) +#define CMARK_VERSION_STRING "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@" + +#endif diff --git a/commonmark.go b/commonmark.go index bebf08b..987b39a 100644 --- a/commonmark.go +++ b/commonmark.go @@ -2,7 +2,7 @@ package commonmark /* -#cgo LDFLAGS: -lcmark +#cgo CFLAGS: -std=gnu99 #include #include #include "cmark.h" diff --git a/config.h b/config.h new file mode 100644 index 0000000..3de8c11 --- /dev/null +++ b/config.h @@ -0,0 +1,23 @@ +#define HAVE_STDBOOL_H + +#ifdef HAVE_STDBOOL_H + #include +#elif !defined(__cplusplus) + typedef char bool; +#endif + +#define 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/config.h.in b/config.h.in new file mode 100644 index 0000000..c1e9597 --- /dev/null +++ b/config.h.in @@ -0,0 +1,23 @@ +#cmakedefine HAVE_STDBOOL_H + +#ifdef HAVE_STDBOOL_H + #include +#elif !defined(__cplusplus) + typedef char bool; +#endif + +#cmakedefine HAVE___BUILTIN_EXPECT + +#cmakedefine HAVE___ATTRIBUTE__ + +#ifdef HAVE___ATTRIBUTE__ + #define CMARK_ATTRIBUTE(list) __attribute__ (list) +#else + #define CMARK_ATTRIBUTE(list) +#endif + +#cmakedefine HAVE_VA_COPY + +#ifndef HAVE_VA_COPY + #define va_copy(dest, src) ((dest) = (src)) +#endif diff --git a/debug.h b/debug.h new file mode 100644 index 0000000..fd2ef62 --- /dev/null +++ b/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/houdini.h b/houdini.h new file mode 100644 index 0000000..9f00f6d --- /dev/null +++ b/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/houdini_href_e.c b/houdini_href_e.c new file mode 100644 index 0000000..7527780 --- /dev/null +++ b/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/houdini_html_e.c b/houdini_html_e.c new file mode 100644 index 0000000..1a4c3e1 --- /dev/null +++ b/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/houdini_html_u.c b/houdini_html_u.c new file mode 100644 index 0000000..2cb14b4 --- /dev/null +++ b/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/html.c b/html.c new file mode 100644 index 0000000..8ccb495 --- /dev/null +++ b/html.c @@ -0,0 +1,323 @@ +#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, long 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, long 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, long 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/html_unescape.gperf b/html_unescape.gperf new file mode 100644 index 0000000..74173a6 --- /dev/null +++ b/html_unescape.gperf @@ -0,0 +1,2130 @@ +struct html_ent { + int entity; + unsigned char utf8[4]; +}; +%% +"Aacute", {195, 129, 0} +"aacute", {195, 161, 0} +"Abreve", {196, 130, 0} +"abreve", {196, 131, 0} +"ac", {226, 136, 190, 0} +"acd", {226, 136, 191, 0} +"acE", {226, 136, 190, 0} +"Acirc", {195, 130, 0} +"acirc", {195, 162, 0} +"acute", {194, 180, 0} +"Acy", {208, 144, 0} +"acy", {208, 176, 0} +"AElig", {195, 134, 0} +"aelig", {195, 166, 0} +"af", {226, 129, 161, 0} +"Afr", {240, 157, 148, 132} +"afr", {240, 157, 148, 158} +"Agrave", {195, 128, 0} +"agrave", {195, 160, 0} +"alefsym", {226, 132, 181, 0} +"aleph", {226, 132, 181, 0} +"Alpha", {206, 145, 0} +"alpha", {206, 177, 0} +"Amacr", {196, 128, 0} +"amacr", {196, 129, 0} +"amalg", {226, 168, 191, 0} +"amp", {38, 0} +"AMP", {38, 0} +"andand", {226, 169, 149, 0} +"And", {226, 169, 147, 0} +"and", {226, 136, 167, 0} +"andd", {226, 169, 156, 0} +"andslope", {226, 169, 152, 0} +"andv", {226, 169, 154, 0} +"ang", {226, 136, 160, 0} +"ange", {226, 166, 164, 0} +"angle", {226, 136, 160, 0} +"angmsdaa", {226, 166, 168, 0} +"angmsdab", {226, 166, 169, 0} +"angmsdac", {226, 166, 170, 0} +"angmsdad", {226, 166, 171, 0} +"angmsdae", {226, 166, 172, 0} +"angmsdaf", {226, 166, 173, 0} +"angmsdag", {226, 166, 174, 0} +"angmsdah", {226, 166, 175, 0} +"angmsd", {226, 136, 161, 0} +"angrt", {226, 136, 159, 0} +"angrtvb", {226, 138, 190, 0} +"angrtvbd", {226, 166, 157, 0} +"angsph", {226, 136, 162, 0} +"angst", {195, 133, 0} +"angzarr", {226, 141, 188, 0} +"Aogon", {196, 132, 0} +"aogon", {196, 133, 0} +"Aopf", {240, 157, 148, 184} +"aopf", {240, 157, 149, 146} +"apacir", {226, 169, 175, 0} +"ap", {226, 137, 136, 0} +"apE", {226, 169, 176, 0} +"ape", {226, 137, 138, 0} +"apid", {226, 137, 139, 0} +"apos", {39, 0} +"ApplyFunction", {226, 129, 161, 0} +"approx", {226, 137, 136, 0} +"approxeq", {226, 137, 138, 0} +"Aring", {195, 133, 0} +"aring", {195, 165, 0} +"Ascr", {240, 157, 146, 156} +"ascr", {240, 157, 146, 182} +"Assign", {226, 137, 148, 0} +"ast", {42, 0} +"asymp", {226, 137, 136, 0} +"asympeq", {226, 137, 141, 0} +"Atilde", {195, 131, 0} +"atilde", {195, 163, 0} +"Auml", {195, 132, 0} +"auml", {195, 164, 0} +"awconint", {226, 136, 179, 0} +"awint", {226, 168, 145, 0} +"backcong", {226, 137, 140, 0} +"backepsilon", {207, 182, 0} +"backprime", {226, 128, 181, 0} +"backsim", {226, 136, 189, 0} +"backsimeq", {226, 139, 141, 0} +"Backslash", {226, 136, 150, 0} +"Barv", {226, 171, 167, 0} +"barvee", {226, 138, 189, 0} +"barwed", {226, 140, 133, 0} +"Barwed", {226, 140, 134, 0} +"barwedge", {226, 140, 133, 0} +"bbrk", {226, 142, 181, 0} +"bbrktbrk", {226, 142, 182, 0} +"bcong", {226, 137, 140, 0} +"Bcy", {208, 145, 0} +"bcy", {208, 177, 0} +"bdquo", {226, 128, 158, 0} +"becaus", {226, 136, 181, 0} +"because", {226, 136, 181, 0} +"Because", {226, 136, 181, 0} +"bemptyv", {226, 166, 176, 0} +"bepsi", {207, 182, 0} +"bernou", {226, 132, 172, 0} +"Bernoullis", {226, 132, 172, 0} +"Beta", {206, 146, 0} +"beta", {206, 178, 0} +"beth", {226, 132, 182, 0} +"between", {226, 137, 172, 0} +"Bfr", {240, 157, 148, 133} +"bfr", {240, 157, 148, 159} +"bigcap", {226, 139, 130, 0} +"bigcirc", {226, 151, 175, 0} +"bigcup", {226, 139, 131, 0} +"bigodot", {226, 168, 128, 0} +"bigoplus", {226, 168, 129, 0} +"bigotimes", {226, 168, 130, 0} +"bigsqcup", {226, 168, 134, 0} +"bigstar", {226, 152, 133, 0} +"bigtriangledown", {226, 150, 189, 0} +"bigtriangleup", {226, 150, 179, 0} +"biguplus", {226, 168, 132, 0} +"bigvee", {226, 139, 129, 0} +"bigwedge", {226, 139, 128, 0} +"bkarow", {226, 164, 141, 0} +"blacklozenge", {226, 167, 171, 0} +"blacksquare", {226, 150, 170, 0} +"blacktriangle", {226, 150, 180, 0} +"blacktriangledown", {226, 150, 190, 0} +"blacktriangleleft", {226, 151, 130, 0} +"blacktriangleright", {226, 150, 184, 0} +"blank", {226, 144, 163, 0} +"blk12", {226, 150, 146, 0} +"blk14", {226, 150, 145, 0} +"blk34", {226, 150, 147, 0} +"block", {226, 150, 136, 0} +"bne", {61, 0} +"bnequiv", {226, 137, 161, 0} +"bNot", {226, 171, 173, 0} +"bnot", {226, 140, 144, 0} +"Bopf", {240, 157, 148, 185} +"bopf", {240, 157, 149, 147} +"bot", {226, 138, 165, 0} +"bottom", {226, 138, 165, 0} +"bowtie", {226, 139, 136, 0} +"boxbox", {226, 167, 137, 0} +"boxdl", {226, 148, 144, 0} +"boxdL", {226, 149, 149, 0} +"boxDl", {226, 149, 150, 0} +"boxDL", {226, 149, 151, 0} +"boxdr", {226, 148, 140, 0} +"boxdR", {226, 149, 146, 0} +"boxDr", {226, 149, 147, 0} +"boxDR", {226, 149, 148, 0} +"boxh", {226, 148, 128, 0} +"boxH", {226, 149, 144, 0} +"boxhd", {226, 148, 172, 0} +"boxHd", {226, 149, 164, 0} +"boxhD", {226, 149, 165, 0} +"boxHD", {226, 149, 166, 0} +"boxhu", {226, 148, 180, 0} +"boxHu", {226, 149, 167, 0} +"boxhU", {226, 149, 168, 0} +"boxHU", {226, 149, 169, 0} +"boxminus", {226, 138, 159, 0} +"boxplus", {226, 138, 158, 0} +"boxtimes", {226, 138, 160, 0} +"boxul", {226, 148, 152, 0} +"boxuL", {226, 149, 155, 0} +"boxUl", {226, 149, 156, 0} +"boxUL", {226, 149, 157, 0} +"boxur", {226, 148, 148, 0} +"boxuR", {226, 149, 152, 0} +"boxUr", {226, 149, 153, 0} +"boxUR", {226, 149, 154, 0} +"boxv", {226, 148, 130, 0} +"boxV", {226, 149, 145, 0} +"boxvh", {226, 148, 188, 0} +"boxvH", {226, 149, 170, 0} +"boxVh", {226, 149, 171, 0} +"boxVH", {226, 149, 172, 0} +"boxvl", {226, 148, 164, 0} +"boxvL", {226, 149, 161, 0} +"boxVl", {226, 149, 162, 0} +"boxVL", {226, 149, 163, 0} +"boxvr", {226, 148, 156, 0} +"boxvR", {226, 149, 158, 0} +"boxVr", {226, 149, 159, 0} +"boxVR", {226, 149, 160, 0} +"bprime", {226, 128, 181, 0} +"breve", {203, 152, 0} +"Breve", {203, 152, 0} +"brvbar", {194, 166, 0} +"bscr", {240, 157, 146, 183} +"Bscr", {226, 132, 172, 0} +"bsemi", {226, 129, 143, 0} +"bsim", {226, 136, 189, 0} +"bsime", {226, 139, 141, 0} +"bsolb", {226, 167, 133, 0} +"bsol", {92, 0} +"bsolhsub", {226, 159, 136, 0} +"bull", {226, 128, 162, 0} +"bullet", {226, 128, 162, 0} +"bump", {226, 137, 142, 0} +"bumpE", {226, 170, 174, 0} +"bumpe", {226, 137, 143, 0} +"Bumpeq", {226, 137, 142, 0} +"bumpeq", {226, 137, 143, 0} +"Cacute", {196, 134, 0} +"cacute", {196, 135, 0} +"capand", {226, 169, 132, 0} +"capbrcup", {226, 169, 137, 0} +"capcap", {226, 169, 139, 0} +"cap", {226, 136, 169, 0} +"Cap", {226, 139, 146, 0} +"capcup", {226, 169, 135, 0} +"capdot", {226, 169, 128, 0} +"CapitalDifferentialD", {226, 133, 133, 0} +"caps", {226, 136, 169, 0} +"caret", {226, 129, 129, 0} +"caron", {203, 135, 0} +"Cayleys", {226, 132, 173, 0} +"ccaps", {226, 169, 141, 0} +"Ccaron", {196, 140, 0} +"ccaron", {196, 141, 0} +"Ccedil", {195, 135, 0} +"ccedil", {195, 167, 0} +"Ccirc", {196, 136, 0} +"ccirc", {196, 137, 0} +"Cconint", {226, 136, 176, 0} +"ccups", {226, 169, 140, 0} +"ccupssm", {226, 169, 144, 0} +"Cdot", {196, 138, 0} +"cdot", {196, 139, 0} +"cedil", {194, 184, 0} +"Cedilla", {194, 184, 0} +"cemptyv", {226, 166, 178, 0} +"cent", {194, 162, 0} +"centerdot", {194, 183, 0} +"CenterDot", {194, 183, 0} +"cfr", {240, 157, 148, 160} +"Cfr", {226, 132, 173, 0} +"CHcy", {208, 167, 0} +"chcy", {209, 135, 0} +"check", {226, 156, 147, 0} +"checkmark", {226, 156, 147, 0} +"Chi", {206, 167, 0} +"chi", {207, 135, 0} +"circ", {203, 134, 0} +"circeq", {226, 137, 151, 0} +"circlearrowleft", {226, 134, 186, 0} +"circlearrowright", {226, 134, 187, 0} +"circledast", {226, 138, 155, 0} +"circledcirc", {226, 138, 154, 0} +"circleddash", {226, 138, 157, 0} +"CircleDot", {226, 138, 153, 0} +"circledR", {194, 174, 0} +"circledS", {226, 147, 136, 0} +"CircleMinus", {226, 138, 150, 0} +"CirclePlus", {226, 138, 149, 0} +"CircleTimes", {226, 138, 151, 0} +"cir", {226, 151, 139, 0} +"cirE", {226, 167, 131, 0} +"cire", {226, 137, 151, 0} +"cirfnint", {226, 168, 144, 0} +"cirmid", {226, 171, 175, 0} +"cirscir", {226, 167, 130, 0} +"ClockwiseContourIntegral", {226, 136, 178, 0} +"CloseCurlyDoubleQuote", {226, 128, 157, 0} +"CloseCurlyQuote", {226, 128, 153, 0} +"clubs", {226, 153, 163, 0} +"clubsuit", {226, 153, 163, 0} +"colon", {58, 0} +"Colon", {226, 136, 183, 0} +"Colone", {226, 169, 180, 0} +"colone", {226, 137, 148, 0} +"coloneq", {226, 137, 148, 0} +"comma", {44, 0} +"commat", {64, 0} +"comp", {226, 136, 129, 0} +"compfn", {226, 136, 152, 0} +"complement", {226, 136, 129, 0} +"complexes", {226, 132, 130, 0} +"cong", {226, 137, 133, 0} +"congdot", {226, 169, 173, 0} +"Congruent", {226, 137, 161, 0} +"conint", {226, 136, 174, 0} +"Conint", {226, 136, 175, 0} +"ContourIntegral", {226, 136, 174, 0} +"copf", {240, 157, 149, 148} +"Copf", {226, 132, 130, 0} +"coprod", {226, 136, 144, 0} +"Coproduct", {226, 136, 144, 0} +"copy", {194, 169, 0} +"COPY", {194, 169, 0} +"copysr", {226, 132, 151, 0} +"CounterClockwiseContourIntegral", {226, 136, 179, 0} +"crarr", {226, 134, 181, 0} +"cross", {226, 156, 151, 0} +"Cross", {226, 168, 175, 0} +"Cscr", {240, 157, 146, 158} +"cscr", {240, 157, 146, 184} +"csub", {226, 171, 143, 0} +"csube", {226, 171, 145, 0} +"csup", {226, 171, 144, 0} +"csupe", {226, 171, 146, 0} +"ctdot", {226, 139, 175, 0} +"cudarrl", {226, 164, 184, 0} +"cudarrr", {226, 164, 181, 0} +"cuepr", {226, 139, 158, 0} +"cuesc", {226, 139, 159, 0} +"cularr", {226, 134, 182, 0} +"cularrp", {226, 164, 189, 0} +"cupbrcap", {226, 169, 136, 0} +"cupcap", {226, 169, 134, 0} +"CupCap", {226, 137, 141, 0} +"cup", {226, 136, 170, 0} +"Cup", {226, 139, 147, 0} +"cupcup", {226, 169, 138, 0} +"cupdot", {226, 138, 141, 0} +"cupor", {226, 169, 133, 0} +"cups", {226, 136, 170, 0} +"curarr", {226, 134, 183, 0} +"curarrm", {226, 164, 188, 0} +"curlyeqprec", {226, 139, 158, 0} +"curlyeqsucc", {226, 139, 159, 0} +"curlyvee", {226, 139, 142, 0} +"curlywedge", {226, 139, 143, 0} +"curren", {194, 164, 0} +"curvearrowleft", {226, 134, 182, 0} +"curvearrowright", {226, 134, 183, 0} +"cuvee", {226, 139, 142, 0} +"cuwed", {226, 139, 143, 0} +"cwconint", {226, 136, 178, 0} +"cwint", {226, 136, 177, 0} +"cylcty", {226, 140, 173, 0} +"dagger", {226, 128, 160, 0} +"Dagger", {226, 128, 161, 0} +"daleth", {226, 132, 184, 0} +"darr", {226, 134, 147, 0} +"Darr", {226, 134, 161, 0} +"dArr", {226, 135, 147, 0} +"dash", {226, 128, 144, 0} +"Dashv", {226, 171, 164, 0} +"dashv", {226, 138, 163, 0} +"dbkarow", {226, 164, 143, 0} +"dblac", {203, 157, 0} +"Dcaron", {196, 142, 0} +"dcaron", {196, 143, 0} +"Dcy", {208, 148, 0} +"dcy", {208, 180, 0} +"ddagger", {226, 128, 161, 0} +"ddarr", {226, 135, 138, 0} +"DD", {226, 133, 133, 0} +"dd", {226, 133, 134, 0} +"DDotrahd", {226, 164, 145, 0} +"ddotseq", {226, 169, 183, 0} +"deg", {194, 176, 0} +"Del", {226, 136, 135, 0} +"Delta", {206, 148, 0} +"delta", {206, 180, 0} +"demptyv", {226, 166, 177, 0} +"dfisht", {226, 165, 191, 0} +"Dfr", {240, 157, 148, 135} +"dfr", {240, 157, 148, 161} +"dHar", {226, 165, 165, 0} +"dharl", {226, 135, 131, 0} +"dharr", {226, 135, 130, 0} +"DiacriticalAcute", {194, 180, 0} +"DiacriticalDot", {203, 153, 0} +"DiacriticalDoubleAcute", {203, 157, 0} +"DiacriticalGrave", {96, 0} +"DiacriticalTilde", {203, 156, 0} +"diam", {226, 139, 132, 0} +"diamond", {226, 139, 132, 0} +"Diamond", {226, 139, 132, 0} +"diamondsuit", {226, 153, 166, 0} +"diams", {226, 153, 166, 0} +"die", {194, 168, 0} +"DifferentialD", {226, 133, 134, 0} +"digamma", {207, 157, 0} +"disin", {226, 139, 178, 0} +"div", {195, 183, 0} +"divide", {195, 183, 0} +"divideontimes", {226, 139, 135, 0} +"divonx", {226, 139, 135, 0} +"DJcy", {208, 130, 0} +"djcy", {209, 146, 0} +"dlcorn", {226, 140, 158, 0} +"dlcrop", {226, 140, 141, 0} +"dollar", {36, 0} +"Dopf", {240, 157, 148, 187} +"dopf", {240, 157, 149, 149} +"Dot", {194, 168, 0} +"dot", {203, 153, 0} +"DotDot", {226, 131, 156, 0} +"doteq", {226, 137, 144, 0} +"doteqdot", {226, 137, 145, 0} +"DotEqual", {226, 137, 144, 0} +"dotminus", {226, 136, 184, 0} +"dotplus", {226, 136, 148, 0} +"dotsquare", {226, 138, 161, 0} +"doublebarwedge", {226, 140, 134, 0} +"DoubleContourIntegral", {226, 136, 175, 0} +"DoubleDot", {194, 168, 0} +"DoubleDownArrow", {226, 135, 147, 0} +"DoubleLeftArrow", {226, 135, 144, 0} +"DoubleLeftRightArrow", {226, 135, 148, 0} +"DoubleLeftTee", {226, 171, 164, 0} +"DoubleLongLeftArrow", {226, 159, 184, 0} +"DoubleLongLeftRightArrow", {226, 159, 186, 0} +"DoubleLongRightArrow", {226, 159, 185, 0} +"DoubleRightArrow", {226, 135, 146, 0} +"DoubleRightTee", {226, 138, 168, 0} +"DoubleUpArrow", {226, 135, 145, 0} +"DoubleUpDownArrow", {226, 135, 149, 0} +"DoubleVerticalBar", {226, 136, 165, 0} +"DownArrowBar", {226, 164, 147, 0} +"downarrow", {226, 134, 147, 0} +"DownArrow", {226, 134, 147, 0} +"Downarrow", {226, 135, 147, 0} +"DownArrowUpArrow", {226, 135, 181, 0} +"DownBreve", {204, 145, 0} +"downdownarrows", {226, 135, 138, 0} +"downharpoonleft", {226, 135, 131, 0} +"downharpoonright", {226, 135, 130, 0} +"DownLeftRightVector", {226, 165, 144, 0} +"DownLeftTeeVector", {226, 165, 158, 0} +"DownLeftVectorBar", {226, 165, 150, 0} +"DownLeftVector", {226, 134, 189, 0} +"DownRightTeeVector", {226, 165, 159, 0} +"DownRightVectorBar", {226, 165, 151, 0} +"DownRightVector", {226, 135, 129, 0} +"DownTeeArrow", {226, 134, 167, 0} +"DownTee", {226, 138, 164, 0} +"drbkarow", {226, 164, 144, 0} +"drcorn", {226, 140, 159, 0} +"drcrop", {226, 140, 140, 0} +"Dscr", {240, 157, 146, 159} +"dscr", {240, 157, 146, 185} +"DScy", {208, 133, 0} +"dscy", {209, 149, 0} +"dsol", {226, 167, 182, 0} +"Dstrok", {196, 144, 0} +"dstrok", {196, 145, 0} +"dtdot", {226, 139, 177, 0} +"dtri", {226, 150, 191, 0} +"dtrif", {226, 150, 190, 0} +"duarr", {226, 135, 181, 0} +"duhar", {226, 165, 175, 0} +"dwangle", {226, 166, 166, 0} +"DZcy", {208, 143, 0} +"dzcy", {209, 159, 0} +"dzigrarr", {226, 159, 191, 0} +"Eacute", {195, 137, 0} +"eacute", {195, 169, 0} +"easter", {226, 169, 174, 0} +"Ecaron", {196, 154, 0} +"ecaron", {196, 155, 0} +"Ecirc", {195, 138, 0} +"ecirc", {195, 170, 0} +"ecir", {226, 137, 150, 0} +"ecolon", {226, 137, 149, 0} +"Ecy", {208, 173, 0} +"ecy", {209, 141, 0} +"eDDot", {226, 169, 183, 0} +"Edot", {196, 150, 0} +"edot", {196, 151, 0} +"eDot", {226, 137, 145, 0} +"ee", {226, 133, 135, 0} +"efDot", {226, 137, 146, 0} +"Efr", {240, 157, 148, 136} +"efr", {240, 157, 148, 162} +"eg", {226, 170, 154, 0} +"Egrave", {195, 136, 0} +"egrave", {195, 168, 0} +"egs", {226, 170, 150, 0} +"egsdot", {226, 170, 152, 0} +"el", {226, 170, 153, 0} +"Element", {226, 136, 136, 0} +"elinters", {226, 143, 167, 0} +"ell", {226, 132, 147, 0} +"els", {226, 170, 149, 0} +"elsdot", {226, 170, 151, 0} +"Emacr", {196, 146, 0} +"emacr", {196, 147, 0} +"empty", {226, 136, 133, 0} +"emptyset", {226, 136, 133, 0} +"EmptySmallSquare", {226, 151, 187, 0} +"emptyv", {226, 136, 133, 0} +"EmptyVerySmallSquare", {226, 150, 171, 0} +"emsp13", {226, 128, 132, 0} +"emsp14", {226, 128, 133, 0} +"emsp", {226, 128, 131, 0} +"ENG", {197, 138, 0} +"eng", {197, 139, 0} +"ensp", {226, 128, 130, 0} +"Eogon", {196, 152, 0} +"eogon", {196, 153, 0} +"Eopf", {240, 157, 148, 188} +"eopf", {240, 157, 149, 150} +"epar", {226, 139, 149, 0} +"eparsl", {226, 167, 163, 0} +"eplus", {226, 169, 177, 0} +"epsi", {206, 181, 0} +"Epsilon", {206, 149, 0} +"epsilon", {206, 181, 0} +"epsiv", {207, 181, 0} +"eqcirc", {226, 137, 150, 0} +"eqcolon", {226, 137, 149, 0} +"eqsim", {226, 137, 130, 0} +"eqslantgtr", {226, 170, 150, 0} +"eqslantless", {226, 170, 149, 0} +"Equal", {226, 169, 181, 0} +"equals", {61, 0} +"EqualTilde", {226, 137, 130, 0} +"equest", {226, 137, 159, 0} +"Equilibrium", {226, 135, 140, 0} +"equiv", {226, 137, 161, 0} +"equivDD", {226, 169, 184, 0} +"eqvparsl", {226, 167, 165, 0} +"erarr", {226, 165, 177, 0} +"erDot", {226, 137, 147, 0} +"escr", {226, 132, 175, 0} +"Escr", {226, 132, 176, 0} +"esdot", {226, 137, 144, 0} +"Esim", {226, 169, 179, 0} +"esim", {226, 137, 130, 0} +"Eta", {206, 151, 0} +"eta", {206, 183, 0} +"ETH", {195, 144, 0} +"eth", {195, 176, 0} +"Euml", {195, 139, 0} +"euml", {195, 171, 0} +"euro", {226, 130, 172, 0} +"excl", {33, 0} +"exist", {226, 136, 131, 0} +"Exists", {226, 136, 131, 0} +"expectation", {226, 132, 176, 0} +"exponentiale", {226, 133, 135, 0} +"ExponentialE", {226, 133, 135, 0} +"fallingdotseq", {226, 137, 146, 0} +"Fcy", {208, 164, 0} +"fcy", {209, 132, 0} +"female", {226, 153, 128, 0} +"ffilig", {239, 172, 131, 0} +"fflig", {239, 172, 128, 0} +"ffllig", {239, 172, 132, 0} +"Ffr", {240, 157, 148, 137} +"ffr", {240, 157, 148, 163} +"filig", {239, 172, 129, 0} +"FilledSmallSquare", {226, 151, 188, 0} +"FilledVerySmallSquare", {226, 150, 170, 0} +"fjlig", {102, 0} +"flat", {226, 153, 173, 0} +"fllig", {239, 172, 130, 0} +"fltns", {226, 150, 177, 0} +"fnof", {198, 146, 0} +"Fopf", {240, 157, 148, 189} +"fopf", {240, 157, 149, 151} +"forall", {226, 136, 128, 0} +"ForAll", {226, 136, 128, 0} +"fork", {226, 139, 148, 0} +"forkv", {226, 171, 153, 0} +"Fouriertrf", {226, 132, 177, 0} +"fpartint", {226, 168, 141, 0} +"frac12", {194, 189, 0} +"frac13", {226, 133, 147, 0} +"frac14", {194, 188, 0} +"frac15", {226, 133, 149, 0} +"frac16", {226, 133, 153, 0} +"frac18", {226, 133, 155, 0} +"frac23", {226, 133, 148, 0} +"frac25", {226, 133, 150, 0} +"frac34", {194, 190, 0} +"frac35", {226, 133, 151, 0} +"frac38", {226, 133, 156, 0} +"frac45", {226, 133, 152, 0} +"frac56", {226, 133, 154, 0} +"frac58", {226, 133, 157, 0} +"frac78", {226, 133, 158, 0} +"frasl", {226, 129, 132, 0} +"frown", {226, 140, 162, 0} +"fscr", {240, 157, 146, 187} +"Fscr", {226, 132, 177, 0} +"gacute", {199, 181, 0} +"Gamma", {206, 147, 0} +"gamma", {206, 179, 0} +"Gammad", {207, 156, 0} +"gammad", {207, 157, 0} +"gap", {226, 170, 134, 0} +"Gbreve", {196, 158, 0} +"gbreve", {196, 159, 0} +"Gcedil", {196, 162, 0} +"Gcirc", {196, 156, 0} +"gcirc", {196, 157, 0} +"Gcy", {208, 147, 0} +"gcy", {208, 179, 0} +"Gdot", {196, 160, 0} +"gdot", {196, 161, 0} +"ge", {226, 137, 165, 0} +"gE", {226, 137, 167, 0} +"gEl", {226, 170, 140, 0} +"gel", {226, 139, 155, 0} +"geq", {226, 137, 165, 0} +"geqq", {226, 137, 167, 0} +"geqslant", {226, 169, 190, 0} +"gescc", {226, 170, 169, 0} +"ges", {226, 169, 190, 0} +"gesdot", {226, 170, 128, 0} +"gesdoto", {226, 170, 130, 0} +"gesdotol", {226, 170, 132, 0} +"gesl", {226, 139, 155, 0} +"gesles", {226, 170, 148, 0} +"Gfr", {240, 157, 148, 138} +"gfr", {240, 157, 148, 164} +"gg", {226, 137, 171, 0} +"Gg", {226, 139, 153, 0} +"ggg", {226, 139, 153, 0} +"gimel", {226, 132, 183, 0} +"GJcy", {208, 131, 0} +"gjcy", {209, 147, 0} +"gla", {226, 170, 165, 0} +"gl", {226, 137, 183, 0} +"glE", {226, 170, 146, 0} +"glj", {226, 170, 164, 0} +"gnap", {226, 170, 138, 0} +"gnapprox", {226, 170, 138, 0} +"gne", {226, 170, 136, 0} +"gnE", {226, 137, 169, 0} +"gneq", {226, 170, 136, 0} +"gneqq", {226, 137, 169, 0} +"gnsim", {226, 139, 167, 0} +"Gopf", {240, 157, 148, 190} +"gopf", {240, 157, 149, 152} +"grave", {96, 0} +"GreaterEqual", {226, 137, 165, 0} +"GreaterEqualLess", {226, 139, 155, 0} +"GreaterFullEqual", {226, 137, 167, 0} +"GreaterGreater", {226, 170, 162, 0} +"GreaterLess", {226, 137, 183, 0} +"GreaterSlantEqual", {226, 169, 190, 0} +"GreaterTilde", {226, 137, 179, 0} +"Gscr", {240, 157, 146, 162} +"gscr", {226, 132, 138, 0} +"gsim", {226, 137, 179, 0} +"gsime", {226, 170, 142, 0} +"gsiml", {226, 170, 144, 0} +"gtcc", {226, 170, 167, 0} +"gtcir", {226, 169, 186, 0} +"gt", {62, 0} +"GT", {62, 0} +"Gt", {226, 137, 171, 0} +"gtdot", {226, 139, 151, 0} +"gtlPar", {226, 166, 149, 0} +"gtquest", {226, 169, 188, 0} +"gtrapprox", {226, 170, 134, 0} +"gtrarr", {226, 165, 184, 0} +"gtrdot", {226, 139, 151, 0} +"gtreqless", {226, 139, 155, 0} +"gtreqqless", {226, 170, 140, 0} +"gtrless", {226, 137, 183, 0} +"gtrsim", {226, 137, 179, 0} +"gvertneqq", {226, 137, 169, 0} +"gvnE", {226, 137, 169, 0} +"Hacek", {203, 135, 0} +"hairsp", {226, 128, 138, 0} +"half", {194, 189, 0} +"hamilt", {226, 132, 139, 0} +"HARDcy", {208, 170, 0} +"hardcy", {209, 138, 0} +"harrcir", {226, 165, 136, 0} +"harr", {226, 134, 148, 0} +"hArr", {226, 135, 148, 0} +"harrw", {226, 134, 173, 0} +"Hat", {94, 0} +"hbar", {226, 132, 143, 0} +"Hcirc", {196, 164, 0} +"hcirc", {196, 165, 0} +"hearts", {226, 153, 165, 0} +"heartsuit", {226, 153, 165, 0} +"hellip", {226, 128, 166, 0} +"hercon", {226, 138, 185, 0} +"hfr", {240, 157, 148, 165} +"Hfr", {226, 132, 140, 0} +"HilbertSpace", {226, 132, 139, 0} +"hksearow", {226, 164, 165, 0} +"hkswarow", {226, 164, 166, 0} +"hoarr", {226, 135, 191, 0} +"homtht", {226, 136, 187, 0} +"hookleftarrow", {226, 134, 169, 0} +"hookrightarrow", {226, 134, 170, 0} +"hopf", {240, 157, 149, 153} +"Hopf", {226, 132, 141, 0} +"horbar", {226, 128, 149, 0} +"HorizontalLine", {226, 148, 128, 0} +"hscr", {240, 157, 146, 189} +"Hscr", {226, 132, 139, 0} +"hslash", {226, 132, 143, 0} +"Hstrok", {196, 166, 0} +"hstrok", {196, 167, 0} +"HumpDownHump", {226, 137, 142, 0} +"HumpEqual", {226, 137, 143, 0} +"hybull", {226, 129, 131, 0} +"hyphen", {226, 128, 144, 0} +"Iacute", {195, 141, 0} +"iacute", {195, 173, 0} +"ic", {226, 129, 163, 0} +"Icirc", {195, 142, 0} +"icirc", {195, 174, 0} +"Icy", {208, 152, 0} +"icy", {208, 184, 0} +"Idot", {196, 176, 0} +"IEcy", {208, 149, 0} +"iecy", {208, 181, 0} +"iexcl", {194, 161, 0} +"iff", {226, 135, 148, 0} +"ifr", {240, 157, 148, 166} +"Ifr", {226, 132, 145, 0} +"Igrave", {195, 140, 0} +"igrave", {195, 172, 0} +"ii", {226, 133, 136, 0} +"iiiint", {226, 168, 140, 0} +"iiint", {226, 136, 173, 0} +"iinfin", {226, 167, 156, 0} +"iiota", {226, 132, 169, 0} +"IJlig", {196, 178, 0} +"ijlig", {196, 179, 0} +"Imacr", {196, 170, 0} +"imacr", {196, 171, 0} +"image", {226, 132, 145, 0} +"ImaginaryI", {226, 133, 136, 0} +"imagline", {226, 132, 144, 0} +"imagpart", {226, 132, 145, 0} +"imath", {196, 177, 0} +"Im", {226, 132, 145, 0} +"imof", {226, 138, 183, 0} +"imped", {198, 181, 0} +"Implies", {226, 135, 146, 0} +"incare", {226, 132, 133, 0} +"in", {226, 136, 136, 0} +"infin", {226, 136, 158, 0} +"infintie", {226, 167, 157, 0} +"inodot", {196, 177, 0} +"intcal", {226, 138, 186, 0} +"int", {226, 136, 171, 0} +"Int", {226, 136, 172, 0} +"integers", {226, 132, 164, 0} +"Integral", {226, 136, 171, 0} +"intercal", {226, 138, 186, 0} +"Intersection", {226, 139, 130, 0} +"intlarhk", {226, 168, 151, 0} +"intprod", {226, 168, 188, 0} +"InvisibleComma", {226, 129, 163, 0} +"InvisibleTimes", {226, 129, 162, 0} +"IOcy", {208, 129, 0} +"iocy", {209, 145, 0} +"Iogon", {196, 174, 0} +"iogon", {196, 175, 0} +"Iopf", {240, 157, 149, 128} +"iopf", {240, 157, 149, 154} +"Iota", {206, 153, 0} +"iota", {206, 185, 0} +"iprod", {226, 168, 188, 0} +"iquest", {194, 191, 0} +"iscr", {240, 157, 146, 190} +"Iscr", {226, 132, 144, 0} +"isin", {226, 136, 136, 0} +"isindot", {226, 139, 181, 0} +"isinE", {226, 139, 185, 0} +"isins", {226, 139, 180, 0} +"isinsv", {226, 139, 179, 0} +"isinv", {226, 136, 136, 0} +"it", {226, 129, 162, 0} +"Itilde", {196, 168, 0} +"itilde", {196, 169, 0} +"Iukcy", {208, 134, 0} +"iukcy", {209, 150, 0} +"Iuml", {195, 143, 0} +"iuml", {195, 175, 0} +"Jcirc", {196, 180, 0} +"jcirc", {196, 181, 0} +"Jcy", {208, 153, 0} +"jcy", {208, 185, 0} +"Jfr", {240, 157, 148, 141} +"jfr", {240, 157, 148, 167} +"jmath", {200, 183, 0} +"Jopf", {240, 157, 149, 129} +"jopf", {240, 157, 149, 155} +"Jscr", {240, 157, 146, 165} +"jscr", {240, 157, 146, 191} +"Jsercy", {208, 136, 0} +"jsercy", {209, 152, 0} +"Jukcy", {208, 132, 0} +"jukcy", {209, 148, 0} +"Kappa", {206, 154, 0} +"kappa", {206, 186, 0} +"kappav", {207, 176, 0} +"Kcedil", {196, 182, 0} +"kcedil", {196, 183, 0} +"Kcy", {208, 154, 0} +"kcy", {208, 186, 0} +"Kfr", {240, 157, 148, 142} +"kfr", {240, 157, 148, 168} +"kgreen", {196, 184, 0} +"KHcy", {208, 165, 0} +"khcy", {209, 133, 0} +"KJcy", {208, 140, 0} +"kjcy", {209, 156, 0} +"Kopf", {240, 157, 149, 130} +"kopf", {240, 157, 149, 156} +"Kscr", {240, 157, 146, 166} +"kscr", {240, 157, 147, 128} +"lAarr", {226, 135, 154, 0} +"Lacute", {196, 185, 0} +"lacute", {196, 186, 0} +"laemptyv", {226, 166, 180, 0} +"lagran", {226, 132, 146, 0} +"Lambda", {206, 155, 0} +"lambda", {206, 187, 0} +"lang", {226, 159, 168, 0} +"Lang", {226, 159, 170, 0} +"langd", {226, 166, 145, 0} +"langle", {226, 159, 168, 0} +"lap", {226, 170, 133, 0} +"Laplacetrf", {226, 132, 146, 0} +"laquo", {194, 171, 0} +"larrb", {226, 135, 164, 0} +"larrbfs", {226, 164, 159, 0} +"larr", {226, 134, 144, 0} +"Larr", {226, 134, 158, 0} +"lArr", {226, 135, 144, 0} +"larrfs", {226, 164, 157, 0} +"larrhk", {226, 134, 169, 0} +"larrlp", {226, 134, 171, 0} +"larrpl", {226, 164, 185, 0} +"larrsim", {226, 165, 179, 0} +"larrtl", {226, 134, 162, 0} +"latail", {226, 164, 153, 0} +"lAtail", {226, 164, 155, 0} +"lat", {226, 170, 171, 0} +"late", {226, 170, 173, 0} +"lates", {226, 170, 173, 0} +"lbarr", {226, 164, 140, 0} +"lBarr", {226, 164, 142, 0} +"lbbrk", {226, 157, 178, 0} +"lbrace", {123, 0} +"lbrack", {91, 0} +"lbrke", {226, 166, 139, 0} +"lbrksld", {226, 166, 143, 0} +"lbrkslu", {226, 166, 141, 0} +"Lcaron", {196, 189, 0} +"lcaron", {196, 190, 0} +"Lcedil", {196, 187, 0} +"lcedil", {196, 188, 0} +"lceil", {226, 140, 136, 0} +"lcub", {123, 0} +"Lcy", {208, 155, 0} +"lcy", {208, 187, 0} +"ldca", {226, 164, 182, 0} +"ldquo", {226, 128, 156, 0} +"ldquor", {226, 128, 158, 0} +"ldrdhar", {226, 165, 167, 0} +"ldrushar", {226, 165, 139, 0} +"ldsh", {226, 134, 178, 0} +"le", {226, 137, 164, 0} +"lE", {226, 137, 166, 0} +"LeftAngleBracket", {226, 159, 168, 0} +"LeftArrowBar", {226, 135, 164, 0} +"leftarrow", {226, 134, 144, 0} +"LeftArrow", {226, 134, 144, 0} +"Leftarrow", {226, 135, 144, 0} +"LeftArrowRightArrow", {226, 135, 134, 0} +"leftarrowtail", {226, 134, 162, 0} +"LeftCeiling", {226, 140, 136, 0} +"LeftDoubleBracket", {226, 159, 166, 0} +"LeftDownTeeVector", {226, 165, 161, 0} +"LeftDownVectorBar", {226, 165, 153, 0} +"LeftDownVector", {226, 135, 131, 0} +"LeftFloor", {226, 140, 138, 0} +"leftharpoondown", {226, 134, 189, 0} +"leftharpoonup", {226, 134, 188, 0} +"leftleftarrows", {226, 135, 135, 0} +"leftrightarrow", {226, 134, 148, 0} +"LeftRightArrow", {226, 134, 148, 0} +"Leftrightarrow", {226, 135, 148, 0} +"leftrightarrows", {226, 135, 134, 0} +"leftrightharpoons", {226, 135, 139, 0} +"leftrightsquigarrow", {226, 134, 173, 0} +"LeftRightVector", {226, 165, 142, 0} +"LeftTeeArrow", {226, 134, 164, 0} +"LeftTee", {226, 138, 163, 0} +"LeftTeeVector", {226, 165, 154, 0} +"leftthreetimes", {226, 139, 139, 0} +"LeftTriangleBar", {226, 167, 143, 0} +"LeftTriangle", {226, 138, 178, 0} +"LeftTriangleEqual", {226, 138, 180, 0} +"LeftUpDownVector", {226, 165, 145, 0} +"LeftUpTeeVector", {226, 165, 160, 0} +"LeftUpVectorBar", {226, 165, 152, 0} +"LeftUpVector", {226, 134, 191, 0} +"LeftVectorBar", {226, 165, 146, 0} +"LeftVector", {226, 134, 188, 0} +"lEg", {226, 170, 139, 0} +"leg", {226, 139, 154, 0} +"leq", {226, 137, 164, 0} +"leqq", {226, 137, 166, 0} +"leqslant", {226, 169, 189, 0} +"lescc", {226, 170, 168, 0} +"les", {226, 169, 189, 0} +"lesdot", {226, 169, 191, 0} +"lesdoto", {226, 170, 129, 0} +"lesdotor", {226, 170, 131, 0} +"lesg", {226, 139, 154, 0} +"lesges", {226, 170, 147, 0} +"lessapprox", {226, 170, 133, 0} +"lessdot", {226, 139, 150, 0} +"lesseqgtr", {226, 139, 154, 0} +"lesseqqgtr", {226, 170, 139, 0} +"LessEqualGreater", {226, 139, 154, 0} +"LessFullEqual", {226, 137, 166, 0} +"LessGreater", {226, 137, 182, 0} +"lessgtr", {226, 137, 182, 0} +"LessLess", {226, 170, 161, 0} +"lesssim", {226, 137, 178, 0} +"LessSlantEqual", {226, 169, 189, 0} +"LessTilde", {226, 137, 178, 0} +"lfisht", {226, 165, 188, 0} +"lfloor", {226, 140, 138, 0} +"Lfr", {240, 157, 148, 143} +"lfr", {240, 157, 148, 169} +"lg", {226, 137, 182, 0} +"lgE", {226, 170, 145, 0} +"lHar", {226, 165, 162, 0} +"lhard", {226, 134, 189, 0} +"lharu", {226, 134, 188, 0} +"lharul", {226, 165, 170, 0} +"lhblk", {226, 150, 132, 0} +"LJcy", {208, 137, 0} +"ljcy", {209, 153, 0} +"llarr", {226, 135, 135, 0} +"ll", {226, 137, 170, 0} +"Ll", {226, 139, 152, 0} +"llcorner", {226, 140, 158, 0} +"Lleftarrow", {226, 135, 154, 0} +"llhard", {226, 165, 171, 0} +"lltri", {226, 151, 186, 0} +"Lmidot", {196, 191, 0} +"lmidot", {197, 128, 0} +"lmoustache", {226, 142, 176, 0} +"lmoust", {226, 142, 176, 0} +"lnap", {226, 170, 137, 0} +"lnapprox", {226, 170, 137, 0} +"lne", {226, 170, 135, 0} +"lnE", {226, 137, 168, 0} +"lneq", {226, 170, 135, 0} +"lneqq", {226, 137, 168, 0} +"lnsim", {226, 139, 166, 0} +"loang", {226, 159, 172, 0} +"loarr", {226, 135, 189, 0} +"lobrk", {226, 159, 166, 0} +"longleftarrow", {226, 159, 181, 0} +"LongLeftArrow", {226, 159, 181, 0} +"Longleftarrow", {226, 159, 184, 0} +"longleftrightarrow", {226, 159, 183, 0} +"LongLeftRightArrow", {226, 159, 183, 0} +"Longleftrightarrow", {226, 159, 186, 0} +"longmapsto", {226, 159, 188, 0} +"longrightarrow", {226, 159, 182, 0} +"LongRightArrow", {226, 159, 182, 0} +"Longrightarrow", {226, 159, 185, 0} +"looparrowleft", {226, 134, 171, 0} +"looparrowright", {226, 134, 172, 0} +"lopar", {226, 166, 133, 0} +"Lopf", {240, 157, 149, 131} +"lopf", {240, 157, 149, 157} +"loplus", {226, 168, 173, 0} +"lotimes", {226, 168, 180, 0} +"lowast", {226, 136, 151, 0} +"lowbar", {95, 0} +"LowerLeftArrow", {226, 134, 153, 0} +"LowerRightArrow", {226, 134, 152, 0} +"loz", {226, 151, 138, 0} +"lozenge", {226, 151, 138, 0} +"lozf", {226, 167, 171, 0} +"lpar", {40, 0} +"lparlt", {226, 166, 147, 0} +"lrarr", {226, 135, 134, 0} +"lrcorner", {226, 140, 159, 0} +"lrhar", {226, 135, 139, 0} +"lrhard", {226, 165, 173, 0} +"lrm", {226, 128, 142, 0} +"lrtri", {226, 138, 191, 0} +"lsaquo", {226, 128, 185, 0} +"lscr", {240, 157, 147, 129} +"Lscr", {226, 132, 146, 0} +"lsh", {226, 134, 176, 0} +"Lsh", {226, 134, 176, 0} +"lsim", {226, 137, 178, 0} +"lsime", {226, 170, 141, 0} +"lsimg", {226, 170, 143, 0} +"lsqb", {91, 0} +"lsquo", {226, 128, 152, 0} +"lsquor", {226, 128, 154, 0} +"Lstrok", {197, 129, 0} +"lstrok", {197, 130, 0} +"ltcc", {226, 170, 166, 0} +"ltcir", {226, 169, 185, 0} +"lt", {60, 0} +"LT", {60, 0} +"Lt", {226, 137, 170, 0} +"ltdot", {226, 139, 150, 0} +"lthree", {226, 139, 139, 0} +"ltimes", {226, 139, 137, 0} +"ltlarr", {226, 165, 182, 0} +"ltquest", {226, 169, 187, 0} +"ltri", {226, 151, 131, 0} +"ltrie", {226, 138, 180, 0} +"ltrif", {226, 151, 130, 0} +"ltrPar", {226, 166, 150, 0} +"lurdshar", {226, 165, 138, 0} +"luruhar", {226, 165, 166, 0} +"lvertneqq", {226, 137, 168, 0} +"lvnE", {226, 137, 168, 0} +"macr", {194, 175, 0} +"male", {226, 153, 130, 0} +"malt", {226, 156, 160, 0} +"maltese", {226, 156, 160, 0} +"Map", {226, 164, 133, 0} +"map", {226, 134, 166, 0} +"mapsto", {226, 134, 166, 0} +"mapstodown", {226, 134, 167, 0} +"mapstoleft", {226, 134, 164, 0} +"mapstoup", {226, 134, 165, 0} +"marker", {226, 150, 174, 0} +"mcomma", {226, 168, 169, 0} +"Mcy", {208, 156, 0} +"mcy", {208, 188, 0} +"mdash", {226, 128, 148, 0} +"mDDot", {226, 136, 186, 0} +"measuredangle", {226, 136, 161, 0} +"MediumSpace", {226, 129, 159, 0} +"Mellintrf", {226, 132, 179, 0} +"Mfr", {240, 157, 148, 144} +"mfr", {240, 157, 148, 170} +"mho", {226, 132, 167, 0} +"micro", {194, 181, 0} +"midast", {42, 0} +"midcir", {226, 171, 176, 0} +"mid", {226, 136, 163, 0} +"middot", {194, 183, 0} +"minusb", {226, 138, 159, 0} +"minus", {226, 136, 146, 0} +"minusd", {226, 136, 184, 0} +"minusdu", {226, 168, 170, 0} +"MinusPlus", {226, 136, 147, 0} +"mlcp", {226, 171, 155, 0} +"mldr", {226, 128, 166, 0} +"mnplus", {226, 136, 147, 0} +"models", {226, 138, 167, 0} +"Mopf", {240, 157, 149, 132} +"mopf", {240, 157, 149, 158} +"mp", {226, 136, 147, 0} +"mscr", {240, 157, 147, 130} +"Mscr", {226, 132, 179, 0} +"mstpos", {226, 136, 190, 0} +"Mu", {206, 156, 0} +"mu", {206, 188, 0} +"multimap", {226, 138, 184, 0} +"mumap", {226, 138, 184, 0} +"nabla", {226, 136, 135, 0} +"Nacute", {197, 131, 0} +"nacute", {197, 132, 0} +"nang", {226, 136, 160, 0} +"nap", {226, 137, 137, 0} +"napE", {226, 169, 176, 0} +"napid", {226, 137, 139, 0} +"napos", {197, 137, 0} +"napprox", {226, 137, 137, 0} +"natural", {226, 153, 174, 0} +"naturals", {226, 132, 149, 0} +"natur", {226, 153, 174, 0} +"nbsp", {194, 160, 0} +"nbump", {226, 137, 142, 0} +"nbumpe", {226, 137, 143, 0} +"ncap", {226, 169, 131, 0} +"Ncaron", {197, 135, 0} +"ncaron", {197, 136, 0} +"Ncedil", {197, 133, 0} +"ncedil", {197, 134, 0} +"ncong", {226, 137, 135, 0} +"ncongdot", {226, 169, 173, 0} +"ncup", {226, 169, 130, 0} +"Ncy", {208, 157, 0} +"ncy", {208, 189, 0} +"ndash", {226, 128, 147, 0} +"nearhk", {226, 164, 164, 0} +"nearr", {226, 134, 151, 0} +"neArr", {226, 135, 151, 0} +"nearrow", {226, 134, 151, 0} +"ne", {226, 137, 160, 0} +"nedot", {226, 137, 144, 0} +"NegativeMediumSpace", {226, 128, 139, 0} +"NegativeThickSpace", {226, 128, 139, 0} +"NegativeThinSpace", {226, 128, 139, 0} +"NegativeVeryThinSpace", {226, 128, 139, 0} +"nequiv", {226, 137, 162, 0} +"nesear", {226, 164, 168, 0} +"nesim", {226, 137, 130, 0} +"NestedGreaterGreater", {226, 137, 171, 0} +"NestedLessLess", {226, 137, 170, 0} +"NewLine", {10, 0} +"nexist", {226, 136, 132, 0} +"nexists", {226, 136, 132, 0} +"Nfr", {240, 157, 148, 145} +"nfr", {240, 157, 148, 171} +"ngE", {226, 137, 167, 0} +"nge", {226, 137, 177, 0} +"ngeq", {226, 137, 177, 0} +"ngeqq", {226, 137, 167, 0} +"ngeqslant", {226, 169, 190, 0} +"nges", {226, 169, 190, 0} +"nGg", {226, 139, 153, 0} +"ngsim", {226, 137, 181, 0} +"nGt", {226, 137, 171, 0} +"ngt", {226, 137, 175, 0} +"ngtr", {226, 137, 175, 0} +"nGtv", {226, 137, 171, 0} +"nharr", {226, 134, 174, 0} +"nhArr", {226, 135, 142, 0} +"nhpar", {226, 171, 178, 0} +"ni", {226, 136, 139, 0} +"nis", {226, 139, 188, 0} +"nisd", {226, 139, 186, 0} +"niv", {226, 136, 139, 0} +"NJcy", {208, 138, 0} +"njcy", {209, 154, 0} +"nlarr", {226, 134, 154, 0} +"nlArr", {226, 135, 141, 0} +"nldr", {226, 128, 165, 0} +"nlE", {226, 137, 166, 0} +"nle", {226, 137, 176, 0} +"nleftarrow", {226, 134, 154, 0} +"nLeftarrow", {226, 135, 141, 0} +"nleftrightarrow", {226, 134, 174, 0} +"nLeftrightarrow", {226, 135, 142, 0} +"nleq", {226, 137, 176, 0} +"nleqq", {226, 137, 166, 0} +"nleqslant", {226, 169, 189, 0} +"nles", {226, 169, 189, 0} +"nless", {226, 137, 174, 0} +"nLl", {226, 139, 152, 0} +"nlsim", {226, 137, 180, 0} +"nLt", {226, 137, 170, 0} +"nlt", {226, 137, 174, 0} +"nltri", {226, 139, 170, 0} +"nltrie", {226, 139, 172, 0} +"nLtv", {226, 137, 170, 0} +"nmid", {226, 136, 164, 0} +"NoBreak", {226, 129, 160, 0} +"NonBreakingSpace", {194, 160, 0} +"nopf", {240, 157, 149, 159} +"Nopf", {226, 132, 149, 0} +"Not", {226, 171, 172, 0} +"not", {194, 172, 0} +"NotCongruent", {226, 137, 162, 0} +"NotCupCap", {226, 137, 173, 0} +"NotDoubleVerticalBar", {226, 136, 166, 0} +"NotElement", {226, 136, 137, 0} +"NotEqual", {226, 137, 160, 0} +"NotEqualTilde", {226, 137, 130, 0} +"NotExists", {226, 136, 132, 0} +"NotGreater", {226, 137, 175, 0} +"NotGreaterEqual", {226, 137, 177, 0} +"NotGreaterFullEqual", {226, 137, 167, 0} +"NotGreaterGreater", {226, 137, 171, 0} +"NotGreaterLess", {226, 137, 185, 0} +"NotGreaterSlantEqual", {226, 169, 190, 0} +"NotGreaterTilde", {226, 137, 181, 0} +"NotHumpDownHump", {226, 137, 142, 0} +"NotHumpEqual", {226, 137, 143, 0} +"notin", {226, 136, 137, 0} +"notindot", {226, 139, 181, 0} +"notinE", {226, 139, 185, 0} +"notinva", {226, 136, 137, 0} +"notinvb", {226, 139, 183, 0} +"notinvc", {226, 139, 182, 0} +"NotLeftTriangleBar", {226, 167, 143, 0} +"NotLeftTriangle", {226, 139, 170, 0} +"NotLeftTriangleEqual", {226, 139, 172, 0} +"NotLess", {226, 137, 174, 0} +"NotLessEqual", {226, 137, 176, 0} +"NotLessGreater", {226, 137, 184, 0} +"NotLessLess", {226, 137, 170, 0} +"NotLessSlantEqual", {226, 169, 189, 0} +"NotLessTilde", {226, 137, 180, 0} +"NotNestedGreaterGreater", {226, 170, 162, 0} +"NotNestedLessLess", {226, 170, 161, 0} +"notni", {226, 136, 140, 0} +"notniva", {226, 136, 140, 0} +"notnivb", {226, 139, 190, 0} +"notnivc", {226, 139, 189, 0} +"NotPrecedes", {226, 138, 128, 0} +"NotPrecedesEqual", {226, 170, 175, 0} +"NotPrecedesSlantEqual", {226, 139, 160, 0} +"NotReverseElement", {226, 136, 140, 0} +"NotRightTriangleBar", {226, 167, 144, 0} +"NotRightTriangle", {226, 139, 171, 0} +"NotRightTriangleEqual", {226, 139, 173, 0} +"NotSquareSubset", {226, 138, 143, 0} +"NotSquareSubsetEqual", {226, 139, 162, 0} +"NotSquareSuperset", {226, 138, 144, 0} +"NotSquareSupersetEqual", {226, 139, 163, 0} +"NotSubset", {226, 138, 130, 0} +"NotSubsetEqual", {226, 138, 136, 0} +"NotSucceeds", {226, 138, 129, 0} +"NotSucceedsEqual", {226, 170, 176, 0} +"NotSucceedsSlantEqual", {226, 139, 161, 0} +"NotSucceedsTilde", {226, 137, 191, 0} +"NotSuperset", {226, 138, 131, 0} +"NotSupersetEqual", {226, 138, 137, 0} +"NotTilde", {226, 137, 129, 0} +"NotTildeEqual", {226, 137, 132, 0} +"NotTildeFullEqual", {226, 137, 135, 0} +"NotTildeTilde", {226, 137, 137, 0} +"NotVerticalBar", {226, 136, 164, 0} +"nparallel", {226, 136, 166, 0} +"npar", {226, 136, 166, 0} +"nparsl", {226, 171, 189, 0} +"npart", {226, 136, 130, 0} +"npolint", {226, 168, 148, 0} +"npr", {226, 138, 128, 0} +"nprcue", {226, 139, 160, 0} +"nprec", {226, 138, 128, 0} +"npreceq", {226, 170, 175, 0} +"npre", {226, 170, 175, 0} +"nrarrc", {226, 164, 179, 0} +"nrarr", {226, 134, 155, 0} +"nrArr", {226, 135, 143, 0} +"nrarrw", {226, 134, 157, 0} +"nrightarrow", {226, 134, 155, 0} +"nRightarrow", {226, 135, 143, 0} +"nrtri", {226, 139, 171, 0} +"nrtrie", {226, 139, 173, 0} +"nsc", {226, 138, 129, 0} +"nsccue", {226, 139, 161, 0} +"nsce", {226, 170, 176, 0} +"Nscr", {240, 157, 146, 169} +"nscr", {240, 157, 147, 131} +"nshortmid", {226, 136, 164, 0} +"nshortparallel", {226, 136, 166, 0} +"nsim", {226, 137, 129, 0} +"nsime", {226, 137, 132, 0} +"nsimeq", {226, 137, 132, 0} +"nsmid", {226, 136, 164, 0} +"nspar", {226, 136, 166, 0} +"nsqsube", {226, 139, 162, 0} +"nsqsupe", {226, 139, 163, 0} +"nsub", {226, 138, 132, 0} +"nsubE", {226, 171, 133, 0} +"nsube", {226, 138, 136, 0} +"nsubset", {226, 138, 130, 0} +"nsubseteq", {226, 138, 136, 0} +"nsubseteqq", {226, 171, 133, 0} +"nsucc", {226, 138, 129, 0} +"nsucceq", {226, 170, 176, 0} +"nsup", {226, 138, 133, 0} +"nsupE", {226, 171, 134, 0} +"nsupe", {226, 138, 137, 0} +"nsupset", {226, 138, 131, 0} +"nsupseteq", {226, 138, 137, 0} +"nsupseteqq", {226, 171, 134, 0} +"ntgl", {226, 137, 185, 0} +"Ntilde", {195, 145, 0} +"ntilde", {195, 177, 0} +"ntlg", {226, 137, 184, 0} +"ntriangleleft", {226, 139, 170, 0} +"ntrianglelefteq", {226, 139, 172, 0} +"ntriangleright", {226, 139, 171, 0} +"ntrianglerighteq", {226, 139, 173, 0} +"Nu", {206, 157, 0} +"nu", {206, 189, 0} +"num", {35, 0} +"numero", {226, 132, 150, 0} +"numsp", {226, 128, 135, 0} +"nvap", {226, 137, 141, 0} +"nvdash", {226, 138, 172, 0} +"nvDash", {226, 138, 173, 0} +"nVdash", {226, 138, 174, 0} +"nVDash", {226, 138, 175, 0} +"nvge", {226, 137, 165, 0} +"nvgt", {62, 0} +"nvHarr", {226, 164, 132, 0} +"nvinfin", {226, 167, 158, 0} +"nvlArr", {226, 164, 130, 0} +"nvle", {226, 137, 164, 0} +"nvlt", {60, 0} +"nvltrie", {226, 138, 180, 0} +"nvrArr", {226, 164, 131, 0} +"nvrtrie", {226, 138, 181, 0} +"nvsim", {226, 136, 188, 0} +"nwarhk", {226, 164, 163, 0} +"nwarr", {226, 134, 150, 0} +"nwArr", {226, 135, 150, 0} +"nwarrow", {226, 134, 150, 0} +"nwnear", {226, 164, 167, 0} +"Oacute", {195, 147, 0} +"oacute", {195, 179, 0} +"oast", {226, 138, 155, 0} +"Ocirc", {195, 148, 0} +"ocirc", {195, 180, 0} +"ocir", {226, 138, 154, 0} +"Ocy", {208, 158, 0} +"ocy", {208, 190, 0} +"odash", {226, 138, 157, 0} +"Odblac", {197, 144, 0} +"odblac", {197, 145, 0} +"odiv", {226, 168, 184, 0} +"odot", {226, 138, 153, 0} +"odsold", {226, 166, 188, 0} +"OElig", {197, 146, 0} +"oelig", {197, 147, 0} +"ofcir", {226, 166, 191, 0} +"Ofr", {240, 157, 148, 146} +"ofr", {240, 157, 148, 172} +"ogon", {203, 155, 0} +"Ograve", {195, 146, 0} +"ograve", {195, 178, 0} +"ogt", {226, 167, 129, 0} +"ohbar", {226, 166, 181, 0} +"ohm", {206, 169, 0} +"oint", {226, 136, 174, 0} +"olarr", {226, 134, 186, 0} +"olcir", {226, 166, 190, 0} +"olcross", {226, 166, 187, 0} +"oline", {226, 128, 190, 0} +"olt", {226, 167, 128, 0} +"Omacr", {197, 140, 0} +"omacr", {197, 141, 0} +"Omega", {206, 169, 0} +"omega", {207, 137, 0} +"Omicron", {206, 159, 0} +"omicron", {206, 191, 0} +"omid", {226, 166, 182, 0} +"ominus", {226, 138, 150, 0} +"Oopf", {240, 157, 149, 134} +"oopf", {240, 157, 149, 160} +"opar", {226, 166, 183, 0} +"OpenCurlyDoubleQuote", {226, 128, 156, 0} +"OpenCurlyQuote", {226, 128, 152, 0} +"operp", {226, 166, 185, 0} +"oplus", {226, 138, 149, 0} +"orarr", {226, 134, 187, 0} +"Or", {226, 169, 148, 0} +"or", {226, 136, 168, 0} +"ord", {226, 169, 157, 0} +"order", {226, 132, 180, 0} +"orderof", {226, 132, 180, 0} +"ordf", {194, 170, 0} +"ordm", {194, 186, 0} +"origof", {226, 138, 182, 0} +"oror", {226, 169, 150, 0} +"orslope", {226, 169, 151, 0} +"orv", {226, 169, 155, 0} +"oS", {226, 147, 136, 0} +"Oscr", {240, 157, 146, 170} +"oscr", {226, 132, 180, 0} +"Oslash", {195, 152, 0} +"oslash", {195, 184, 0} +"osol", {226, 138, 152, 0} +"Otilde", {195, 149, 0} +"otilde", {195, 181, 0} +"otimesas", {226, 168, 182, 0} +"Otimes", {226, 168, 183, 0} +"otimes", {226, 138, 151, 0} +"Ouml", {195, 150, 0} +"ouml", {195, 182, 0} +"ovbar", {226, 140, 189, 0} +"OverBar", {226, 128, 190, 0} +"OverBrace", {226, 143, 158, 0} +"OverBracket", {226, 142, 180, 0} +"OverParenthesis", {226, 143, 156, 0} +"para", {194, 182, 0} +"parallel", {226, 136, 165, 0} +"par", {226, 136, 165, 0} +"parsim", {226, 171, 179, 0} +"parsl", {226, 171, 189, 0} +"part", {226, 136, 130, 0} +"PartialD", {226, 136, 130, 0} +"Pcy", {208, 159, 0} +"pcy", {208, 191, 0} +"percnt", {37, 0} +"period", {46, 0} +"permil", {226, 128, 176, 0} +"perp", {226, 138, 165, 0} +"pertenk", {226, 128, 177, 0} +"Pfr", {240, 157, 148, 147} +"pfr", {240, 157, 148, 173} +"Phi", {206, 166, 0} +"phi", {207, 134, 0} +"phiv", {207, 149, 0} +"phmmat", {226, 132, 179, 0} +"phone", {226, 152, 142, 0} +"Pi", {206, 160, 0} +"pi", {207, 128, 0} +"pitchfork", {226, 139, 148, 0} +"piv", {207, 150, 0} +"planck", {226, 132, 143, 0} +"planckh", {226, 132, 142, 0} +"plankv", {226, 132, 143, 0} +"plusacir", {226, 168, 163, 0} +"plusb", {226, 138, 158, 0} +"pluscir", {226, 168, 162, 0} +"plus", {43, 0} +"plusdo", {226, 136, 148, 0} +"plusdu", {226, 168, 165, 0} +"pluse", {226, 169, 178, 0} +"PlusMinus", {194, 177, 0} +"plusmn", {194, 177, 0} +"plussim", {226, 168, 166, 0} +"plustwo", {226, 168, 167, 0} +"pm", {194, 177, 0} +"Poincareplane", {226, 132, 140, 0} +"pointint", {226, 168, 149, 0} +"popf", {240, 157, 149, 161} +"Popf", {226, 132, 153, 0} +"pound", {194, 163, 0} +"prap", {226, 170, 183, 0} +"Pr", {226, 170, 187, 0} +"pr", {226, 137, 186, 0} +"prcue", {226, 137, 188, 0} +"precapprox", {226, 170, 183, 0} +"prec", {226, 137, 186, 0} +"preccurlyeq", {226, 137, 188, 0} +"Precedes", {226, 137, 186, 0} +"PrecedesEqual", {226, 170, 175, 0} +"PrecedesSlantEqual", {226, 137, 188, 0} +"PrecedesTilde", {226, 137, 190, 0} +"preceq", {226, 170, 175, 0} +"precnapprox", {226, 170, 185, 0} +"precneqq", {226, 170, 181, 0} +"precnsim", {226, 139, 168, 0} +"pre", {226, 170, 175, 0} +"prE", {226, 170, 179, 0} +"precsim", {226, 137, 190, 0} +"prime", {226, 128, 178, 0} +"Prime", {226, 128, 179, 0} +"primes", {226, 132, 153, 0} +"prnap", {226, 170, 185, 0} +"prnE", {226, 170, 181, 0} +"prnsim", {226, 139, 168, 0} +"prod", {226, 136, 143, 0} +"Product", {226, 136, 143, 0} +"profalar", {226, 140, 174, 0} +"profline", {226, 140, 146, 0} +"profsurf", {226, 140, 147, 0} +"prop", {226, 136, 157, 0} +"Proportional", {226, 136, 157, 0} +"Proportion", {226, 136, 183, 0} +"propto", {226, 136, 157, 0} +"prsim", {226, 137, 190, 0} +"prurel", {226, 138, 176, 0} +"Pscr", {240, 157, 146, 171} +"pscr", {240, 157, 147, 133} +"Psi", {206, 168, 0} +"psi", {207, 136, 0} +"puncsp", {226, 128, 136, 0} +"Qfr", {240, 157, 148, 148} +"qfr", {240, 157, 148, 174} +"qint", {226, 168, 140, 0} +"qopf", {240, 157, 149, 162} +"Qopf", {226, 132, 154, 0} +"qprime", {226, 129, 151, 0} +"Qscr", {240, 157, 146, 172} +"qscr", {240, 157, 147, 134} +"quaternions", {226, 132, 141, 0} +"quatint", {226, 168, 150, 0} +"quest", {63, 0} +"questeq", {226, 137, 159, 0} +"quot", {34, 0} +"QUOT", {34, 0} +"rAarr", {226, 135, 155, 0} +"race", {226, 136, 189, 0} +"Racute", {197, 148, 0} +"racute", {197, 149, 0} +"radic", {226, 136, 154, 0} +"raemptyv", {226, 166, 179, 0} +"rang", {226, 159, 169, 0} +"Rang", {226, 159, 171, 0} +"rangd", {226, 166, 146, 0} +"range", {226, 166, 165, 0} +"rangle", {226, 159, 169, 0} +"raquo", {194, 187, 0} +"rarrap", {226, 165, 181, 0} +"rarrb", {226, 135, 165, 0} +"rarrbfs", {226, 164, 160, 0} +"rarrc", {226, 164, 179, 0} +"rarr", {226, 134, 146, 0} +"Rarr", {226, 134, 160, 0} +"rArr", {226, 135, 146, 0} +"rarrfs", {226, 164, 158, 0} +"rarrhk", {226, 134, 170, 0} +"rarrlp", {226, 134, 172, 0} +"rarrpl", {226, 165, 133, 0} +"rarrsim", {226, 165, 180, 0} +"Rarrtl", {226, 164, 150, 0} +"rarrtl", {226, 134, 163, 0} +"rarrw", {226, 134, 157, 0} +"ratail", {226, 164, 154, 0} +"rAtail", {226, 164, 156, 0} +"ratio", {226, 136, 182, 0} +"rationals", {226, 132, 154, 0} +"rbarr", {226, 164, 141, 0} +"rBarr", {226, 164, 143, 0} +"RBarr", {226, 164, 144, 0} +"rbbrk", {226, 157, 179, 0} +"rbrace", {125, 0} +"rbrack", {93, 0} +"rbrke", {226, 166, 140, 0} +"rbrksld", {226, 166, 142, 0} +"rbrkslu", {226, 166, 144, 0} +"Rcaron", {197, 152, 0} +"rcaron", {197, 153, 0} +"Rcedil", {197, 150, 0} +"rcedil", {197, 151, 0} +"rceil", {226, 140, 137, 0} +"rcub", {125, 0} +"Rcy", {208, 160, 0} +"rcy", {209, 128, 0} +"rdca", {226, 164, 183, 0} +"rdldhar", {226, 165, 169, 0} +"rdquo", {226, 128, 157, 0} +"rdquor", {226, 128, 157, 0} +"rdsh", {226, 134, 179, 0} +"real", {226, 132, 156, 0} +"realine", {226, 132, 155, 0} +"realpart", {226, 132, 156, 0} +"reals", {226, 132, 157, 0} +"Re", {226, 132, 156, 0} +"rect", {226, 150, 173, 0} +"reg", {194, 174, 0} +"REG", {194, 174, 0} +"ReverseElement", {226, 136, 139, 0} +"ReverseEquilibrium", {226, 135, 139, 0} +"ReverseUpEquilibrium", {226, 165, 175, 0} +"rfisht", {226, 165, 189, 0} +"rfloor", {226, 140, 139, 0} +"rfr", {240, 157, 148, 175} +"Rfr", {226, 132, 156, 0} +"rHar", {226, 165, 164, 0} +"rhard", {226, 135, 129, 0} +"rharu", {226, 135, 128, 0} +"rharul", {226, 165, 172, 0} +"Rho", {206, 161, 0} +"rho", {207, 129, 0} +"rhov", {207, 177, 0} +"RightAngleBracket", {226, 159, 169, 0} +"RightArrowBar", {226, 135, 165, 0} +"rightarrow", {226, 134, 146, 0} +"RightArrow", {226, 134, 146, 0} +"Rightarrow", {226, 135, 146, 0} +"RightArrowLeftArrow", {226, 135, 132, 0} +"rightarrowtail", {226, 134, 163, 0} +"RightCeiling", {226, 140, 137, 0} +"RightDoubleBracket", {226, 159, 167, 0} +"RightDownTeeVector", {226, 165, 157, 0} +"RightDownVectorBar", {226, 165, 149, 0} +"RightDownVector", {226, 135, 130, 0} +"RightFloor", {226, 140, 139, 0} +"rightharpoondown", {226, 135, 129, 0} +"rightharpoonup", {226, 135, 128, 0} +"rightleftarrows", {226, 135, 132, 0} +"rightleftharpoons", {226, 135, 140, 0} +"rightrightarrows", {226, 135, 137, 0} +"rightsquigarrow", {226, 134, 157, 0} +"RightTeeArrow", {226, 134, 166, 0} +"RightTee", {226, 138, 162, 0} +"RightTeeVector", {226, 165, 155, 0} +"rightthreetimes", {226, 139, 140, 0} +"RightTriangleBar", {226, 167, 144, 0} +"RightTriangle", {226, 138, 179, 0} +"RightTriangleEqual", {226, 138, 181, 0} +"RightUpDownVector", {226, 165, 143, 0} +"RightUpTeeVector", {226, 165, 156, 0} +"RightUpVectorBar", {226, 165, 148, 0} +"RightUpVector", {226, 134, 190, 0} +"RightVectorBar", {226, 165, 147, 0} +"RightVector", {226, 135, 128, 0} +"ring", {203, 154, 0} +"risingdotseq", {226, 137, 147, 0} +"rlarr", {226, 135, 132, 0} +"rlhar", {226, 135, 140, 0} +"rlm", {226, 128, 143, 0} +"rmoustache", {226, 142, 177, 0} +"rmoust", {226, 142, 177, 0} +"rnmid", {226, 171, 174, 0} +"roang", {226, 159, 173, 0} +"roarr", {226, 135, 190, 0} +"robrk", {226, 159, 167, 0} +"ropar", {226, 166, 134, 0} +"ropf", {240, 157, 149, 163} +"Ropf", {226, 132, 157, 0} +"roplus", {226, 168, 174, 0} +"rotimes", {226, 168, 181, 0} +"RoundImplies", {226, 165, 176, 0} +"rpar", {41, 0} +"rpargt", {226, 166, 148, 0} +"rppolint", {226, 168, 146, 0} +"rrarr", {226, 135, 137, 0} +"Rrightarrow", {226, 135, 155, 0} +"rsaquo", {226, 128, 186, 0} +"rscr", {240, 157, 147, 135} +"Rscr", {226, 132, 155, 0} +"rsh", {226, 134, 177, 0} +"Rsh", {226, 134, 177, 0} +"rsqb", {93, 0} +"rsquo", {226, 128, 153, 0} +"rsquor", {226, 128, 153, 0} +"rthree", {226, 139, 140, 0} +"rtimes", {226, 139, 138, 0} +"rtri", {226, 150, 185, 0} +"rtrie", {226, 138, 181, 0} +"rtrif", {226, 150, 184, 0} +"rtriltri", {226, 167, 142, 0} +"RuleDelayed", {226, 167, 180, 0} +"ruluhar", {226, 165, 168, 0} +"rx", {226, 132, 158, 0} +"Sacute", {197, 154, 0} +"sacute", {197, 155, 0} +"sbquo", {226, 128, 154, 0} +"scap", {226, 170, 184, 0} +"Scaron", {197, 160, 0} +"scaron", {197, 161, 0} +"Sc", {226, 170, 188, 0} +"sc", {226, 137, 187, 0} +"sccue", {226, 137, 189, 0} +"sce", {226, 170, 176, 0} +"scE", {226, 170, 180, 0} +"Scedil", {197, 158, 0} +"scedil", {197, 159, 0} +"Scirc", {197, 156, 0} +"scirc", {197, 157, 0} +"scnap", {226, 170, 186, 0} +"scnE", {226, 170, 182, 0} +"scnsim", {226, 139, 169, 0} +"scpolint", {226, 168, 147, 0} +"scsim", {226, 137, 191, 0} +"Scy", {208, 161, 0} +"scy", {209, 129, 0} +"sdotb", {226, 138, 161, 0} +"sdot", {226, 139, 133, 0} +"sdote", {226, 169, 166, 0} +"searhk", {226, 164, 165, 0} +"searr", {226, 134, 152, 0} +"seArr", {226, 135, 152, 0} +"searrow", {226, 134, 152, 0} +"sect", {194, 167, 0} +"semi", {59, 0} +"seswar", {226, 164, 169, 0} +"setminus", {226, 136, 150, 0} +"setmn", {226, 136, 150, 0} +"sext", {226, 156, 182, 0} +"Sfr", {240, 157, 148, 150} +"sfr", {240, 157, 148, 176} +"sfrown", {226, 140, 162, 0} +"sharp", {226, 153, 175, 0} +"SHCHcy", {208, 169, 0} +"shchcy", {209, 137, 0} +"SHcy", {208, 168, 0} +"shcy", {209, 136, 0} +"ShortDownArrow", {226, 134, 147, 0} +"ShortLeftArrow", {226, 134, 144, 0} +"shortmid", {226, 136, 163, 0} +"shortparallel", {226, 136, 165, 0} +"ShortRightArrow", {226, 134, 146, 0} +"ShortUpArrow", {226, 134, 145, 0} +"shy", {194, 173, 0} +"Sigma", {206, 163, 0} +"sigma", {207, 131, 0} +"sigmaf", {207, 130, 0} +"sigmav", {207, 130, 0} +"sim", {226, 136, 188, 0} +"simdot", {226, 169, 170, 0} +"sime", {226, 137, 131, 0} +"simeq", {226, 137, 131, 0} +"simg", {226, 170, 158, 0} +"simgE", {226, 170, 160, 0} +"siml", {226, 170, 157, 0} +"simlE", {226, 170, 159, 0} +"simne", {226, 137, 134, 0} +"simplus", {226, 168, 164, 0} +"simrarr", {226, 165, 178, 0} +"slarr", {226, 134, 144, 0} +"SmallCircle", {226, 136, 152, 0} +"smallsetminus", {226, 136, 150, 0} +"smashp", {226, 168, 179, 0} +"smeparsl", {226, 167, 164, 0} +"smid", {226, 136, 163, 0} +"smile", {226, 140, 163, 0} +"smt", {226, 170, 170, 0} +"smte", {226, 170, 172, 0} +"smtes", {226, 170, 172, 0} +"SOFTcy", {208, 172, 0} +"softcy", {209, 140, 0} +"solbar", {226, 140, 191, 0} +"solb", {226, 167, 132, 0} +"sol", {47, 0} +"Sopf", {240, 157, 149, 138} +"sopf", {240, 157, 149, 164} +"spades", {226, 153, 160, 0} +"spadesuit", {226, 153, 160, 0} +"spar", {226, 136, 165, 0} +"sqcap", {226, 138, 147, 0} +"sqcaps", {226, 138, 147, 0} +"sqcup", {226, 138, 148, 0} +"sqcups", {226, 138, 148, 0} +"Sqrt", {226, 136, 154, 0} +"sqsub", {226, 138, 143, 0} +"sqsube", {226, 138, 145, 0} +"sqsubset", {226, 138, 143, 0} +"sqsubseteq", {226, 138, 145, 0} +"sqsup", {226, 138, 144, 0} +"sqsupe", {226, 138, 146, 0} +"sqsupset", {226, 138, 144, 0} +"sqsupseteq", {226, 138, 146, 0} +"square", {226, 150, 161, 0} +"Square", {226, 150, 161, 0} +"SquareIntersection", {226, 138, 147, 0} +"SquareSubset", {226, 138, 143, 0} +"SquareSubsetEqual", {226, 138, 145, 0} +"SquareSuperset", {226, 138, 144, 0} +"SquareSupersetEqual", {226, 138, 146, 0} +"SquareUnion", {226, 138, 148, 0} +"squarf", {226, 150, 170, 0} +"squ", {226, 150, 161, 0} +"squf", {226, 150, 170, 0} +"srarr", {226, 134, 146, 0} +"Sscr", {240, 157, 146, 174} +"sscr", {240, 157, 147, 136} +"ssetmn", {226, 136, 150, 0} +"ssmile", {226, 140, 163, 0} +"sstarf", {226, 139, 134, 0} +"Star", {226, 139, 134, 0} +"star", {226, 152, 134, 0} +"starf", {226, 152, 133, 0} +"straightepsilon", {207, 181, 0} +"straightphi", {207, 149, 0} +"strns", {194, 175, 0} +"sub", {226, 138, 130, 0} +"Sub", {226, 139, 144, 0} +"subdot", {226, 170, 189, 0} +"subE", {226, 171, 133, 0} +"sube", {226, 138, 134, 0} +"subedot", {226, 171, 131, 0} +"submult", {226, 171, 129, 0} +"subnE", {226, 171, 139, 0} +"subne", {226, 138, 138, 0} +"subplus", {226, 170, 191, 0} +"subrarr", {226, 165, 185, 0} +"subset", {226, 138, 130, 0} +"Subset", {226, 139, 144, 0} +"subseteq", {226, 138, 134, 0} +"subseteqq", {226, 171, 133, 0} +"SubsetEqual", {226, 138, 134, 0} +"subsetneq", {226, 138, 138, 0} +"subsetneqq", {226, 171, 139, 0} +"subsim", {226, 171, 135, 0} +"subsub", {226, 171, 149, 0} +"subsup", {226, 171, 147, 0} +"succapprox", {226, 170, 184, 0} +"succ", {226, 137, 187, 0} +"succcurlyeq", {226, 137, 189, 0} +"Succeeds", {226, 137, 187, 0} +"SucceedsEqual", {226, 170, 176, 0} +"SucceedsSlantEqual", {226, 137, 189, 0} +"SucceedsTilde", {226, 137, 191, 0} +"succeq", {226, 170, 176, 0} +"succnapprox", {226, 170, 186, 0} +"succneqq", {226, 170, 182, 0} +"succnsim", {226, 139, 169, 0} +"succsim", {226, 137, 191, 0} +"SuchThat", {226, 136, 139, 0} +"sum", {226, 136, 145, 0} +"Sum", {226, 136, 145, 0} +"sung", {226, 153, 170, 0} +"sup1", {194, 185, 0} +"sup2", {194, 178, 0} +"sup3", {194, 179, 0} +"sup", {226, 138, 131, 0} +"Sup", {226, 139, 145, 0} +"supdot", {226, 170, 190, 0} +"supdsub", {226, 171, 152, 0} +"supE", {226, 171, 134, 0} +"supe", {226, 138, 135, 0} +"supedot", {226, 171, 132, 0} +"Superset", {226, 138, 131, 0} +"SupersetEqual", {226, 138, 135, 0} +"suphsol", {226, 159, 137, 0} +"suphsub", {226, 171, 151, 0} +"suplarr", {226, 165, 187, 0} +"supmult", {226, 171, 130, 0} +"supnE", {226, 171, 140, 0} +"supne", {226, 138, 139, 0} +"supplus", {226, 171, 128, 0} +"supset", {226, 138, 131, 0} +"Supset", {226, 139, 145, 0} +"supseteq", {226, 138, 135, 0} +"supseteqq", {226, 171, 134, 0} +"supsetneq", {226, 138, 139, 0} +"supsetneqq", {226, 171, 140, 0} +"supsim", {226, 171, 136, 0} +"supsub", {226, 171, 148, 0} +"supsup", {226, 171, 150, 0} +"swarhk", {226, 164, 166, 0} +"swarr", {226, 134, 153, 0} +"swArr", {226, 135, 153, 0} +"swarrow", {226, 134, 153, 0} +"swnwar", {226, 164, 170, 0} +"szlig", {195, 159, 0} +"Tab", {9, 0} +"target", {226, 140, 150, 0} +"Tau", {206, 164, 0} +"tau", {207, 132, 0} +"tbrk", {226, 142, 180, 0} +"Tcaron", {197, 164, 0} +"tcaron", {197, 165, 0} +"Tcedil", {197, 162, 0} +"tcedil", {197, 163, 0} +"Tcy", {208, 162, 0} +"tcy", {209, 130, 0} +"tdot", {226, 131, 155, 0} +"telrec", {226, 140, 149, 0} +"Tfr", {240, 157, 148, 151} +"tfr", {240, 157, 148, 177} +"there4", {226, 136, 180, 0} +"therefore", {226, 136, 180, 0} +"Therefore", {226, 136, 180, 0} +"Theta", {206, 152, 0} +"theta", {206, 184, 0} +"thetasym", {207, 145, 0} +"thetav", {207, 145, 0} +"thickapprox", {226, 137, 136, 0} +"thicksim", {226, 136, 188, 0} +"ThickSpace", {226, 129, 159, 0} +"ThinSpace", {226, 128, 137, 0} +"thinsp", {226, 128, 137, 0} +"thkap", {226, 137, 136, 0} +"thksim", {226, 136, 188, 0} +"THORN", {195, 158, 0} +"thorn", {195, 190, 0} +"tilde", {203, 156, 0} +"Tilde", {226, 136, 188, 0} +"TildeEqual", {226, 137, 131, 0} +"TildeFullEqual", {226, 137, 133, 0} +"TildeTilde", {226, 137, 136, 0} +"timesbar", {226, 168, 177, 0} +"timesb", {226, 138, 160, 0} +"times", {195, 151, 0} +"timesd", {226, 168, 176, 0} +"tint", {226, 136, 173, 0} +"toea", {226, 164, 168, 0} +"topbot", {226, 140, 182, 0} +"topcir", {226, 171, 177, 0} +"top", {226, 138, 164, 0} +"Topf", {240, 157, 149, 139} +"topf", {240, 157, 149, 165} +"topfork", {226, 171, 154, 0} +"tosa", {226, 164, 169, 0} +"tprime", {226, 128, 180, 0} +"trade", {226, 132, 162, 0} +"TRADE", {226, 132, 162, 0} +"triangle", {226, 150, 181, 0} +"triangledown", {226, 150, 191, 0} +"triangleleft", {226, 151, 131, 0} +"trianglelefteq", {226, 138, 180, 0} +"triangleq", {226, 137, 156, 0} +"triangleright", {226, 150, 185, 0} +"trianglerighteq", {226, 138, 181, 0} +"tridot", {226, 151, 172, 0} +"trie", {226, 137, 156, 0} +"triminus", {226, 168, 186, 0} +"TripleDot", {226, 131, 155, 0} +"triplus", {226, 168, 185, 0} +"trisb", {226, 167, 141, 0} +"tritime", {226, 168, 187, 0} +"trpezium", {226, 143, 162, 0} +"Tscr", {240, 157, 146, 175} +"tscr", {240, 157, 147, 137} +"TScy", {208, 166, 0} +"tscy", {209, 134, 0} +"TSHcy", {208, 139, 0} +"tshcy", {209, 155, 0} +"Tstrok", {197, 166, 0} +"tstrok", {197, 167, 0} +"twixt", {226, 137, 172, 0} +"twoheadleftarrow", {226, 134, 158, 0} +"twoheadrightarrow", {226, 134, 160, 0} +"Uacute", {195, 154, 0} +"uacute", {195, 186, 0} +"uarr", {226, 134, 145, 0} +"Uarr", {226, 134, 159, 0} +"uArr", {226, 135, 145, 0} +"Uarrocir", {226, 165, 137, 0} +"Ubrcy", {208, 142, 0} +"ubrcy", {209, 158, 0} +"Ubreve", {197, 172, 0} +"ubreve", {197, 173, 0} +"Ucirc", {195, 155, 0} +"ucirc", {195, 187, 0} +"Ucy", {208, 163, 0} +"ucy", {209, 131, 0} +"udarr", {226, 135, 133, 0} +"Udblac", {197, 176, 0} +"udblac", {197, 177, 0} +"udhar", {226, 165, 174, 0} +"ufisht", {226, 165, 190, 0} +"Ufr", {240, 157, 148, 152} +"ufr", {240, 157, 148, 178} +"Ugrave", {195, 153, 0} +"ugrave", {195, 185, 0} +"uHar", {226, 165, 163, 0} +"uharl", {226, 134, 191, 0} +"uharr", {226, 134, 190, 0} +"uhblk", {226, 150, 128, 0} +"ulcorn", {226, 140, 156, 0} +"ulcorner", {226, 140, 156, 0} +"ulcrop", {226, 140, 143, 0} +"ultri", {226, 151, 184, 0} +"Umacr", {197, 170, 0} +"umacr", {197, 171, 0} +"uml", {194, 168, 0} +"UnderBar", {95, 0} +"UnderBrace", {226, 143, 159, 0} +"UnderBracket", {226, 142, 181, 0} +"UnderParenthesis", {226, 143, 157, 0} +"Union", {226, 139, 131, 0} +"UnionPlus", {226, 138, 142, 0} +"Uogon", {197, 178, 0} +"uogon", {197, 179, 0} +"Uopf", {240, 157, 149, 140} +"uopf", {240, 157, 149, 166} +"UpArrowBar", {226, 164, 146, 0} +"uparrow", {226, 134, 145, 0} +"UpArrow", {226, 134, 145, 0} +"Uparrow", {226, 135, 145, 0} +"UpArrowDownArrow", {226, 135, 133, 0} +"updownarrow", {226, 134, 149, 0} +"UpDownArrow", {226, 134, 149, 0} +"Updownarrow", {226, 135, 149, 0} +"UpEquilibrium", {226, 165, 174, 0} +"upharpoonleft", {226, 134, 191, 0} +"upharpoonright", {226, 134, 190, 0} +"uplus", {226, 138, 142, 0} +"UpperLeftArrow", {226, 134, 150, 0} +"UpperRightArrow", {226, 134, 151, 0} +"upsi", {207, 133, 0} +"Upsi", {207, 146, 0} +"upsih", {207, 146, 0} +"Upsilon", {206, 165, 0} +"upsilon", {207, 133, 0} +"UpTeeArrow", {226, 134, 165, 0} +"UpTee", {226, 138, 165, 0} +"upuparrows", {226, 135, 136, 0} +"urcorn", {226, 140, 157, 0} +"urcorner", {226, 140, 157, 0} +"urcrop", {226, 140, 142, 0} +"Uring", {197, 174, 0} +"uring", {197, 175, 0} +"urtri", {226, 151, 185, 0} +"Uscr", {240, 157, 146, 176} +"uscr", {240, 157, 147, 138} +"utdot", {226, 139, 176, 0} +"Utilde", {197, 168, 0} +"utilde", {197, 169, 0} +"utri", {226, 150, 181, 0} +"utrif", {226, 150, 180, 0} +"uuarr", {226, 135, 136, 0} +"Uuml", {195, 156, 0} +"uuml", {195, 188, 0} +"uwangle", {226, 166, 167, 0} +"vangrt", {226, 166, 156, 0} +"varepsilon", {207, 181, 0} +"varkappa", {207, 176, 0} +"varnothing", {226, 136, 133, 0} +"varphi", {207, 149, 0} +"varpi", {207, 150, 0} +"varpropto", {226, 136, 157, 0} +"varr", {226, 134, 149, 0} +"vArr", {226, 135, 149, 0} +"varrho", {207, 177, 0} +"varsigma", {207, 130, 0} +"varsubsetneq", {226, 138, 138, 0} +"varsubsetneqq", {226, 171, 139, 0} +"varsupsetneq", {226, 138, 139, 0} +"varsupsetneqq", {226, 171, 140, 0} +"vartheta", {207, 145, 0} +"vartriangleleft", {226, 138, 178, 0} +"vartriangleright", {226, 138, 179, 0} +"vBar", {226, 171, 168, 0} +"Vbar", {226, 171, 171, 0} +"vBarv", {226, 171, 169, 0} +"Vcy", {208, 146, 0} +"vcy", {208, 178, 0} +"vdash", {226, 138, 162, 0} +"vDash", {226, 138, 168, 0} +"Vdash", {226, 138, 169, 0} +"VDash", {226, 138, 171, 0} +"Vdashl", {226, 171, 166, 0} +"veebar", {226, 138, 187, 0} +"vee", {226, 136, 168, 0} +"Vee", {226, 139, 129, 0} +"veeeq", {226, 137, 154, 0} +"vellip", {226, 139, 174, 0} +"verbar", {124, 0} +"Verbar", {226, 128, 150, 0} +"vert", {124, 0} +"Vert", {226, 128, 150, 0} +"VerticalBar", {226, 136, 163, 0} +"VerticalLine", {124, 0} +"VerticalSeparator", {226, 157, 152, 0} +"VerticalTilde", {226, 137, 128, 0} +"VeryThinSpace", {226, 128, 138, 0} +"Vfr", {240, 157, 148, 153} +"vfr", {240, 157, 148, 179} +"vltri", {226, 138, 178, 0} +"vnsub", {226, 138, 130, 0} +"vnsup", {226, 138, 131, 0} +"Vopf", {240, 157, 149, 141} +"vopf", {240, 157, 149, 167} +"vprop", {226, 136, 157, 0} +"vrtri", {226, 138, 179, 0} +"Vscr", {240, 157, 146, 177} +"vscr", {240, 157, 147, 139} +"vsubnE", {226, 171, 139, 0} +"vsubne", {226, 138, 138, 0} +"vsupnE", {226, 171, 140, 0} +"vsupne", {226, 138, 139, 0} +"Vvdash", {226, 138, 170, 0} +"vzigzag", {226, 166, 154, 0} +"Wcirc", {197, 180, 0} +"wcirc", {197, 181, 0} +"wedbar", {226, 169, 159, 0} +"wedge", {226, 136, 167, 0} +"Wedge", {226, 139, 128, 0} +"wedgeq", {226, 137, 153, 0} +"weierp", {226, 132, 152, 0} +"Wfr", {240, 157, 148, 154} +"wfr", {240, 157, 148, 180} +"Wopf", {240, 157, 149, 142} +"wopf", {240, 157, 149, 168} +"wp", {226, 132, 152, 0} +"wr", {226, 137, 128, 0} +"wreath", {226, 137, 128, 0} +"Wscr", {240, 157, 146, 178} +"wscr", {240, 157, 147, 140} +"xcap", {226, 139, 130, 0} +"xcirc", {226, 151, 175, 0} +"xcup", {226, 139, 131, 0} +"xdtri", {226, 150, 189, 0} +"Xfr", {240, 157, 148, 155} +"xfr", {240, 157, 148, 181} +"xharr", {226, 159, 183, 0} +"xhArr", {226, 159, 186, 0} +"Xi", {206, 158, 0} +"xi", {206, 190, 0} +"xlarr", {226, 159, 181, 0} +"xlArr", {226, 159, 184, 0} +"xmap", {226, 159, 188, 0} +"xnis", {226, 139, 187, 0} +"xodot", {226, 168, 128, 0} +"Xopf", {240, 157, 149, 143} +"xopf", {240, 157, 149, 169} +"xoplus", {226, 168, 129, 0} +"xotime", {226, 168, 130, 0} +"xrarr", {226, 159, 182, 0} +"xrArr", {226, 159, 185, 0} +"Xscr", {240, 157, 146, 179} +"xscr", {240, 157, 147, 141} +"xsqcup", {226, 168, 134, 0} +"xuplus", {226, 168, 132, 0} +"xutri", {226, 150, 179, 0} +"xvee", {226, 139, 129, 0} +"xwedge", {226, 139, 128, 0} +"Yacute", {195, 157, 0} +"yacute", {195, 189, 0} +"YAcy", {208, 175, 0} +"yacy", {209, 143, 0} +"Ycirc", {197, 182, 0} +"ycirc", {197, 183, 0} +"Ycy", {208, 171, 0} +"ycy", {209, 139, 0} +"yen", {194, 165, 0} +"Yfr", {240, 157, 148, 156} +"yfr", {240, 157, 148, 182} +"YIcy", {208, 135, 0} +"yicy", {209, 151, 0} +"Yopf", {240, 157, 149, 144} +"yopf", {240, 157, 149, 170} +"Yscr", {240, 157, 146, 180} +"yscr", {240, 157, 147, 142} +"YUcy", {208, 174, 0} +"yucy", {209, 142, 0} +"yuml", {195, 191, 0} +"Yuml", {197, 184, 0} +"Zacute", {197, 185, 0} +"zacute", {197, 186, 0} +"Zcaron", {197, 189, 0} +"zcaron", {197, 190, 0} +"Zcy", {208, 151, 0} +"zcy", {208, 183, 0} +"Zdot", {197, 187, 0} +"zdot", {197, 188, 0} +"zeetrf", {226, 132, 168, 0} +"ZeroWidthSpace", {226, 128, 139, 0} +"Zeta", {206, 150, 0} +"zeta", {206, 182, 0} +"zfr", {240, 157, 148, 183} +"Zfr", {226, 132, 168, 0} +"ZHcy", {208, 150, 0} +"zhcy", {208, 182, 0} +"zigrarr", {226, 135, 157, 0} +"zopf", {240, 157, 149, 171} +"Zopf", {226, 132, 164, 0} +"Zscr", {240, 157, 146, 181} +"zscr", {240, 157, 147, 143} +"zwj", {226, 128, 141, 0} +"zwnj", {226, 128, 140, 0} diff --git a/html_unescape.h b/html_unescape.h new file mode 100644 index 0000000..1eb318b --- /dev/null +++ b/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/inlines.c b/inlines.c new file mode 100644 index 0000000..2c12408 --- /dev/null +++ b/inlines.c @@ -0,0 +1,1031 @@ +#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" + + +// 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; + unsigned char delim_char; + int position; + 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); + +static void subject_from_buf(subject *e, cmark_strbuf *buffer, + cmark_reference_map *refmap); +static int subject_find_special_char(subject *subj); + +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; + } + } + + 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 { + *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; +} + +// Parse strong/emph or a fallback. +// Assumes the subject has '_' or '*' at the current position. +static cmark_node* handle_strong_emph(subject* subj, unsigned char c) +{ + int numdelims; + cmark_node * inl_text; + bool can_open, can_close; + + numdelims = scan_delims(subj, c, &can_open, &can_close); + + inl_text = make_str(cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims)); + + if (can_open || can_close) { + push_delimiter(subj, c, can_open, can_close, inl_text); + } + + return inl_text; +} + +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 == '_')) { + // 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 (opener != NULL && opener != start_delim) { + closer = S_insert_emph(subj, opener, closer); + } else { + 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) +{ + // "\n\\`&_*[]pos + 1; + + while (n < subj->input.len) { + if (SPECIAL_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) +{ + 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 '_': + new_inl = handle_strong_emph(subj, c); + 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); + 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) +{ + subject subj; + subject_from_buf(&subj, &parent->string_content, refmap); + + while (!is_eof(&subj) && parse_inline(&subj, parent)) ; + + 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/inlines.h b/inlines.h new file mode 100644 index 0000000..d2ccfb4 --- /dev/null +++ b/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 cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/iterator.c b/iterator.c new file mode 100644 index 0000000..eb7b49c --- /dev/null +++ b/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_get_node(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/iterator.h b/iterator.h new file mode 100644 index 0000000..027b10b --- /dev/null +++ b/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/libcmark.pc.in b/libcmark.pc.in new file mode 100644 index 0000000..9c3a9a9 --- /dev/null +++ b/libcmark.pc.in @@ -0,0 +1,10 @@ +prefix=@CMAKE_INSTALL_PREFIX@ +exec_prefix=@CMAKE_INSTALL_PREFIX@ +libdir=@CMAKE_INSTALL_PREFIX@/lib +includedir=@CMAKE_INSTALL_PREFIX@/include + +Name: libcmark +Description: CommonMark parsing, rendering, and manipulation +Version: @PROJECT_VERSION@ +Libs: -L${libdir} -lcmark +Cflags: -I${includedir} diff --git a/man.c b/man.c new file mode 100644 index 0000000..f57eb75 --- /dev/null +++ b/man.c @@ -0,0 +1,250 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" + +// Functions to convert cmark_nodes to groff man strings. + +static void escape_man(cmark_strbuf *dest, const unsigned char *source, int length) +{ + int i; + unsigned char c; + bool beginLine = true; + + for (i = 0; i < length; i++) { + c = source[i]; + if (c == '.' && beginLine) { + cmark_strbuf_puts(dest, "\\&."); + } else if (c == '\'' && beginLine) { + cmark_strbuf_puts(dest, "\\&'"); + } else if (c == '-') { + cmark_strbuf_puts(dest, "\\-"); + } else if (c == '\\') { + cmark_strbuf_puts(dest, "\\e"); + } else { + cmark_strbuf_putc(dest, source[i]); + } + beginLine = (c == '\n'); + } +} + +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, long 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/node.c b/node.c new file mode 100644 index 0000000..fe3dac3 --- /dev/null +++ b/node.c @@ -0,0 +1,871 @@ +#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/node.h b/node.h new file mode 100644 index 0000000..74eddd4 --- /dev/null +++ b/node.h @@ -0,0 +1,79 @@ +#ifndef CMARK_NODE_H +#define CMARK_NODE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#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 { + bool fenced; + int fence_length; + int fence_offset; + unsigned char fence_char; + cmark_chunk info; + cmark_chunk literal; +} cmark_code; + +typedef struct { + int level; + bool setext; +} cmark_header; + +typedef struct { + unsigned char *url; + unsigned char *title; +} cmark_link; + +struct cmark_node { + cmark_node_type type; + + 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; + 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/parser.h b/parser.h new file mode 100644 index 0000000..3c8def9 --- /dev/null +++ b/parser.h @@ -0,0 +1,28 @@ +#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; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/references.c b/references.c new file mode 100644 index 0000000..37bf4cb --- /dev/null +++ b/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/references.h b/references.h new file mode 100644 index 0000000..69325bb --- /dev/null +++ b/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/scanners.c b/scanners.c new file mode 100644 index 0000000..440cf83 --- /dev/null +++ b/scanners.c @@ -0,0 +1,12391 @@ +/* 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, 230, 230, 230, 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 <= '\n') 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 >= '\v') 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 <= '\n') 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 >= '\v') 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 <= '\n') 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 <= '\n') { + 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 <= '\n') 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 <= '\n') 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 <= '\n') 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 <= '\n') { + 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 <= '\n') 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 <= '\n') 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 <= '\n') 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 <= '\n') { + 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 >= '\v') 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 <= '\n') { + 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 <= '\n') { + 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 <= '\n') 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 <= '\n') 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 <= '\n') 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, 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') { + if (yych <= 0x08) goto yy1174; + if (yych <= '\t') goto yy1171; + goto yy1172; + } else { + 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/scanners.h b/scanners.h new file mode 100644 index 0000000..f360505 --- /dev/null +++ b/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/scanners.re b/scanners.re new file mode 100644 index 0000000..28a6991 --- /dev/null +++ b/scanners.re @@ -0,0 +1,236 @@ +#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; +} + +/*!re2c + re2c:define:YYCTYPE = "unsigned char"; + re2c:define:YYCURSOR = p; + re2c:define:YYMARKER = marker; + re2c:define:YYCTXMARKER = marker; + re2c:yyfill:enable = 0; + + wordchar = [^\x00-\x20]; + + spacechar = [ \t\n]; + + reg_char = [^\\()\x00-\x20]; + + escaped_char = [\\][!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~-]; + + tagname = [A-Za-z][A-Za-z0-9]*; + + blocktagname = 'article'|'header'|'aside'|'hgroup'|'iframe'|'blockquote'|'hr'|'body'|'li'|'map'|'button'|'object'|'canvas'|'ol'|'caption'|'output'|'col'|'p'|'colgroup'|'pre'|'dd'|'progress'|'div'|'section'|'dl'|'table'|'td'|'dt'|'tbody'|'embed'|'textarea'|'fieldset'|'tfoot'|'figcaption'|'th'|'figure'|'thead'|'footer'|'footer'|'tr'|'form'|'ul'|'h1'|'h2'|'h3'|'h4'|'h5'|'h6'|'video'|'script'|'style'; + + attributename = [a-zA-Z_:][a-zA-Z0-9:._-]*; + + unquotedvalue = [^\"'=<>`\x00]+; + singlequotedvalue = ['][^'\x00]*[']; + doublequotedvalue = [\"][^\"\x00]*[\"]; + + attributevalue = unquotedvalue | singlequotedvalue | doublequotedvalue; + + attributevaluespec = spacechar* [=] spacechar* attributevalue; + + attribute = spacechar+ attributename attributevaluespec?; + + opentag = tagname attribute* spacechar* [/]? [>]; + closetag = [/] tagname spacechar* [>]; + + htmlcomment = "!---->" | ("!--" ([-]? [^\x00>-]) ([-]? [^\x00-])* "-->"); + + processinginstruction = "?" ([^?>\x00]+ | [?][^>\x00] | [>])* "?>"; + + declaration = "!" [A-Z]+ spacechar+ [^>\x00]* ">"; + + cdata = "![CDATA[" ([^\]\x00]+ | "]" [^\]\x00] | "]]" [^>\x00])* "]]>"; + + htmltag = opentag | closetag | htmlcomment | processinginstruction | + declaration | cdata; + + in_parens_nosp = [(] (reg_char|escaped_char)* [)]; + + in_double_quotes = ["] (escaped_char|[^"\x00])* ["]; + in_single_quotes = ['] (escaped_char|[^'\x00])* [']; + in_parens = [(] (escaped_char|[^)\x00])* [)]; + + scheme = 'coap'|'doi'|'javascript'|'aaa'|'aaas'|'about'|'acap'|'cap'|'cid'|'crid'|'data'|'dav'|'dict'|'dns'|'file'|'ftp'|'geo'|'go'|'gopher'|'h323'|'http'|'https'|'iax'|'icap'|'im'|'imap'|'info'|'ipp'|'iris'|'iris.beep'|'iris.xpc'|'iris.xpcs'|'iris.lwz'|'ldap'|'mailto'|'mid'|'msrp'|'msrps'|'mtqp'|'mupdate'|'news'|'nfs'|'ni'|'nih'|'nntp'|'opaquelocktoken'|'pop'|'pres'|'rtsp'|'service'|'session'|'shttp'|'sieve'|'sip'|'sips'|'sms'|'snmp'|'soap.beep'|'soap.beeps'|'tag'|'tel'|'telnet'|'tftp'|'thismessage'|'tn3270'|'tip'|'tv'|'urn'|'vemmi'|'ws'|'wss'|'xcon'|'xcon-userid'|'xmlrpc.beep'|'xmlrpc.beeps'|'xmpp'|'z39.50r'|'z39.50s'|'adiumxtra'|'afp'|'afs'|'aim'|'apt'|'attachment'|'aw'|'beshare'|'bitcoin'|'bolo'|'callto'|'chrome'|'chrome-extension'|'com-eventbrite-attendee'|'content'|'cvs'|'dlna-playsingle'|'dlna-playcontainer'|'dtn'|'dvb'|'ed2k'|'facetime'|'feed'|'finger'|'fish'|'gg'|'git'|'gizmoproject'|'gtalk'|'hcp'|'icon'|'ipn'|'irc'|'irc6'|'ircs'|'itms'|'jar'|'jms'|'keyparc'|'lastfm'|'ldaps'|'magnet'|'maps'|'market'|'message'|'mms'|'ms-help'|'msnim'|'mumble'|'mvn'|'notes'|'oid'|'palm'|'paparazzi'|'platform'|'proxy'|'psyc'|'query'|'res'|'resource'|'rmi'|'rsync'|'rtmp'|'secondlife'|'sftp'|'sgn'|'skype'|'smb'|'soldat'|'spotify'|'ssh'|'steam'|'svn'|'teamspeak'|'things'|'udp'|'unreal'|'ut2004'|'ventrilo'|'view-source'|'webcal'|'wtai'|'wyciwyg'|'xfire'|'xri'|'ymsgr'; +*/ + +// 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; +/*!re2c + scheme [:][^\x00-\x20<>]*[>] { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+ + [@] + [a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])? + ([.][a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)* + [>] { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + htmltag { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [<] [/] blocktagname (spacechar | [>]) { return (p - start); } + [<] blocktagname (spacechar | [/>]) { return (p - start); } + [<] [!?] { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [ \n]* [<] ([^<>\n\\\x00] | escaped_char | [\\])* [>] { return (p - start); } + [ \n]* (reg_char+ | escaped_char | in_parens_nosp)* { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + ["] (escaped_char|[^"\x00])* ["] { return (p - start); } + ['] (escaped_char|[^'\x00])* ['] { return (p - start); } + [(] (escaped_char|[^)\x00])* [)] { return (p - start); } + .? { return 0; } +*/ +} + +// Match space characters, including newlines. +int _scan_spacechars(const unsigned char *p) +{ + const unsigned char *start = p; \ +/*!re2c + [ \t\n]* { return (p - start); } + . { 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; +/*!re2c + [#]{1,6} ([ ]+|[\n]) { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [=]+ [ ]* [\n] { return 1; } + [-]+ [ ]* [\n] { return 2; } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + ([*][ ]*){3,} [ \t]* [\n] { return (p - start); } + ([_][ ]*){3,} [ \t]* [\n] { return (p - start); } + ([-][ ]*){3,} [ \t]* [\n] { return (p - start); } + .? { return 0; } +*/ +} + +// Scan an opening code fence. +int _scan_open_code_fence(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [`]{3,} / [^`\n\x00]*[\n] { return (p - start); } + [~]{3,} / [^~\n\x00]*[\n] { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [`]{3,} / [ \t]*[\n] { return (p - start); } + [~]{3,} / [ \t]*[\n] { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [&] ([#] ([Xx][A-Fa-f0-9]{1,8}|[0-9]{1,8}) |[A-Za-z][A-Za-z0-9]{1,31} ) [;] + { return (p - start); } + .? { return 0; } +*/ +} diff --git a/utf8.c b/utf8.c new file mode 100644 index 0000000..d77c5d1 --- /dev/null +++ b/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/utf8.h b/utf8.h new file mode 100644 index 0000000..7df1573 --- /dev/null +++ b/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/xml.c b/xml.c new file mode 100644 index 0000000..f169241 --- /dev/null +++ b/xml.c @@ -0,0 +1,174 @@ +#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, long 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, long options) +{ + char *result; + cmark_strbuf xml = GH_BUF_INIT; + cmark_event_type ev_type; + cmark_node *cur; + struct render_state state = { &xml, 0 }; + + if (options & CMARK_OPT_NORMALIZE) { + cmark_consolidate_text_nodes(root); + } + + 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; +} From c046930eb63a8aab0b2339213b2d2ef50d82ee31 Mon Sep 17 00:00:00 2001 From: James Adam Date: Thu, 12 Feb 2015 20:51:09 -0500 Subject: [PATCH 02/26] Revert "Changed library to build statically and be 'go-gettable' by including so..." --- CMakeLists.txt | 149 - bench.h | 27 - blocks.c | 878 --- buffer.c | 381 -- buffer.h | 113 - case_fold_switch.inc | 2637 -------- chunk.h | 110 - cmark.c | 24 - cmark.h | 556 -- cmark_ctype.c | 53 - cmark_ctype.h | 24 - cmark_export.h | 35 - cmark_version.h | 7 - cmark_version.h.in | 7 - commonmark.go | 2 +- config.h | 23 - config.h.in | 23 - debug.h | 36 - houdini.h | 52 - houdini_href_e.c | 107 - houdini_html_e.c | 81 - houdini_html_u.c | 116 - html.c | 323 - html_unescape.gperf | 2130 ------- html_unescape.h | 13375 ----------------------------------------- inlines.c | 1031 ---- inlines.h | 19 - iterator.c | 146 - iterator.h | 25 - libcmark.pc.in | 10 - man.c | 250 - node.c | 871 --- node.h | 79 - parser.h | 28 - references.c | 154 - references.h | 37 - scanners.c | 12391 -------------------------------------- scanners.h | 39 - scanners.re | 236 - utf8.c | 453 -- utf8.h | 22 - xml.c | 174 - 42 files changed, 1 insertion(+), 37233 deletions(-) delete mode 100644 CMakeLists.txt delete mode 100644 bench.h delete mode 100644 blocks.c delete mode 100644 buffer.c delete mode 100644 buffer.h delete mode 100644 case_fold_switch.inc delete mode 100644 chunk.h delete mode 100644 cmark.c delete mode 100644 cmark.h delete mode 100644 cmark_ctype.c delete mode 100644 cmark_ctype.h delete mode 100644 cmark_export.h delete mode 100644 cmark_version.h delete mode 100644 cmark_version.h.in delete mode 100644 config.h delete mode 100644 config.h.in delete mode 100644 debug.h delete mode 100644 houdini.h delete mode 100644 houdini_href_e.c delete mode 100644 houdini_html_e.c delete mode 100644 houdini_html_u.c delete mode 100644 html.c delete mode 100644 html_unescape.gperf delete mode 100644 html_unescape.h delete mode 100644 inlines.c delete mode 100644 inlines.h delete mode 100644 iterator.c delete mode 100644 iterator.h delete mode 100644 libcmark.pc.in delete mode 100644 man.c delete mode 100644 node.c delete mode 100644 node.h delete mode 100644 parser.h delete mode 100644 references.c delete mode 100644 references.h delete mode 100644 scanners.c delete mode 100644 scanners.h delete mode 100644 scanners.re delete mode 100644 utf8.c delete mode 100644 utf8.h delete mode 100644 xml.c diff --git a/CMakeLists.txt b/CMakeLists.txt deleted file mode 100644 index 2179c08..0000000 --- a/CMakeLists.txt +++ /dev/null @@ -1,149 +0,0 @@ -cmake_minimum_required(VERSION 2.8) -set(LIBRARY "libcmark") -set(HEADERS - cmark.h - parser.h - buffer.h - node.h - iterator.h - chunk.h - references.h - debug.h - bench.h - utf8.h - scanners.h - inlines.h - html_unescape.h - houdini.h - cmark_ctype.h - ) -set(LIBRARY_SOURCES - cmark.c - node.c - iterator.c - blocks.c - inlines.c - scanners.c - scanners.re - utf8.c - buffer.c - references.c - man.c - xml.c - html.c - html_unescape.gperf - houdini_href_e.c - houdini_html_e.c - houdini_html_u.c - cmark_ctype.c - ${HEADERS} - ) - -set(PROGRAM "cmark") -set(PROGRAM_SOURCES - ${LIBRARY_SOURCES} - main.c - ) - -include_directories(. ${CMAKE_CURRENT_BINARY_DIR}) - -configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmark_version.h.in - ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h) - -configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark.pc.in - ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc @ONLY) -install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc - DESTINATION lib/pkgconfig) - -include (GenerateExportHeader) - -add_executable(${PROGRAM} ${PROGRAM_SOURCES}) -add_compiler_export_flags() - -# Disable the PUBLIC declarations when compiling the executable: -set_target_properties(${PROGRAM} PROPERTIES - COMPILE_FLAGS -DCMARK_STATIC_DEFINE) - -# Check integrity of node structure when compiled as debug: -set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -pg -DCMARK_DEBUG_NODES") -set(CMAKE_LINKER_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -pg") - -set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -pg") -set(CMAKE_LINKER_PROFILE "${CMAKE_LINKER_FLAGS_RELEASE} -pg") - -if (${CMAKE_MAJOR_VERSION} GREATER 1 AND ${CMAKE_MINOR_VERSION} GREATER 8) - set(CMAKE_C_VISIBILITY_PRESET hidden) - set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) -elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") -endif () - -add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES}) -# Include minor version in soname as long as major version is 0. -set_target_properties(${LIBRARY} PROPERTIES - OUTPUT_NAME "cmark" - SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR} - VERSION ${PROJECT_VERSION}) - -set_property(TARGET ${LIBRARY} - APPEND PROPERTY MACOSX_RPATH true) - -generate_export_header(${LIBRARY} - BASE_NAME ${PROJECT_NAME}) - -if (MSVC) - set_property(TARGET ${PROGRAM} - APPEND PROPERTY LINK_FLAGS /INCREMENTAL:NO) -endif(MSVC) - -install(TARGETS ${PROGRAM} ${LIBRARY} - RUNTIME DESTINATION bin - LIBRARY DESTINATION lib - ) - -install(FILES - cmark.h - ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h - ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h - DESTINATION include - ) - -# Feature tests -include(CheckIncludeFile) -include(CheckCSourceCompiles) -include(CheckSymbolExists) -CHECK_INCLUDE_FILE(stdbool.h HAVE_STDBOOL_H) -CHECK_C_SOURCE_COMPILES( - "int main() { __builtin_expect(0,0); return 0; }" - HAVE___BUILTIN_EXPECT) -CHECK_C_SOURCE_COMPILES(" - int f(void) __attribute__ (()); - int main() { return 0; } -" HAVE___ATTRIBUTE__) -CHECK_SYMBOL_EXISTS(va_copy stdarg.h HAVE_VA_COPY) - -CONFIGURE_FILE( - ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in - ${CMAKE_CURRENT_BINARY_DIR}/config.h) - -# Always compile with warnings -if(MSVC) - # Force to always compile with W4 - if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") - string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") - else() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4") - endif() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127 /wd4244 /wd4267 /wd4706 /wd4800 /D_CRT_SECURE_NO_WARNINGS") -elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=c99 -pedantic") -endif() - -# Compile as C++ under MSVC -if(MSVC) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /TP") -endif() - -if($ENV{TIMER}) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DTIMER=1") -endif($ENV{TIMER}) diff --git a/bench.h b/bench.h deleted file mode 100644 index bbea2c6..0000000 --- a/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/blocks.c b/blocks.c deleted file mode 100644 index 806f7a6..0000000 --- a/blocks.c +++ /dev/null @@ -1,878 +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 cmark_node. -static cmark_node* make_document() -{ - cmark_node *e = make_block(NODE_DOCUMENT, 1, 1); - return e; -} - -cmark_parser *cmark_parser_new() -{ - 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; - - 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 cmark_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 cmark_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 cmark_node that can accept this child, - // then back up til we hit a cmark_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 cmark_node and all children, recursively, parsing -// string content into inline content where appropriate. -static void process_inlines(cmark_node* root, cmark_reference_map *refmap) -{ - 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); - } - } - } - - 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); - - return parser->root; -} - -cmark_node *cmark_parse_file(FILE *f) -{ - unsigned char buffer[4096]; - cmark_parser *parser = cmark_parser_new(); - 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) -{ - cmark_parser *parser = cmark_parser_new(); - 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; - cmark_node* cur = parser->current; - bool blank = false; - int first_nonspace; - int indent; - cmark_chunk input; - - 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 cmark_node, try to parse the associated line start. - // bail out on failure: container will point to the last matching cmark_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 cmark_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); - } - - // unless last matched container is code cmark_node, 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 (cur->type != NODE_PARAGRAPH && !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; - } - } - - // 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 (cur != last_matched_container && - container == last_matched_container && - !blank && - cur->type == NODE_PARAGRAPH && - cmark_strbuf_len(&cur->string_content) > 0) { - - add_line(cur, &input, offset); - - } else { // not a lazy continuation - - // finalize any blocks that were not matched and set cur to container: - while (cur != last_matched_container) { - cur = finalize(parser, cur); - assert(cur != 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); - cmark_strbuf_free(parser->curline); -#if CMARK_DEBUG_NODES - if (cmark_node_check(parser->root, stderr)) { - abort(); - } -#endif - return parser->root; -} diff --git a/buffer.c b/buffer.c deleted file mode 100644 index 0df6561..0000000 --- a/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/buffer.h b/buffer.h deleted file mode 100644 index fb9f910..0000000 --- a/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/case_fold_switch.inc b/case_fold_switch.inc deleted file mode 100644 index 70fdd75..0000000 --- a/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/chunk.h b/chunk.h deleted file mode 100644 index 54c4b16..0000000 --- a/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.c b/cmark.c deleted file mode 100644 index 2ec9be9..0000000 --- a/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) -{ - cmark_node *doc; - char *result; - - doc = cmark_parse_document(text, len); - - result = cmark_render_html(doc, CMARK_OPT_DEFAULT); - cmark_node_free(doc); - - return result; -} - diff --git a/cmark.h b/cmark.h deleted file mode 100644 index 64d8d47..0000000 --- a/cmark.h +++ /dev/null @@ -1,556 +0,0 @@ -#ifndef CMARK_H -#define CMARK_H - -#include -#include "cmark_export.h" -#include "cmark_version.h" - -#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); - -/** ## 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); - * - * Streaming interface: - * - * cmark_parser *parser = cmark_parser_new(); - * 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(); - -/** 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); - -/** Parse a CommonMark document in file 'f', returning a pointer to - * a tree of nodes. - */ -CMARK_EXPORT -cmark_node *cmark_parse_file(FILE *f); - -/** - * ## Rendering - */ - -/** Render a 'node' tree as XML. - */ -CMARK_EXPORT -char *cmark_render_xml(cmark_node *root, long 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, long options); - -/** Render a 'node' tree as a groff man page, without the header. - */ -CMARK_EXPORT -char *cmark_render_man(cmark_node *root, long 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 - -/** - * ## 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 NODE_LINK_LABEL CMARK_NODE_LINK_LABEL -#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_ctype.c b/cmark_ctype.c deleted file mode 100644 index 5de8199..0000000 --- a/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_ctype.h b/cmark_ctype.h deleted file mode 100644 index f803946..0000000 --- a/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_export.h b/cmark_export.h deleted file mode 100644 index 1102c36..0000000 --- a/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_version.h b/cmark_version.h deleted file mode 100644 index f86b6aa..0000000 --- a/cmark_version.h +++ /dev/null @@ -1,7 +0,0 @@ -#ifndef CMARK_VERSION_H -#define CMARK_VERSION_H - -#define CMARK_VERSION ((0 << 16) | (17 << 8) | 0) -#define CMARK_VERSION_STRING "0.17.0" - -#endif diff --git a/cmark_version.h.in b/cmark_version.h.in deleted file mode 100644 index 41de3ac..0000000 --- a/cmark_version.h.in +++ /dev/null @@ -1,7 +0,0 @@ -#ifndef CMARK_VERSION_H -#define CMARK_VERSION_H - -#define CMARK_VERSION ((@PROJECT_VERSION_MAJOR@ << 16) | (@PROJECT_VERSION_MINOR@ << 8) | @PROJECT_VERSION_PATCH@) -#define CMARK_VERSION_STRING "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@" - -#endif diff --git a/commonmark.go b/commonmark.go index 987b39a..bebf08b 100644 --- a/commonmark.go +++ b/commonmark.go @@ -2,7 +2,7 @@ package commonmark /* -#cgo CFLAGS: -std=gnu99 +#cgo LDFLAGS: -lcmark #include #include #include "cmark.h" diff --git a/config.h b/config.h deleted file mode 100644 index 3de8c11..0000000 --- a/config.h +++ /dev/null @@ -1,23 +0,0 @@ -#define HAVE_STDBOOL_H - -#ifdef HAVE_STDBOOL_H - #include -#elif !defined(__cplusplus) - typedef char bool; -#endif - -#define 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/config.h.in b/config.h.in deleted file mode 100644 index c1e9597..0000000 --- a/config.h.in +++ /dev/null @@ -1,23 +0,0 @@ -#cmakedefine HAVE_STDBOOL_H - -#ifdef HAVE_STDBOOL_H - #include -#elif !defined(__cplusplus) - typedef char bool; -#endif - -#cmakedefine HAVE___BUILTIN_EXPECT - -#cmakedefine HAVE___ATTRIBUTE__ - -#ifdef HAVE___ATTRIBUTE__ - #define CMARK_ATTRIBUTE(list) __attribute__ (list) -#else - #define CMARK_ATTRIBUTE(list) -#endif - -#cmakedefine HAVE_VA_COPY - -#ifndef HAVE_VA_COPY - #define va_copy(dest, src) ((dest) = (src)) -#endif diff --git a/debug.h b/debug.h deleted file mode 100644 index fd2ef62..0000000 --- a/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/houdini.h b/houdini.h deleted file mode 100644 index 9f00f6d..0000000 --- a/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/houdini_href_e.c b/houdini_href_e.c deleted file mode 100644 index 7527780..0000000 --- a/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/houdini_html_e.c b/houdini_html_e.c deleted file mode 100644 index 1a4c3e1..0000000 --- a/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/houdini_html_u.c b/houdini_html_u.c deleted file mode 100644 index 2cb14b4..0000000 --- a/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/html.c b/html.c deleted file mode 100644 index 8ccb495..0000000 --- a/html.c +++ /dev/null @@ -1,323 +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, long 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, long 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, long 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/html_unescape.gperf b/html_unescape.gperf deleted file mode 100644 index 74173a6..0000000 --- a/html_unescape.gperf +++ /dev/null @@ -1,2130 +0,0 @@ -struct html_ent { - int entity; - unsigned char utf8[4]; -}; -%% -"Aacute", {195, 129, 0} -"aacute", {195, 161, 0} -"Abreve", {196, 130, 0} -"abreve", {196, 131, 0} -"ac", {226, 136, 190, 0} -"acd", {226, 136, 191, 0} -"acE", {226, 136, 190, 0} -"Acirc", {195, 130, 0} -"acirc", {195, 162, 0} -"acute", {194, 180, 0} -"Acy", {208, 144, 0} -"acy", {208, 176, 0} -"AElig", {195, 134, 0} -"aelig", {195, 166, 0} -"af", {226, 129, 161, 0} -"Afr", {240, 157, 148, 132} -"afr", {240, 157, 148, 158} -"Agrave", {195, 128, 0} -"agrave", {195, 160, 0} -"alefsym", {226, 132, 181, 0} -"aleph", {226, 132, 181, 0} -"Alpha", {206, 145, 0} -"alpha", {206, 177, 0} -"Amacr", {196, 128, 0} -"amacr", {196, 129, 0} -"amalg", {226, 168, 191, 0} -"amp", {38, 0} -"AMP", {38, 0} -"andand", {226, 169, 149, 0} -"And", {226, 169, 147, 0} -"and", {226, 136, 167, 0} -"andd", {226, 169, 156, 0} -"andslope", {226, 169, 152, 0} -"andv", {226, 169, 154, 0} -"ang", {226, 136, 160, 0} -"ange", {226, 166, 164, 0} -"angle", {226, 136, 160, 0} -"angmsdaa", {226, 166, 168, 0} -"angmsdab", {226, 166, 169, 0} -"angmsdac", {226, 166, 170, 0} -"angmsdad", {226, 166, 171, 0} -"angmsdae", {226, 166, 172, 0} -"angmsdaf", {226, 166, 173, 0} -"angmsdag", {226, 166, 174, 0} -"angmsdah", {226, 166, 175, 0} -"angmsd", {226, 136, 161, 0} -"angrt", {226, 136, 159, 0} -"angrtvb", {226, 138, 190, 0} -"angrtvbd", {226, 166, 157, 0} -"angsph", {226, 136, 162, 0} -"angst", {195, 133, 0} -"angzarr", {226, 141, 188, 0} -"Aogon", {196, 132, 0} -"aogon", {196, 133, 0} -"Aopf", {240, 157, 148, 184} -"aopf", {240, 157, 149, 146} -"apacir", {226, 169, 175, 0} -"ap", {226, 137, 136, 0} -"apE", {226, 169, 176, 0} -"ape", {226, 137, 138, 0} -"apid", {226, 137, 139, 0} -"apos", {39, 0} -"ApplyFunction", {226, 129, 161, 0} -"approx", {226, 137, 136, 0} -"approxeq", {226, 137, 138, 0} -"Aring", {195, 133, 0} -"aring", {195, 165, 0} -"Ascr", {240, 157, 146, 156} -"ascr", {240, 157, 146, 182} -"Assign", {226, 137, 148, 0} -"ast", {42, 0} -"asymp", {226, 137, 136, 0} -"asympeq", {226, 137, 141, 0} -"Atilde", {195, 131, 0} -"atilde", {195, 163, 0} -"Auml", {195, 132, 0} -"auml", {195, 164, 0} -"awconint", {226, 136, 179, 0} -"awint", {226, 168, 145, 0} -"backcong", {226, 137, 140, 0} -"backepsilon", {207, 182, 0} -"backprime", {226, 128, 181, 0} -"backsim", {226, 136, 189, 0} -"backsimeq", {226, 139, 141, 0} -"Backslash", {226, 136, 150, 0} -"Barv", {226, 171, 167, 0} -"barvee", {226, 138, 189, 0} -"barwed", {226, 140, 133, 0} -"Barwed", {226, 140, 134, 0} -"barwedge", {226, 140, 133, 0} -"bbrk", {226, 142, 181, 0} -"bbrktbrk", {226, 142, 182, 0} -"bcong", {226, 137, 140, 0} -"Bcy", {208, 145, 0} -"bcy", {208, 177, 0} -"bdquo", {226, 128, 158, 0} -"becaus", {226, 136, 181, 0} -"because", {226, 136, 181, 0} -"Because", {226, 136, 181, 0} -"bemptyv", {226, 166, 176, 0} -"bepsi", {207, 182, 0} -"bernou", {226, 132, 172, 0} -"Bernoullis", {226, 132, 172, 0} -"Beta", {206, 146, 0} -"beta", {206, 178, 0} -"beth", {226, 132, 182, 0} -"between", {226, 137, 172, 0} -"Bfr", {240, 157, 148, 133} -"bfr", {240, 157, 148, 159} -"bigcap", {226, 139, 130, 0} -"bigcirc", {226, 151, 175, 0} -"bigcup", {226, 139, 131, 0} -"bigodot", {226, 168, 128, 0} -"bigoplus", {226, 168, 129, 0} -"bigotimes", {226, 168, 130, 0} -"bigsqcup", {226, 168, 134, 0} -"bigstar", {226, 152, 133, 0} -"bigtriangledown", {226, 150, 189, 0} -"bigtriangleup", {226, 150, 179, 0} -"biguplus", {226, 168, 132, 0} -"bigvee", {226, 139, 129, 0} -"bigwedge", {226, 139, 128, 0} -"bkarow", {226, 164, 141, 0} -"blacklozenge", {226, 167, 171, 0} -"blacksquare", {226, 150, 170, 0} -"blacktriangle", {226, 150, 180, 0} -"blacktriangledown", {226, 150, 190, 0} -"blacktriangleleft", {226, 151, 130, 0} -"blacktriangleright", {226, 150, 184, 0} -"blank", {226, 144, 163, 0} -"blk12", {226, 150, 146, 0} -"blk14", {226, 150, 145, 0} -"blk34", {226, 150, 147, 0} -"block", {226, 150, 136, 0} -"bne", {61, 0} -"bnequiv", {226, 137, 161, 0} -"bNot", {226, 171, 173, 0} -"bnot", {226, 140, 144, 0} -"Bopf", {240, 157, 148, 185} -"bopf", {240, 157, 149, 147} -"bot", {226, 138, 165, 0} -"bottom", {226, 138, 165, 0} -"bowtie", {226, 139, 136, 0} -"boxbox", {226, 167, 137, 0} -"boxdl", {226, 148, 144, 0} -"boxdL", {226, 149, 149, 0} -"boxDl", {226, 149, 150, 0} -"boxDL", {226, 149, 151, 0} -"boxdr", {226, 148, 140, 0} -"boxdR", {226, 149, 146, 0} -"boxDr", {226, 149, 147, 0} -"boxDR", {226, 149, 148, 0} -"boxh", {226, 148, 128, 0} -"boxH", {226, 149, 144, 0} -"boxhd", {226, 148, 172, 0} -"boxHd", {226, 149, 164, 0} -"boxhD", {226, 149, 165, 0} -"boxHD", {226, 149, 166, 0} -"boxhu", {226, 148, 180, 0} -"boxHu", {226, 149, 167, 0} -"boxhU", {226, 149, 168, 0} -"boxHU", {226, 149, 169, 0} -"boxminus", {226, 138, 159, 0} -"boxplus", {226, 138, 158, 0} -"boxtimes", {226, 138, 160, 0} -"boxul", {226, 148, 152, 0} -"boxuL", {226, 149, 155, 0} -"boxUl", {226, 149, 156, 0} -"boxUL", {226, 149, 157, 0} -"boxur", {226, 148, 148, 0} -"boxuR", {226, 149, 152, 0} -"boxUr", {226, 149, 153, 0} -"boxUR", {226, 149, 154, 0} -"boxv", {226, 148, 130, 0} -"boxV", {226, 149, 145, 0} -"boxvh", {226, 148, 188, 0} -"boxvH", {226, 149, 170, 0} -"boxVh", {226, 149, 171, 0} -"boxVH", {226, 149, 172, 0} -"boxvl", {226, 148, 164, 0} -"boxvL", {226, 149, 161, 0} -"boxVl", {226, 149, 162, 0} -"boxVL", {226, 149, 163, 0} -"boxvr", {226, 148, 156, 0} -"boxvR", {226, 149, 158, 0} -"boxVr", {226, 149, 159, 0} -"boxVR", {226, 149, 160, 0} -"bprime", {226, 128, 181, 0} -"breve", {203, 152, 0} -"Breve", {203, 152, 0} -"brvbar", {194, 166, 0} -"bscr", {240, 157, 146, 183} -"Bscr", {226, 132, 172, 0} -"bsemi", {226, 129, 143, 0} -"bsim", {226, 136, 189, 0} -"bsime", {226, 139, 141, 0} -"bsolb", {226, 167, 133, 0} -"bsol", {92, 0} -"bsolhsub", {226, 159, 136, 0} -"bull", {226, 128, 162, 0} -"bullet", {226, 128, 162, 0} -"bump", {226, 137, 142, 0} -"bumpE", {226, 170, 174, 0} -"bumpe", {226, 137, 143, 0} -"Bumpeq", {226, 137, 142, 0} -"bumpeq", {226, 137, 143, 0} -"Cacute", {196, 134, 0} -"cacute", {196, 135, 0} -"capand", {226, 169, 132, 0} -"capbrcup", {226, 169, 137, 0} -"capcap", {226, 169, 139, 0} -"cap", {226, 136, 169, 0} -"Cap", {226, 139, 146, 0} -"capcup", {226, 169, 135, 0} -"capdot", {226, 169, 128, 0} -"CapitalDifferentialD", {226, 133, 133, 0} -"caps", {226, 136, 169, 0} -"caret", {226, 129, 129, 0} -"caron", {203, 135, 0} -"Cayleys", {226, 132, 173, 0} -"ccaps", {226, 169, 141, 0} -"Ccaron", {196, 140, 0} -"ccaron", {196, 141, 0} -"Ccedil", {195, 135, 0} -"ccedil", {195, 167, 0} -"Ccirc", {196, 136, 0} -"ccirc", {196, 137, 0} -"Cconint", {226, 136, 176, 0} -"ccups", {226, 169, 140, 0} -"ccupssm", {226, 169, 144, 0} -"Cdot", {196, 138, 0} -"cdot", {196, 139, 0} -"cedil", {194, 184, 0} -"Cedilla", {194, 184, 0} -"cemptyv", {226, 166, 178, 0} -"cent", {194, 162, 0} -"centerdot", {194, 183, 0} -"CenterDot", {194, 183, 0} -"cfr", {240, 157, 148, 160} -"Cfr", {226, 132, 173, 0} -"CHcy", {208, 167, 0} -"chcy", {209, 135, 0} -"check", {226, 156, 147, 0} -"checkmark", {226, 156, 147, 0} -"Chi", {206, 167, 0} -"chi", {207, 135, 0} -"circ", {203, 134, 0} -"circeq", {226, 137, 151, 0} -"circlearrowleft", {226, 134, 186, 0} -"circlearrowright", {226, 134, 187, 0} -"circledast", {226, 138, 155, 0} -"circledcirc", {226, 138, 154, 0} -"circleddash", {226, 138, 157, 0} -"CircleDot", {226, 138, 153, 0} -"circledR", {194, 174, 0} -"circledS", {226, 147, 136, 0} -"CircleMinus", {226, 138, 150, 0} -"CirclePlus", {226, 138, 149, 0} -"CircleTimes", {226, 138, 151, 0} -"cir", {226, 151, 139, 0} -"cirE", {226, 167, 131, 0} -"cire", {226, 137, 151, 0} -"cirfnint", {226, 168, 144, 0} -"cirmid", {226, 171, 175, 0} -"cirscir", {226, 167, 130, 0} -"ClockwiseContourIntegral", {226, 136, 178, 0} -"CloseCurlyDoubleQuote", {226, 128, 157, 0} -"CloseCurlyQuote", {226, 128, 153, 0} -"clubs", {226, 153, 163, 0} -"clubsuit", {226, 153, 163, 0} -"colon", {58, 0} -"Colon", {226, 136, 183, 0} -"Colone", {226, 169, 180, 0} -"colone", {226, 137, 148, 0} -"coloneq", {226, 137, 148, 0} -"comma", {44, 0} -"commat", {64, 0} -"comp", {226, 136, 129, 0} -"compfn", {226, 136, 152, 0} -"complement", {226, 136, 129, 0} -"complexes", {226, 132, 130, 0} -"cong", {226, 137, 133, 0} -"congdot", {226, 169, 173, 0} -"Congruent", {226, 137, 161, 0} -"conint", {226, 136, 174, 0} -"Conint", {226, 136, 175, 0} -"ContourIntegral", {226, 136, 174, 0} -"copf", {240, 157, 149, 148} -"Copf", {226, 132, 130, 0} -"coprod", {226, 136, 144, 0} -"Coproduct", {226, 136, 144, 0} -"copy", {194, 169, 0} -"COPY", {194, 169, 0} -"copysr", {226, 132, 151, 0} -"CounterClockwiseContourIntegral", {226, 136, 179, 0} -"crarr", {226, 134, 181, 0} -"cross", {226, 156, 151, 0} -"Cross", {226, 168, 175, 0} -"Cscr", {240, 157, 146, 158} -"cscr", {240, 157, 146, 184} -"csub", {226, 171, 143, 0} -"csube", {226, 171, 145, 0} -"csup", {226, 171, 144, 0} -"csupe", {226, 171, 146, 0} -"ctdot", {226, 139, 175, 0} -"cudarrl", {226, 164, 184, 0} -"cudarrr", {226, 164, 181, 0} -"cuepr", {226, 139, 158, 0} -"cuesc", {226, 139, 159, 0} -"cularr", {226, 134, 182, 0} -"cularrp", {226, 164, 189, 0} -"cupbrcap", {226, 169, 136, 0} -"cupcap", {226, 169, 134, 0} -"CupCap", {226, 137, 141, 0} -"cup", {226, 136, 170, 0} -"Cup", {226, 139, 147, 0} -"cupcup", {226, 169, 138, 0} -"cupdot", {226, 138, 141, 0} -"cupor", {226, 169, 133, 0} -"cups", {226, 136, 170, 0} -"curarr", {226, 134, 183, 0} -"curarrm", {226, 164, 188, 0} -"curlyeqprec", {226, 139, 158, 0} -"curlyeqsucc", {226, 139, 159, 0} -"curlyvee", {226, 139, 142, 0} -"curlywedge", {226, 139, 143, 0} -"curren", {194, 164, 0} -"curvearrowleft", {226, 134, 182, 0} -"curvearrowright", {226, 134, 183, 0} -"cuvee", {226, 139, 142, 0} -"cuwed", {226, 139, 143, 0} -"cwconint", {226, 136, 178, 0} -"cwint", {226, 136, 177, 0} -"cylcty", {226, 140, 173, 0} -"dagger", {226, 128, 160, 0} -"Dagger", {226, 128, 161, 0} -"daleth", {226, 132, 184, 0} -"darr", {226, 134, 147, 0} -"Darr", {226, 134, 161, 0} -"dArr", {226, 135, 147, 0} -"dash", {226, 128, 144, 0} -"Dashv", {226, 171, 164, 0} -"dashv", {226, 138, 163, 0} -"dbkarow", {226, 164, 143, 0} -"dblac", {203, 157, 0} -"Dcaron", {196, 142, 0} -"dcaron", {196, 143, 0} -"Dcy", {208, 148, 0} -"dcy", {208, 180, 0} -"ddagger", {226, 128, 161, 0} -"ddarr", {226, 135, 138, 0} -"DD", {226, 133, 133, 0} -"dd", {226, 133, 134, 0} -"DDotrahd", {226, 164, 145, 0} -"ddotseq", {226, 169, 183, 0} -"deg", {194, 176, 0} -"Del", {226, 136, 135, 0} -"Delta", {206, 148, 0} -"delta", {206, 180, 0} -"demptyv", {226, 166, 177, 0} -"dfisht", {226, 165, 191, 0} -"Dfr", {240, 157, 148, 135} -"dfr", {240, 157, 148, 161} -"dHar", {226, 165, 165, 0} -"dharl", {226, 135, 131, 0} -"dharr", {226, 135, 130, 0} -"DiacriticalAcute", {194, 180, 0} -"DiacriticalDot", {203, 153, 0} -"DiacriticalDoubleAcute", {203, 157, 0} -"DiacriticalGrave", {96, 0} -"DiacriticalTilde", {203, 156, 0} -"diam", {226, 139, 132, 0} -"diamond", {226, 139, 132, 0} -"Diamond", {226, 139, 132, 0} -"diamondsuit", {226, 153, 166, 0} -"diams", {226, 153, 166, 0} -"die", {194, 168, 0} -"DifferentialD", {226, 133, 134, 0} -"digamma", {207, 157, 0} -"disin", {226, 139, 178, 0} -"div", {195, 183, 0} -"divide", {195, 183, 0} -"divideontimes", {226, 139, 135, 0} -"divonx", {226, 139, 135, 0} -"DJcy", {208, 130, 0} -"djcy", {209, 146, 0} -"dlcorn", {226, 140, 158, 0} -"dlcrop", {226, 140, 141, 0} -"dollar", {36, 0} -"Dopf", {240, 157, 148, 187} -"dopf", {240, 157, 149, 149} -"Dot", {194, 168, 0} -"dot", {203, 153, 0} -"DotDot", {226, 131, 156, 0} -"doteq", {226, 137, 144, 0} -"doteqdot", {226, 137, 145, 0} -"DotEqual", {226, 137, 144, 0} -"dotminus", {226, 136, 184, 0} -"dotplus", {226, 136, 148, 0} -"dotsquare", {226, 138, 161, 0} -"doublebarwedge", {226, 140, 134, 0} -"DoubleContourIntegral", {226, 136, 175, 0} -"DoubleDot", {194, 168, 0} -"DoubleDownArrow", {226, 135, 147, 0} -"DoubleLeftArrow", {226, 135, 144, 0} -"DoubleLeftRightArrow", {226, 135, 148, 0} -"DoubleLeftTee", {226, 171, 164, 0} -"DoubleLongLeftArrow", {226, 159, 184, 0} -"DoubleLongLeftRightArrow", {226, 159, 186, 0} -"DoubleLongRightArrow", {226, 159, 185, 0} -"DoubleRightArrow", {226, 135, 146, 0} -"DoubleRightTee", {226, 138, 168, 0} -"DoubleUpArrow", {226, 135, 145, 0} -"DoubleUpDownArrow", {226, 135, 149, 0} -"DoubleVerticalBar", {226, 136, 165, 0} -"DownArrowBar", {226, 164, 147, 0} -"downarrow", {226, 134, 147, 0} -"DownArrow", {226, 134, 147, 0} -"Downarrow", {226, 135, 147, 0} -"DownArrowUpArrow", {226, 135, 181, 0} -"DownBreve", {204, 145, 0} -"downdownarrows", {226, 135, 138, 0} -"downharpoonleft", {226, 135, 131, 0} -"downharpoonright", {226, 135, 130, 0} -"DownLeftRightVector", {226, 165, 144, 0} -"DownLeftTeeVector", {226, 165, 158, 0} -"DownLeftVectorBar", {226, 165, 150, 0} -"DownLeftVector", {226, 134, 189, 0} -"DownRightTeeVector", {226, 165, 159, 0} -"DownRightVectorBar", {226, 165, 151, 0} -"DownRightVector", {226, 135, 129, 0} -"DownTeeArrow", {226, 134, 167, 0} -"DownTee", {226, 138, 164, 0} -"drbkarow", {226, 164, 144, 0} -"drcorn", {226, 140, 159, 0} -"drcrop", {226, 140, 140, 0} -"Dscr", {240, 157, 146, 159} -"dscr", {240, 157, 146, 185} -"DScy", {208, 133, 0} -"dscy", {209, 149, 0} -"dsol", {226, 167, 182, 0} -"Dstrok", {196, 144, 0} -"dstrok", {196, 145, 0} -"dtdot", {226, 139, 177, 0} -"dtri", {226, 150, 191, 0} -"dtrif", {226, 150, 190, 0} -"duarr", {226, 135, 181, 0} -"duhar", {226, 165, 175, 0} -"dwangle", {226, 166, 166, 0} -"DZcy", {208, 143, 0} -"dzcy", {209, 159, 0} -"dzigrarr", {226, 159, 191, 0} -"Eacute", {195, 137, 0} -"eacute", {195, 169, 0} -"easter", {226, 169, 174, 0} -"Ecaron", {196, 154, 0} -"ecaron", {196, 155, 0} -"Ecirc", {195, 138, 0} -"ecirc", {195, 170, 0} -"ecir", {226, 137, 150, 0} -"ecolon", {226, 137, 149, 0} -"Ecy", {208, 173, 0} -"ecy", {209, 141, 0} -"eDDot", {226, 169, 183, 0} -"Edot", {196, 150, 0} -"edot", {196, 151, 0} -"eDot", {226, 137, 145, 0} -"ee", {226, 133, 135, 0} -"efDot", {226, 137, 146, 0} -"Efr", {240, 157, 148, 136} -"efr", {240, 157, 148, 162} -"eg", {226, 170, 154, 0} -"Egrave", {195, 136, 0} -"egrave", {195, 168, 0} -"egs", {226, 170, 150, 0} -"egsdot", {226, 170, 152, 0} -"el", {226, 170, 153, 0} -"Element", {226, 136, 136, 0} -"elinters", {226, 143, 167, 0} -"ell", {226, 132, 147, 0} -"els", {226, 170, 149, 0} -"elsdot", {226, 170, 151, 0} -"Emacr", {196, 146, 0} -"emacr", {196, 147, 0} -"empty", {226, 136, 133, 0} -"emptyset", {226, 136, 133, 0} -"EmptySmallSquare", {226, 151, 187, 0} -"emptyv", {226, 136, 133, 0} -"EmptyVerySmallSquare", {226, 150, 171, 0} -"emsp13", {226, 128, 132, 0} -"emsp14", {226, 128, 133, 0} -"emsp", {226, 128, 131, 0} -"ENG", {197, 138, 0} -"eng", {197, 139, 0} -"ensp", {226, 128, 130, 0} -"Eogon", {196, 152, 0} -"eogon", {196, 153, 0} -"Eopf", {240, 157, 148, 188} -"eopf", {240, 157, 149, 150} -"epar", {226, 139, 149, 0} -"eparsl", {226, 167, 163, 0} -"eplus", {226, 169, 177, 0} -"epsi", {206, 181, 0} -"Epsilon", {206, 149, 0} -"epsilon", {206, 181, 0} -"epsiv", {207, 181, 0} -"eqcirc", {226, 137, 150, 0} -"eqcolon", {226, 137, 149, 0} -"eqsim", {226, 137, 130, 0} -"eqslantgtr", {226, 170, 150, 0} -"eqslantless", {226, 170, 149, 0} -"Equal", {226, 169, 181, 0} -"equals", {61, 0} -"EqualTilde", {226, 137, 130, 0} -"equest", {226, 137, 159, 0} -"Equilibrium", {226, 135, 140, 0} -"equiv", {226, 137, 161, 0} -"equivDD", {226, 169, 184, 0} -"eqvparsl", {226, 167, 165, 0} -"erarr", {226, 165, 177, 0} -"erDot", {226, 137, 147, 0} -"escr", {226, 132, 175, 0} -"Escr", {226, 132, 176, 0} -"esdot", {226, 137, 144, 0} -"Esim", {226, 169, 179, 0} -"esim", {226, 137, 130, 0} -"Eta", {206, 151, 0} -"eta", {206, 183, 0} -"ETH", {195, 144, 0} -"eth", {195, 176, 0} -"Euml", {195, 139, 0} -"euml", {195, 171, 0} -"euro", {226, 130, 172, 0} -"excl", {33, 0} -"exist", {226, 136, 131, 0} -"Exists", {226, 136, 131, 0} -"expectation", {226, 132, 176, 0} -"exponentiale", {226, 133, 135, 0} -"ExponentialE", {226, 133, 135, 0} -"fallingdotseq", {226, 137, 146, 0} -"Fcy", {208, 164, 0} -"fcy", {209, 132, 0} -"female", {226, 153, 128, 0} -"ffilig", {239, 172, 131, 0} -"fflig", {239, 172, 128, 0} -"ffllig", {239, 172, 132, 0} -"Ffr", {240, 157, 148, 137} -"ffr", {240, 157, 148, 163} -"filig", {239, 172, 129, 0} -"FilledSmallSquare", {226, 151, 188, 0} -"FilledVerySmallSquare", {226, 150, 170, 0} -"fjlig", {102, 0} -"flat", {226, 153, 173, 0} -"fllig", {239, 172, 130, 0} -"fltns", {226, 150, 177, 0} -"fnof", {198, 146, 0} -"Fopf", {240, 157, 148, 189} -"fopf", {240, 157, 149, 151} -"forall", {226, 136, 128, 0} -"ForAll", {226, 136, 128, 0} -"fork", {226, 139, 148, 0} -"forkv", {226, 171, 153, 0} -"Fouriertrf", {226, 132, 177, 0} -"fpartint", {226, 168, 141, 0} -"frac12", {194, 189, 0} -"frac13", {226, 133, 147, 0} -"frac14", {194, 188, 0} -"frac15", {226, 133, 149, 0} -"frac16", {226, 133, 153, 0} -"frac18", {226, 133, 155, 0} -"frac23", {226, 133, 148, 0} -"frac25", {226, 133, 150, 0} -"frac34", {194, 190, 0} -"frac35", {226, 133, 151, 0} -"frac38", {226, 133, 156, 0} -"frac45", {226, 133, 152, 0} -"frac56", {226, 133, 154, 0} -"frac58", {226, 133, 157, 0} -"frac78", {226, 133, 158, 0} -"frasl", {226, 129, 132, 0} -"frown", {226, 140, 162, 0} -"fscr", {240, 157, 146, 187} -"Fscr", {226, 132, 177, 0} -"gacute", {199, 181, 0} -"Gamma", {206, 147, 0} -"gamma", {206, 179, 0} -"Gammad", {207, 156, 0} -"gammad", {207, 157, 0} -"gap", {226, 170, 134, 0} -"Gbreve", {196, 158, 0} -"gbreve", {196, 159, 0} -"Gcedil", {196, 162, 0} -"Gcirc", {196, 156, 0} -"gcirc", {196, 157, 0} -"Gcy", {208, 147, 0} -"gcy", {208, 179, 0} -"Gdot", {196, 160, 0} -"gdot", {196, 161, 0} -"ge", {226, 137, 165, 0} -"gE", {226, 137, 167, 0} -"gEl", {226, 170, 140, 0} -"gel", {226, 139, 155, 0} -"geq", {226, 137, 165, 0} -"geqq", {226, 137, 167, 0} -"geqslant", {226, 169, 190, 0} -"gescc", {226, 170, 169, 0} -"ges", {226, 169, 190, 0} -"gesdot", {226, 170, 128, 0} -"gesdoto", {226, 170, 130, 0} -"gesdotol", {226, 170, 132, 0} -"gesl", {226, 139, 155, 0} -"gesles", {226, 170, 148, 0} -"Gfr", {240, 157, 148, 138} -"gfr", {240, 157, 148, 164} -"gg", {226, 137, 171, 0} -"Gg", {226, 139, 153, 0} -"ggg", {226, 139, 153, 0} -"gimel", {226, 132, 183, 0} -"GJcy", {208, 131, 0} -"gjcy", {209, 147, 0} -"gla", {226, 170, 165, 0} -"gl", {226, 137, 183, 0} -"glE", {226, 170, 146, 0} -"glj", {226, 170, 164, 0} -"gnap", {226, 170, 138, 0} -"gnapprox", {226, 170, 138, 0} -"gne", {226, 170, 136, 0} -"gnE", {226, 137, 169, 0} -"gneq", {226, 170, 136, 0} -"gneqq", {226, 137, 169, 0} -"gnsim", {226, 139, 167, 0} -"Gopf", {240, 157, 148, 190} -"gopf", {240, 157, 149, 152} -"grave", {96, 0} -"GreaterEqual", {226, 137, 165, 0} -"GreaterEqualLess", {226, 139, 155, 0} -"GreaterFullEqual", {226, 137, 167, 0} -"GreaterGreater", {226, 170, 162, 0} -"GreaterLess", {226, 137, 183, 0} -"GreaterSlantEqual", {226, 169, 190, 0} -"GreaterTilde", {226, 137, 179, 0} -"Gscr", {240, 157, 146, 162} -"gscr", {226, 132, 138, 0} -"gsim", {226, 137, 179, 0} -"gsime", {226, 170, 142, 0} -"gsiml", {226, 170, 144, 0} -"gtcc", {226, 170, 167, 0} -"gtcir", {226, 169, 186, 0} -"gt", {62, 0} -"GT", {62, 0} -"Gt", {226, 137, 171, 0} -"gtdot", {226, 139, 151, 0} -"gtlPar", {226, 166, 149, 0} -"gtquest", {226, 169, 188, 0} -"gtrapprox", {226, 170, 134, 0} -"gtrarr", {226, 165, 184, 0} -"gtrdot", {226, 139, 151, 0} -"gtreqless", {226, 139, 155, 0} -"gtreqqless", {226, 170, 140, 0} -"gtrless", {226, 137, 183, 0} -"gtrsim", {226, 137, 179, 0} -"gvertneqq", {226, 137, 169, 0} -"gvnE", {226, 137, 169, 0} -"Hacek", {203, 135, 0} -"hairsp", {226, 128, 138, 0} -"half", {194, 189, 0} -"hamilt", {226, 132, 139, 0} -"HARDcy", {208, 170, 0} -"hardcy", {209, 138, 0} -"harrcir", {226, 165, 136, 0} -"harr", {226, 134, 148, 0} -"hArr", {226, 135, 148, 0} -"harrw", {226, 134, 173, 0} -"Hat", {94, 0} -"hbar", {226, 132, 143, 0} -"Hcirc", {196, 164, 0} -"hcirc", {196, 165, 0} -"hearts", {226, 153, 165, 0} -"heartsuit", {226, 153, 165, 0} -"hellip", {226, 128, 166, 0} -"hercon", {226, 138, 185, 0} -"hfr", {240, 157, 148, 165} -"Hfr", {226, 132, 140, 0} -"HilbertSpace", {226, 132, 139, 0} -"hksearow", {226, 164, 165, 0} -"hkswarow", {226, 164, 166, 0} -"hoarr", {226, 135, 191, 0} -"homtht", {226, 136, 187, 0} -"hookleftarrow", {226, 134, 169, 0} -"hookrightarrow", {226, 134, 170, 0} -"hopf", {240, 157, 149, 153} -"Hopf", {226, 132, 141, 0} -"horbar", {226, 128, 149, 0} -"HorizontalLine", {226, 148, 128, 0} -"hscr", {240, 157, 146, 189} -"Hscr", {226, 132, 139, 0} -"hslash", {226, 132, 143, 0} -"Hstrok", {196, 166, 0} -"hstrok", {196, 167, 0} -"HumpDownHump", {226, 137, 142, 0} -"HumpEqual", {226, 137, 143, 0} -"hybull", {226, 129, 131, 0} -"hyphen", {226, 128, 144, 0} -"Iacute", {195, 141, 0} -"iacute", {195, 173, 0} -"ic", {226, 129, 163, 0} -"Icirc", {195, 142, 0} -"icirc", {195, 174, 0} -"Icy", {208, 152, 0} -"icy", {208, 184, 0} -"Idot", {196, 176, 0} -"IEcy", {208, 149, 0} -"iecy", {208, 181, 0} -"iexcl", {194, 161, 0} -"iff", {226, 135, 148, 0} -"ifr", {240, 157, 148, 166} -"Ifr", {226, 132, 145, 0} -"Igrave", {195, 140, 0} -"igrave", {195, 172, 0} -"ii", {226, 133, 136, 0} -"iiiint", {226, 168, 140, 0} -"iiint", {226, 136, 173, 0} -"iinfin", {226, 167, 156, 0} -"iiota", {226, 132, 169, 0} -"IJlig", {196, 178, 0} -"ijlig", {196, 179, 0} -"Imacr", {196, 170, 0} -"imacr", {196, 171, 0} -"image", {226, 132, 145, 0} -"ImaginaryI", {226, 133, 136, 0} -"imagline", {226, 132, 144, 0} -"imagpart", {226, 132, 145, 0} -"imath", {196, 177, 0} -"Im", {226, 132, 145, 0} -"imof", {226, 138, 183, 0} -"imped", {198, 181, 0} -"Implies", {226, 135, 146, 0} -"incare", {226, 132, 133, 0} -"in", {226, 136, 136, 0} -"infin", {226, 136, 158, 0} -"infintie", {226, 167, 157, 0} -"inodot", {196, 177, 0} -"intcal", {226, 138, 186, 0} -"int", {226, 136, 171, 0} -"Int", {226, 136, 172, 0} -"integers", {226, 132, 164, 0} -"Integral", {226, 136, 171, 0} -"intercal", {226, 138, 186, 0} -"Intersection", {226, 139, 130, 0} -"intlarhk", {226, 168, 151, 0} -"intprod", {226, 168, 188, 0} -"InvisibleComma", {226, 129, 163, 0} -"InvisibleTimes", {226, 129, 162, 0} -"IOcy", {208, 129, 0} -"iocy", {209, 145, 0} -"Iogon", {196, 174, 0} -"iogon", {196, 175, 0} -"Iopf", {240, 157, 149, 128} -"iopf", {240, 157, 149, 154} -"Iota", {206, 153, 0} -"iota", {206, 185, 0} -"iprod", {226, 168, 188, 0} -"iquest", {194, 191, 0} -"iscr", {240, 157, 146, 190} -"Iscr", {226, 132, 144, 0} -"isin", {226, 136, 136, 0} -"isindot", {226, 139, 181, 0} -"isinE", {226, 139, 185, 0} -"isins", {226, 139, 180, 0} -"isinsv", {226, 139, 179, 0} -"isinv", {226, 136, 136, 0} -"it", {226, 129, 162, 0} -"Itilde", {196, 168, 0} -"itilde", {196, 169, 0} -"Iukcy", {208, 134, 0} -"iukcy", {209, 150, 0} -"Iuml", {195, 143, 0} -"iuml", {195, 175, 0} -"Jcirc", {196, 180, 0} -"jcirc", {196, 181, 0} -"Jcy", {208, 153, 0} -"jcy", {208, 185, 0} -"Jfr", {240, 157, 148, 141} -"jfr", {240, 157, 148, 167} -"jmath", {200, 183, 0} -"Jopf", {240, 157, 149, 129} -"jopf", {240, 157, 149, 155} -"Jscr", {240, 157, 146, 165} -"jscr", {240, 157, 146, 191} -"Jsercy", {208, 136, 0} -"jsercy", {209, 152, 0} -"Jukcy", {208, 132, 0} -"jukcy", {209, 148, 0} -"Kappa", {206, 154, 0} -"kappa", {206, 186, 0} -"kappav", {207, 176, 0} -"Kcedil", {196, 182, 0} -"kcedil", {196, 183, 0} -"Kcy", {208, 154, 0} -"kcy", {208, 186, 0} -"Kfr", {240, 157, 148, 142} -"kfr", {240, 157, 148, 168} -"kgreen", {196, 184, 0} -"KHcy", {208, 165, 0} -"khcy", {209, 133, 0} -"KJcy", {208, 140, 0} -"kjcy", {209, 156, 0} -"Kopf", {240, 157, 149, 130} -"kopf", {240, 157, 149, 156} -"Kscr", {240, 157, 146, 166} -"kscr", {240, 157, 147, 128} -"lAarr", {226, 135, 154, 0} -"Lacute", {196, 185, 0} -"lacute", {196, 186, 0} -"laemptyv", {226, 166, 180, 0} -"lagran", {226, 132, 146, 0} -"Lambda", {206, 155, 0} -"lambda", {206, 187, 0} -"lang", {226, 159, 168, 0} -"Lang", {226, 159, 170, 0} -"langd", {226, 166, 145, 0} -"langle", {226, 159, 168, 0} -"lap", {226, 170, 133, 0} -"Laplacetrf", {226, 132, 146, 0} -"laquo", {194, 171, 0} -"larrb", {226, 135, 164, 0} -"larrbfs", {226, 164, 159, 0} -"larr", {226, 134, 144, 0} -"Larr", {226, 134, 158, 0} -"lArr", {226, 135, 144, 0} -"larrfs", {226, 164, 157, 0} -"larrhk", {226, 134, 169, 0} -"larrlp", {226, 134, 171, 0} -"larrpl", {226, 164, 185, 0} -"larrsim", {226, 165, 179, 0} -"larrtl", {226, 134, 162, 0} -"latail", {226, 164, 153, 0} -"lAtail", {226, 164, 155, 0} -"lat", {226, 170, 171, 0} -"late", {226, 170, 173, 0} -"lates", {226, 170, 173, 0} -"lbarr", {226, 164, 140, 0} -"lBarr", {226, 164, 142, 0} -"lbbrk", {226, 157, 178, 0} -"lbrace", {123, 0} -"lbrack", {91, 0} -"lbrke", {226, 166, 139, 0} -"lbrksld", {226, 166, 143, 0} -"lbrkslu", {226, 166, 141, 0} -"Lcaron", {196, 189, 0} -"lcaron", {196, 190, 0} -"Lcedil", {196, 187, 0} -"lcedil", {196, 188, 0} -"lceil", {226, 140, 136, 0} -"lcub", {123, 0} -"Lcy", {208, 155, 0} -"lcy", {208, 187, 0} -"ldca", {226, 164, 182, 0} -"ldquo", {226, 128, 156, 0} -"ldquor", {226, 128, 158, 0} -"ldrdhar", {226, 165, 167, 0} -"ldrushar", {226, 165, 139, 0} -"ldsh", {226, 134, 178, 0} -"le", {226, 137, 164, 0} -"lE", {226, 137, 166, 0} -"LeftAngleBracket", {226, 159, 168, 0} -"LeftArrowBar", {226, 135, 164, 0} -"leftarrow", {226, 134, 144, 0} -"LeftArrow", {226, 134, 144, 0} -"Leftarrow", {226, 135, 144, 0} -"LeftArrowRightArrow", {226, 135, 134, 0} -"leftarrowtail", {226, 134, 162, 0} -"LeftCeiling", {226, 140, 136, 0} -"LeftDoubleBracket", {226, 159, 166, 0} -"LeftDownTeeVector", {226, 165, 161, 0} -"LeftDownVectorBar", {226, 165, 153, 0} -"LeftDownVector", {226, 135, 131, 0} -"LeftFloor", {226, 140, 138, 0} -"leftharpoondown", {226, 134, 189, 0} -"leftharpoonup", {226, 134, 188, 0} -"leftleftarrows", {226, 135, 135, 0} -"leftrightarrow", {226, 134, 148, 0} -"LeftRightArrow", {226, 134, 148, 0} -"Leftrightarrow", {226, 135, 148, 0} -"leftrightarrows", {226, 135, 134, 0} -"leftrightharpoons", {226, 135, 139, 0} -"leftrightsquigarrow", {226, 134, 173, 0} -"LeftRightVector", {226, 165, 142, 0} -"LeftTeeArrow", {226, 134, 164, 0} -"LeftTee", {226, 138, 163, 0} -"LeftTeeVector", {226, 165, 154, 0} -"leftthreetimes", {226, 139, 139, 0} -"LeftTriangleBar", {226, 167, 143, 0} -"LeftTriangle", {226, 138, 178, 0} -"LeftTriangleEqual", {226, 138, 180, 0} -"LeftUpDownVector", {226, 165, 145, 0} -"LeftUpTeeVector", {226, 165, 160, 0} -"LeftUpVectorBar", {226, 165, 152, 0} -"LeftUpVector", {226, 134, 191, 0} -"LeftVectorBar", {226, 165, 146, 0} -"LeftVector", {226, 134, 188, 0} -"lEg", {226, 170, 139, 0} -"leg", {226, 139, 154, 0} -"leq", {226, 137, 164, 0} -"leqq", {226, 137, 166, 0} -"leqslant", {226, 169, 189, 0} -"lescc", {226, 170, 168, 0} -"les", {226, 169, 189, 0} -"lesdot", {226, 169, 191, 0} -"lesdoto", {226, 170, 129, 0} -"lesdotor", {226, 170, 131, 0} -"lesg", {226, 139, 154, 0} -"lesges", {226, 170, 147, 0} -"lessapprox", {226, 170, 133, 0} -"lessdot", {226, 139, 150, 0} -"lesseqgtr", {226, 139, 154, 0} -"lesseqqgtr", {226, 170, 139, 0} -"LessEqualGreater", {226, 139, 154, 0} -"LessFullEqual", {226, 137, 166, 0} -"LessGreater", {226, 137, 182, 0} -"lessgtr", {226, 137, 182, 0} -"LessLess", {226, 170, 161, 0} -"lesssim", {226, 137, 178, 0} -"LessSlantEqual", {226, 169, 189, 0} -"LessTilde", {226, 137, 178, 0} -"lfisht", {226, 165, 188, 0} -"lfloor", {226, 140, 138, 0} -"Lfr", {240, 157, 148, 143} -"lfr", {240, 157, 148, 169} -"lg", {226, 137, 182, 0} -"lgE", {226, 170, 145, 0} -"lHar", {226, 165, 162, 0} -"lhard", {226, 134, 189, 0} -"lharu", {226, 134, 188, 0} -"lharul", {226, 165, 170, 0} -"lhblk", {226, 150, 132, 0} -"LJcy", {208, 137, 0} -"ljcy", {209, 153, 0} -"llarr", {226, 135, 135, 0} -"ll", {226, 137, 170, 0} -"Ll", {226, 139, 152, 0} -"llcorner", {226, 140, 158, 0} -"Lleftarrow", {226, 135, 154, 0} -"llhard", {226, 165, 171, 0} -"lltri", {226, 151, 186, 0} -"Lmidot", {196, 191, 0} -"lmidot", {197, 128, 0} -"lmoustache", {226, 142, 176, 0} -"lmoust", {226, 142, 176, 0} -"lnap", {226, 170, 137, 0} -"lnapprox", {226, 170, 137, 0} -"lne", {226, 170, 135, 0} -"lnE", {226, 137, 168, 0} -"lneq", {226, 170, 135, 0} -"lneqq", {226, 137, 168, 0} -"lnsim", {226, 139, 166, 0} -"loang", {226, 159, 172, 0} -"loarr", {226, 135, 189, 0} -"lobrk", {226, 159, 166, 0} -"longleftarrow", {226, 159, 181, 0} -"LongLeftArrow", {226, 159, 181, 0} -"Longleftarrow", {226, 159, 184, 0} -"longleftrightarrow", {226, 159, 183, 0} -"LongLeftRightArrow", {226, 159, 183, 0} -"Longleftrightarrow", {226, 159, 186, 0} -"longmapsto", {226, 159, 188, 0} -"longrightarrow", {226, 159, 182, 0} -"LongRightArrow", {226, 159, 182, 0} -"Longrightarrow", {226, 159, 185, 0} -"looparrowleft", {226, 134, 171, 0} -"looparrowright", {226, 134, 172, 0} -"lopar", {226, 166, 133, 0} -"Lopf", {240, 157, 149, 131} -"lopf", {240, 157, 149, 157} -"loplus", {226, 168, 173, 0} -"lotimes", {226, 168, 180, 0} -"lowast", {226, 136, 151, 0} -"lowbar", {95, 0} -"LowerLeftArrow", {226, 134, 153, 0} -"LowerRightArrow", {226, 134, 152, 0} -"loz", {226, 151, 138, 0} -"lozenge", {226, 151, 138, 0} -"lozf", {226, 167, 171, 0} -"lpar", {40, 0} -"lparlt", {226, 166, 147, 0} -"lrarr", {226, 135, 134, 0} -"lrcorner", {226, 140, 159, 0} -"lrhar", {226, 135, 139, 0} -"lrhard", {226, 165, 173, 0} -"lrm", {226, 128, 142, 0} -"lrtri", {226, 138, 191, 0} -"lsaquo", {226, 128, 185, 0} -"lscr", {240, 157, 147, 129} -"Lscr", {226, 132, 146, 0} -"lsh", {226, 134, 176, 0} -"Lsh", {226, 134, 176, 0} -"lsim", {226, 137, 178, 0} -"lsime", {226, 170, 141, 0} -"lsimg", {226, 170, 143, 0} -"lsqb", {91, 0} -"lsquo", {226, 128, 152, 0} -"lsquor", {226, 128, 154, 0} -"Lstrok", {197, 129, 0} -"lstrok", {197, 130, 0} -"ltcc", {226, 170, 166, 0} -"ltcir", {226, 169, 185, 0} -"lt", {60, 0} -"LT", {60, 0} -"Lt", {226, 137, 170, 0} -"ltdot", {226, 139, 150, 0} -"lthree", {226, 139, 139, 0} -"ltimes", {226, 139, 137, 0} -"ltlarr", {226, 165, 182, 0} -"ltquest", {226, 169, 187, 0} -"ltri", {226, 151, 131, 0} -"ltrie", {226, 138, 180, 0} -"ltrif", {226, 151, 130, 0} -"ltrPar", {226, 166, 150, 0} -"lurdshar", {226, 165, 138, 0} -"luruhar", {226, 165, 166, 0} -"lvertneqq", {226, 137, 168, 0} -"lvnE", {226, 137, 168, 0} -"macr", {194, 175, 0} -"male", {226, 153, 130, 0} -"malt", {226, 156, 160, 0} -"maltese", {226, 156, 160, 0} -"Map", {226, 164, 133, 0} -"map", {226, 134, 166, 0} -"mapsto", {226, 134, 166, 0} -"mapstodown", {226, 134, 167, 0} -"mapstoleft", {226, 134, 164, 0} -"mapstoup", {226, 134, 165, 0} -"marker", {226, 150, 174, 0} -"mcomma", {226, 168, 169, 0} -"Mcy", {208, 156, 0} -"mcy", {208, 188, 0} -"mdash", {226, 128, 148, 0} -"mDDot", {226, 136, 186, 0} -"measuredangle", {226, 136, 161, 0} -"MediumSpace", {226, 129, 159, 0} -"Mellintrf", {226, 132, 179, 0} -"Mfr", {240, 157, 148, 144} -"mfr", {240, 157, 148, 170} -"mho", {226, 132, 167, 0} -"micro", {194, 181, 0} -"midast", {42, 0} -"midcir", {226, 171, 176, 0} -"mid", {226, 136, 163, 0} -"middot", {194, 183, 0} -"minusb", {226, 138, 159, 0} -"minus", {226, 136, 146, 0} -"minusd", {226, 136, 184, 0} -"minusdu", {226, 168, 170, 0} -"MinusPlus", {226, 136, 147, 0} -"mlcp", {226, 171, 155, 0} -"mldr", {226, 128, 166, 0} -"mnplus", {226, 136, 147, 0} -"models", {226, 138, 167, 0} -"Mopf", {240, 157, 149, 132} -"mopf", {240, 157, 149, 158} -"mp", {226, 136, 147, 0} -"mscr", {240, 157, 147, 130} -"Mscr", {226, 132, 179, 0} -"mstpos", {226, 136, 190, 0} -"Mu", {206, 156, 0} -"mu", {206, 188, 0} -"multimap", {226, 138, 184, 0} -"mumap", {226, 138, 184, 0} -"nabla", {226, 136, 135, 0} -"Nacute", {197, 131, 0} -"nacute", {197, 132, 0} -"nang", {226, 136, 160, 0} -"nap", {226, 137, 137, 0} -"napE", {226, 169, 176, 0} -"napid", {226, 137, 139, 0} -"napos", {197, 137, 0} -"napprox", {226, 137, 137, 0} -"natural", {226, 153, 174, 0} -"naturals", {226, 132, 149, 0} -"natur", {226, 153, 174, 0} -"nbsp", {194, 160, 0} -"nbump", {226, 137, 142, 0} -"nbumpe", {226, 137, 143, 0} -"ncap", {226, 169, 131, 0} -"Ncaron", {197, 135, 0} -"ncaron", {197, 136, 0} -"Ncedil", {197, 133, 0} -"ncedil", {197, 134, 0} -"ncong", {226, 137, 135, 0} -"ncongdot", {226, 169, 173, 0} -"ncup", {226, 169, 130, 0} -"Ncy", {208, 157, 0} -"ncy", {208, 189, 0} -"ndash", {226, 128, 147, 0} -"nearhk", {226, 164, 164, 0} -"nearr", {226, 134, 151, 0} -"neArr", {226, 135, 151, 0} -"nearrow", {226, 134, 151, 0} -"ne", {226, 137, 160, 0} -"nedot", {226, 137, 144, 0} -"NegativeMediumSpace", {226, 128, 139, 0} -"NegativeThickSpace", {226, 128, 139, 0} -"NegativeThinSpace", {226, 128, 139, 0} -"NegativeVeryThinSpace", {226, 128, 139, 0} -"nequiv", {226, 137, 162, 0} -"nesear", {226, 164, 168, 0} -"nesim", {226, 137, 130, 0} -"NestedGreaterGreater", {226, 137, 171, 0} -"NestedLessLess", {226, 137, 170, 0} -"NewLine", {10, 0} -"nexist", {226, 136, 132, 0} -"nexists", {226, 136, 132, 0} -"Nfr", {240, 157, 148, 145} -"nfr", {240, 157, 148, 171} -"ngE", {226, 137, 167, 0} -"nge", {226, 137, 177, 0} -"ngeq", {226, 137, 177, 0} -"ngeqq", {226, 137, 167, 0} -"ngeqslant", {226, 169, 190, 0} -"nges", {226, 169, 190, 0} -"nGg", {226, 139, 153, 0} -"ngsim", {226, 137, 181, 0} -"nGt", {226, 137, 171, 0} -"ngt", {226, 137, 175, 0} -"ngtr", {226, 137, 175, 0} -"nGtv", {226, 137, 171, 0} -"nharr", {226, 134, 174, 0} -"nhArr", {226, 135, 142, 0} -"nhpar", {226, 171, 178, 0} -"ni", {226, 136, 139, 0} -"nis", {226, 139, 188, 0} -"nisd", {226, 139, 186, 0} -"niv", {226, 136, 139, 0} -"NJcy", {208, 138, 0} -"njcy", {209, 154, 0} -"nlarr", {226, 134, 154, 0} -"nlArr", {226, 135, 141, 0} -"nldr", {226, 128, 165, 0} -"nlE", {226, 137, 166, 0} -"nle", {226, 137, 176, 0} -"nleftarrow", {226, 134, 154, 0} -"nLeftarrow", {226, 135, 141, 0} -"nleftrightarrow", {226, 134, 174, 0} -"nLeftrightarrow", {226, 135, 142, 0} -"nleq", {226, 137, 176, 0} -"nleqq", {226, 137, 166, 0} -"nleqslant", {226, 169, 189, 0} -"nles", {226, 169, 189, 0} -"nless", {226, 137, 174, 0} -"nLl", {226, 139, 152, 0} -"nlsim", {226, 137, 180, 0} -"nLt", {226, 137, 170, 0} -"nlt", {226, 137, 174, 0} -"nltri", {226, 139, 170, 0} -"nltrie", {226, 139, 172, 0} -"nLtv", {226, 137, 170, 0} -"nmid", {226, 136, 164, 0} -"NoBreak", {226, 129, 160, 0} -"NonBreakingSpace", {194, 160, 0} -"nopf", {240, 157, 149, 159} -"Nopf", {226, 132, 149, 0} -"Not", {226, 171, 172, 0} -"not", {194, 172, 0} -"NotCongruent", {226, 137, 162, 0} -"NotCupCap", {226, 137, 173, 0} -"NotDoubleVerticalBar", {226, 136, 166, 0} -"NotElement", {226, 136, 137, 0} -"NotEqual", {226, 137, 160, 0} -"NotEqualTilde", {226, 137, 130, 0} -"NotExists", {226, 136, 132, 0} -"NotGreater", {226, 137, 175, 0} -"NotGreaterEqual", {226, 137, 177, 0} -"NotGreaterFullEqual", {226, 137, 167, 0} -"NotGreaterGreater", {226, 137, 171, 0} -"NotGreaterLess", {226, 137, 185, 0} -"NotGreaterSlantEqual", {226, 169, 190, 0} -"NotGreaterTilde", {226, 137, 181, 0} -"NotHumpDownHump", {226, 137, 142, 0} -"NotHumpEqual", {226, 137, 143, 0} -"notin", {226, 136, 137, 0} -"notindot", {226, 139, 181, 0} -"notinE", {226, 139, 185, 0} -"notinva", {226, 136, 137, 0} -"notinvb", {226, 139, 183, 0} -"notinvc", {226, 139, 182, 0} -"NotLeftTriangleBar", {226, 167, 143, 0} -"NotLeftTriangle", {226, 139, 170, 0} -"NotLeftTriangleEqual", {226, 139, 172, 0} -"NotLess", {226, 137, 174, 0} -"NotLessEqual", {226, 137, 176, 0} -"NotLessGreater", {226, 137, 184, 0} -"NotLessLess", {226, 137, 170, 0} -"NotLessSlantEqual", {226, 169, 189, 0} -"NotLessTilde", {226, 137, 180, 0} -"NotNestedGreaterGreater", {226, 170, 162, 0} -"NotNestedLessLess", {226, 170, 161, 0} -"notni", {226, 136, 140, 0} -"notniva", {226, 136, 140, 0} -"notnivb", {226, 139, 190, 0} -"notnivc", {226, 139, 189, 0} -"NotPrecedes", {226, 138, 128, 0} -"NotPrecedesEqual", {226, 170, 175, 0} -"NotPrecedesSlantEqual", {226, 139, 160, 0} -"NotReverseElement", {226, 136, 140, 0} -"NotRightTriangleBar", {226, 167, 144, 0} -"NotRightTriangle", {226, 139, 171, 0} -"NotRightTriangleEqual", {226, 139, 173, 0} -"NotSquareSubset", {226, 138, 143, 0} -"NotSquareSubsetEqual", {226, 139, 162, 0} -"NotSquareSuperset", {226, 138, 144, 0} -"NotSquareSupersetEqual", {226, 139, 163, 0} -"NotSubset", {226, 138, 130, 0} -"NotSubsetEqual", {226, 138, 136, 0} -"NotSucceeds", {226, 138, 129, 0} -"NotSucceedsEqual", {226, 170, 176, 0} -"NotSucceedsSlantEqual", {226, 139, 161, 0} -"NotSucceedsTilde", {226, 137, 191, 0} -"NotSuperset", {226, 138, 131, 0} -"NotSupersetEqual", {226, 138, 137, 0} -"NotTilde", {226, 137, 129, 0} -"NotTildeEqual", {226, 137, 132, 0} -"NotTildeFullEqual", {226, 137, 135, 0} -"NotTildeTilde", {226, 137, 137, 0} -"NotVerticalBar", {226, 136, 164, 0} -"nparallel", {226, 136, 166, 0} -"npar", {226, 136, 166, 0} -"nparsl", {226, 171, 189, 0} -"npart", {226, 136, 130, 0} -"npolint", {226, 168, 148, 0} -"npr", {226, 138, 128, 0} -"nprcue", {226, 139, 160, 0} -"nprec", {226, 138, 128, 0} -"npreceq", {226, 170, 175, 0} -"npre", {226, 170, 175, 0} -"nrarrc", {226, 164, 179, 0} -"nrarr", {226, 134, 155, 0} -"nrArr", {226, 135, 143, 0} -"nrarrw", {226, 134, 157, 0} -"nrightarrow", {226, 134, 155, 0} -"nRightarrow", {226, 135, 143, 0} -"nrtri", {226, 139, 171, 0} -"nrtrie", {226, 139, 173, 0} -"nsc", {226, 138, 129, 0} -"nsccue", {226, 139, 161, 0} -"nsce", {226, 170, 176, 0} -"Nscr", {240, 157, 146, 169} -"nscr", {240, 157, 147, 131} -"nshortmid", {226, 136, 164, 0} -"nshortparallel", {226, 136, 166, 0} -"nsim", {226, 137, 129, 0} -"nsime", {226, 137, 132, 0} -"nsimeq", {226, 137, 132, 0} -"nsmid", {226, 136, 164, 0} -"nspar", {226, 136, 166, 0} -"nsqsube", {226, 139, 162, 0} -"nsqsupe", {226, 139, 163, 0} -"nsub", {226, 138, 132, 0} -"nsubE", {226, 171, 133, 0} -"nsube", {226, 138, 136, 0} -"nsubset", {226, 138, 130, 0} -"nsubseteq", {226, 138, 136, 0} -"nsubseteqq", {226, 171, 133, 0} -"nsucc", {226, 138, 129, 0} -"nsucceq", {226, 170, 176, 0} -"nsup", {226, 138, 133, 0} -"nsupE", {226, 171, 134, 0} -"nsupe", {226, 138, 137, 0} -"nsupset", {226, 138, 131, 0} -"nsupseteq", {226, 138, 137, 0} -"nsupseteqq", {226, 171, 134, 0} -"ntgl", {226, 137, 185, 0} -"Ntilde", {195, 145, 0} -"ntilde", {195, 177, 0} -"ntlg", {226, 137, 184, 0} -"ntriangleleft", {226, 139, 170, 0} -"ntrianglelefteq", {226, 139, 172, 0} -"ntriangleright", {226, 139, 171, 0} -"ntrianglerighteq", {226, 139, 173, 0} -"Nu", {206, 157, 0} -"nu", {206, 189, 0} -"num", {35, 0} -"numero", {226, 132, 150, 0} -"numsp", {226, 128, 135, 0} -"nvap", {226, 137, 141, 0} -"nvdash", {226, 138, 172, 0} -"nvDash", {226, 138, 173, 0} -"nVdash", {226, 138, 174, 0} -"nVDash", {226, 138, 175, 0} -"nvge", {226, 137, 165, 0} -"nvgt", {62, 0} -"nvHarr", {226, 164, 132, 0} -"nvinfin", {226, 167, 158, 0} -"nvlArr", {226, 164, 130, 0} -"nvle", {226, 137, 164, 0} -"nvlt", {60, 0} -"nvltrie", {226, 138, 180, 0} -"nvrArr", {226, 164, 131, 0} -"nvrtrie", {226, 138, 181, 0} -"nvsim", {226, 136, 188, 0} -"nwarhk", {226, 164, 163, 0} -"nwarr", {226, 134, 150, 0} -"nwArr", {226, 135, 150, 0} -"nwarrow", {226, 134, 150, 0} -"nwnear", {226, 164, 167, 0} -"Oacute", {195, 147, 0} -"oacute", {195, 179, 0} -"oast", {226, 138, 155, 0} -"Ocirc", {195, 148, 0} -"ocirc", {195, 180, 0} -"ocir", {226, 138, 154, 0} -"Ocy", {208, 158, 0} -"ocy", {208, 190, 0} -"odash", {226, 138, 157, 0} -"Odblac", {197, 144, 0} -"odblac", {197, 145, 0} -"odiv", {226, 168, 184, 0} -"odot", {226, 138, 153, 0} -"odsold", {226, 166, 188, 0} -"OElig", {197, 146, 0} -"oelig", {197, 147, 0} -"ofcir", {226, 166, 191, 0} -"Ofr", {240, 157, 148, 146} -"ofr", {240, 157, 148, 172} -"ogon", {203, 155, 0} -"Ograve", {195, 146, 0} -"ograve", {195, 178, 0} -"ogt", {226, 167, 129, 0} -"ohbar", {226, 166, 181, 0} -"ohm", {206, 169, 0} -"oint", {226, 136, 174, 0} -"olarr", {226, 134, 186, 0} -"olcir", {226, 166, 190, 0} -"olcross", {226, 166, 187, 0} -"oline", {226, 128, 190, 0} -"olt", {226, 167, 128, 0} -"Omacr", {197, 140, 0} -"omacr", {197, 141, 0} -"Omega", {206, 169, 0} -"omega", {207, 137, 0} -"Omicron", {206, 159, 0} -"omicron", {206, 191, 0} -"omid", {226, 166, 182, 0} -"ominus", {226, 138, 150, 0} -"Oopf", {240, 157, 149, 134} -"oopf", {240, 157, 149, 160} -"opar", {226, 166, 183, 0} -"OpenCurlyDoubleQuote", {226, 128, 156, 0} -"OpenCurlyQuote", {226, 128, 152, 0} -"operp", {226, 166, 185, 0} -"oplus", {226, 138, 149, 0} -"orarr", {226, 134, 187, 0} -"Or", {226, 169, 148, 0} -"or", {226, 136, 168, 0} -"ord", {226, 169, 157, 0} -"order", {226, 132, 180, 0} -"orderof", {226, 132, 180, 0} -"ordf", {194, 170, 0} -"ordm", {194, 186, 0} -"origof", {226, 138, 182, 0} -"oror", {226, 169, 150, 0} -"orslope", {226, 169, 151, 0} -"orv", {226, 169, 155, 0} -"oS", {226, 147, 136, 0} -"Oscr", {240, 157, 146, 170} -"oscr", {226, 132, 180, 0} -"Oslash", {195, 152, 0} -"oslash", {195, 184, 0} -"osol", {226, 138, 152, 0} -"Otilde", {195, 149, 0} -"otilde", {195, 181, 0} -"otimesas", {226, 168, 182, 0} -"Otimes", {226, 168, 183, 0} -"otimes", {226, 138, 151, 0} -"Ouml", {195, 150, 0} -"ouml", {195, 182, 0} -"ovbar", {226, 140, 189, 0} -"OverBar", {226, 128, 190, 0} -"OverBrace", {226, 143, 158, 0} -"OverBracket", {226, 142, 180, 0} -"OverParenthesis", {226, 143, 156, 0} -"para", {194, 182, 0} -"parallel", {226, 136, 165, 0} -"par", {226, 136, 165, 0} -"parsim", {226, 171, 179, 0} -"parsl", {226, 171, 189, 0} -"part", {226, 136, 130, 0} -"PartialD", {226, 136, 130, 0} -"Pcy", {208, 159, 0} -"pcy", {208, 191, 0} -"percnt", {37, 0} -"period", {46, 0} -"permil", {226, 128, 176, 0} -"perp", {226, 138, 165, 0} -"pertenk", {226, 128, 177, 0} -"Pfr", {240, 157, 148, 147} -"pfr", {240, 157, 148, 173} -"Phi", {206, 166, 0} -"phi", {207, 134, 0} -"phiv", {207, 149, 0} -"phmmat", {226, 132, 179, 0} -"phone", {226, 152, 142, 0} -"Pi", {206, 160, 0} -"pi", {207, 128, 0} -"pitchfork", {226, 139, 148, 0} -"piv", {207, 150, 0} -"planck", {226, 132, 143, 0} -"planckh", {226, 132, 142, 0} -"plankv", {226, 132, 143, 0} -"plusacir", {226, 168, 163, 0} -"plusb", {226, 138, 158, 0} -"pluscir", {226, 168, 162, 0} -"plus", {43, 0} -"plusdo", {226, 136, 148, 0} -"plusdu", {226, 168, 165, 0} -"pluse", {226, 169, 178, 0} -"PlusMinus", {194, 177, 0} -"plusmn", {194, 177, 0} -"plussim", {226, 168, 166, 0} -"plustwo", {226, 168, 167, 0} -"pm", {194, 177, 0} -"Poincareplane", {226, 132, 140, 0} -"pointint", {226, 168, 149, 0} -"popf", {240, 157, 149, 161} -"Popf", {226, 132, 153, 0} -"pound", {194, 163, 0} -"prap", {226, 170, 183, 0} -"Pr", {226, 170, 187, 0} -"pr", {226, 137, 186, 0} -"prcue", {226, 137, 188, 0} -"precapprox", {226, 170, 183, 0} -"prec", {226, 137, 186, 0} -"preccurlyeq", {226, 137, 188, 0} -"Precedes", {226, 137, 186, 0} -"PrecedesEqual", {226, 170, 175, 0} -"PrecedesSlantEqual", {226, 137, 188, 0} -"PrecedesTilde", {226, 137, 190, 0} -"preceq", {226, 170, 175, 0} -"precnapprox", {226, 170, 185, 0} -"precneqq", {226, 170, 181, 0} -"precnsim", {226, 139, 168, 0} -"pre", {226, 170, 175, 0} -"prE", {226, 170, 179, 0} -"precsim", {226, 137, 190, 0} -"prime", {226, 128, 178, 0} -"Prime", {226, 128, 179, 0} -"primes", {226, 132, 153, 0} -"prnap", {226, 170, 185, 0} -"prnE", {226, 170, 181, 0} -"prnsim", {226, 139, 168, 0} -"prod", {226, 136, 143, 0} -"Product", {226, 136, 143, 0} -"profalar", {226, 140, 174, 0} -"profline", {226, 140, 146, 0} -"profsurf", {226, 140, 147, 0} -"prop", {226, 136, 157, 0} -"Proportional", {226, 136, 157, 0} -"Proportion", {226, 136, 183, 0} -"propto", {226, 136, 157, 0} -"prsim", {226, 137, 190, 0} -"prurel", {226, 138, 176, 0} -"Pscr", {240, 157, 146, 171} -"pscr", {240, 157, 147, 133} -"Psi", {206, 168, 0} -"psi", {207, 136, 0} -"puncsp", {226, 128, 136, 0} -"Qfr", {240, 157, 148, 148} -"qfr", {240, 157, 148, 174} -"qint", {226, 168, 140, 0} -"qopf", {240, 157, 149, 162} -"Qopf", {226, 132, 154, 0} -"qprime", {226, 129, 151, 0} -"Qscr", {240, 157, 146, 172} -"qscr", {240, 157, 147, 134} -"quaternions", {226, 132, 141, 0} -"quatint", {226, 168, 150, 0} -"quest", {63, 0} -"questeq", {226, 137, 159, 0} -"quot", {34, 0} -"QUOT", {34, 0} -"rAarr", {226, 135, 155, 0} -"race", {226, 136, 189, 0} -"Racute", {197, 148, 0} -"racute", {197, 149, 0} -"radic", {226, 136, 154, 0} -"raemptyv", {226, 166, 179, 0} -"rang", {226, 159, 169, 0} -"Rang", {226, 159, 171, 0} -"rangd", {226, 166, 146, 0} -"range", {226, 166, 165, 0} -"rangle", {226, 159, 169, 0} -"raquo", {194, 187, 0} -"rarrap", {226, 165, 181, 0} -"rarrb", {226, 135, 165, 0} -"rarrbfs", {226, 164, 160, 0} -"rarrc", {226, 164, 179, 0} -"rarr", {226, 134, 146, 0} -"Rarr", {226, 134, 160, 0} -"rArr", {226, 135, 146, 0} -"rarrfs", {226, 164, 158, 0} -"rarrhk", {226, 134, 170, 0} -"rarrlp", {226, 134, 172, 0} -"rarrpl", {226, 165, 133, 0} -"rarrsim", {226, 165, 180, 0} -"Rarrtl", {226, 164, 150, 0} -"rarrtl", {226, 134, 163, 0} -"rarrw", {226, 134, 157, 0} -"ratail", {226, 164, 154, 0} -"rAtail", {226, 164, 156, 0} -"ratio", {226, 136, 182, 0} -"rationals", {226, 132, 154, 0} -"rbarr", {226, 164, 141, 0} -"rBarr", {226, 164, 143, 0} -"RBarr", {226, 164, 144, 0} -"rbbrk", {226, 157, 179, 0} -"rbrace", {125, 0} -"rbrack", {93, 0} -"rbrke", {226, 166, 140, 0} -"rbrksld", {226, 166, 142, 0} -"rbrkslu", {226, 166, 144, 0} -"Rcaron", {197, 152, 0} -"rcaron", {197, 153, 0} -"Rcedil", {197, 150, 0} -"rcedil", {197, 151, 0} -"rceil", {226, 140, 137, 0} -"rcub", {125, 0} -"Rcy", {208, 160, 0} -"rcy", {209, 128, 0} -"rdca", {226, 164, 183, 0} -"rdldhar", {226, 165, 169, 0} -"rdquo", {226, 128, 157, 0} -"rdquor", {226, 128, 157, 0} -"rdsh", {226, 134, 179, 0} -"real", {226, 132, 156, 0} -"realine", {226, 132, 155, 0} -"realpart", {226, 132, 156, 0} -"reals", {226, 132, 157, 0} -"Re", {226, 132, 156, 0} -"rect", {226, 150, 173, 0} -"reg", {194, 174, 0} -"REG", {194, 174, 0} -"ReverseElement", {226, 136, 139, 0} -"ReverseEquilibrium", {226, 135, 139, 0} -"ReverseUpEquilibrium", {226, 165, 175, 0} -"rfisht", {226, 165, 189, 0} -"rfloor", {226, 140, 139, 0} -"rfr", {240, 157, 148, 175} -"Rfr", {226, 132, 156, 0} -"rHar", {226, 165, 164, 0} -"rhard", {226, 135, 129, 0} -"rharu", {226, 135, 128, 0} -"rharul", {226, 165, 172, 0} -"Rho", {206, 161, 0} -"rho", {207, 129, 0} -"rhov", {207, 177, 0} -"RightAngleBracket", {226, 159, 169, 0} -"RightArrowBar", {226, 135, 165, 0} -"rightarrow", {226, 134, 146, 0} -"RightArrow", {226, 134, 146, 0} -"Rightarrow", {226, 135, 146, 0} -"RightArrowLeftArrow", {226, 135, 132, 0} -"rightarrowtail", {226, 134, 163, 0} -"RightCeiling", {226, 140, 137, 0} -"RightDoubleBracket", {226, 159, 167, 0} -"RightDownTeeVector", {226, 165, 157, 0} -"RightDownVectorBar", {226, 165, 149, 0} -"RightDownVector", {226, 135, 130, 0} -"RightFloor", {226, 140, 139, 0} -"rightharpoondown", {226, 135, 129, 0} -"rightharpoonup", {226, 135, 128, 0} -"rightleftarrows", {226, 135, 132, 0} -"rightleftharpoons", {226, 135, 140, 0} -"rightrightarrows", {226, 135, 137, 0} -"rightsquigarrow", {226, 134, 157, 0} -"RightTeeArrow", {226, 134, 166, 0} -"RightTee", {226, 138, 162, 0} -"RightTeeVector", {226, 165, 155, 0} -"rightthreetimes", {226, 139, 140, 0} -"RightTriangleBar", {226, 167, 144, 0} -"RightTriangle", {226, 138, 179, 0} -"RightTriangleEqual", {226, 138, 181, 0} -"RightUpDownVector", {226, 165, 143, 0} -"RightUpTeeVector", {226, 165, 156, 0} -"RightUpVectorBar", {226, 165, 148, 0} -"RightUpVector", {226, 134, 190, 0} -"RightVectorBar", {226, 165, 147, 0} -"RightVector", {226, 135, 128, 0} -"ring", {203, 154, 0} -"risingdotseq", {226, 137, 147, 0} -"rlarr", {226, 135, 132, 0} -"rlhar", {226, 135, 140, 0} -"rlm", {226, 128, 143, 0} -"rmoustache", {226, 142, 177, 0} -"rmoust", {226, 142, 177, 0} -"rnmid", {226, 171, 174, 0} -"roang", {226, 159, 173, 0} -"roarr", {226, 135, 190, 0} -"robrk", {226, 159, 167, 0} -"ropar", {226, 166, 134, 0} -"ropf", {240, 157, 149, 163} -"Ropf", {226, 132, 157, 0} -"roplus", {226, 168, 174, 0} -"rotimes", {226, 168, 181, 0} -"RoundImplies", {226, 165, 176, 0} -"rpar", {41, 0} -"rpargt", {226, 166, 148, 0} -"rppolint", {226, 168, 146, 0} -"rrarr", {226, 135, 137, 0} -"Rrightarrow", {226, 135, 155, 0} -"rsaquo", {226, 128, 186, 0} -"rscr", {240, 157, 147, 135} -"Rscr", {226, 132, 155, 0} -"rsh", {226, 134, 177, 0} -"Rsh", {226, 134, 177, 0} -"rsqb", {93, 0} -"rsquo", {226, 128, 153, 0} -"rsquor", {226, 128, 153, 0} -"rthree", {226, 139, 140, 0} -"rtimes", {226, 139, 138, 0} -"rtri", {226, 150, 185, 0} -"rtrie", {226, 138, 181, 0} -"rtrif", {226, 150, 184, 0} -"rtriltri", {226, 167, 142, 0} -"RuleDelayed", {226, 167, 180, 0} -"ruluhar", {226, 165, 168, 0} -"rx", {226, 132, 158, 0} -"Sacute", {197, 154, 0} -"sacute", {197, 155, 0} -"sbquo", {226, 128, 154, 0} -"scap", {226, 170, 184, 0} -"Scaron", {197, 160, 0} -"scaron", {197, 161, 0} -"Sc", {226, 170, 188, 0} -"sc", {226, 137, 187, 0} -"sccue", {226, 137, 189, 0} -"sce", {226, 170, 176, 0} -"scE", {226, 170, 180, 0} -"Scedil", {197, 158, 0} -"scedil", {197, 159, 0} -"Scirc", {197, 156, 0} -"scirc", {197, 157, 0} -"scnap", {226, 170, 186, 0} -"scnE", {226, 170, 182, 0} -"scnsim", {226, 139, 169, 0} -"scpolint", {226, 168, 147, 0} -"scsim", {226, 137, 191, 0} -"Scy", {208, 161, 0} -"scy", {209, 129, 0} -"sdotb", {226, 138, 161, 0} -"sdot", {226, 139, 133, 0} -"sdote", {226, 169, 166, 0} -"searhk", {226, 164, 165, 0} -"searr", {226, 134, 152, 0} -"seArr", {226, 135, 152, 0} -"searrow", {226, 134, 152, 0} -"sect", {194, 167, 0} -"semi", {59, 0} -"seswar", {226, 164, 169, 0} -"setminus", {226, 136, 150, 0} -"setmn", {226, 136, 150, 0} -"sext", {226, 156, 182, 0} -"Sfr", {240, 157, 148, 150} -"sfr", {240, 157, 148, 176} -"sfrown", {226, 140, 162, 0} -"sharp", {226, 153, 175, 0} -"SHCHcy", {208, 169, 0} -"shchcy", {209, 137, 0} -"SHcy", {208, 168, 0} -"shcy", {209, 136, 0} -"ShortDownArrow", {226, 134, 147, 0} -"ShortLeftArrow", {226, 134, 144, 0} -"shortmid", {226, 136, 163, 0} -"shortparallel", {226, 136, 165, 0} -"ShortRightArrow", {226, 134, 146, 0} -"ShortUpArrow", {226, 134, 145, 0} -"shy", {194, 173, 0} -"Sigma", {206, 163, 0} -"sigma", {207, 131, 0} -"sigmaf", {207, 130, 0} -"sigmav", {207, 130, 0} -"sim", {226, 136, 188, 0} -"simdot", {226, 169, 170, 0} -"sime", {226, 137, 131, 0} -"simeq", {226, 137, 131, 0} -"simg", {226, 170, 158, 0} -"simgE", {226, 170, 160, 0} -"siml", {226, 170, 157, 0} -"simlE", {226, 170, 159, 0} -"simne", {226, 137, 134, 0} -"simplus", {226, 168, 164, 0} -"simrarr", {226, 165, 178, 0} -"slarr", {226, 134, 144, 0} -"SmallCircle", {226, 136, 152, 0} -"smallsetminus", {226, 136, 150, 0} -"smashp", {226, 168, 179, 0} -"smeparsl", {226, 167, 164, 0} -"smid", {226, 136, 163, 0} -"smile", {226, 140, 163, 0} -"smt", {226, 170, 170, 0} -"smte", {226, 170, 172, 0} -"smtes", {226, 170, 172, 0} -"SOFTcy", {208, 172, 0} -"softcy", {209, 140, 0} -"solbar", {226, 140, 191, 0} -"solb", {226, 167, 132, 0} -"sol", {47, 0} -"Sopf", {240, 157, 149, 138} -"sopf", {240, 157, 149, 164} -"spades", {226, 153, 160, 0} -"spadesuit", {226, 153, 160, 0} -"spar", {226, 136, 165, 0} -"sqcap", {226, 138, 147, 0} -"sqcaps", {226, 138, 147, 0} -"sqcup", {226, 138, 148, 0} -"sqcups", {226, 138, 148, 0} -"Sqrt", {226, 136, 154, 0} -"sqsub", {226, 138, 143, 0} -"sqsube", {226, 138, 145, 0} -"sqsubset", {226, 138, 143, 0} -"sqsubseteq", {226, 138, 145, 0} -"sqsup", {226, 138, 144, 0} -"sqsupe", {226, 138, 146, 0} -"sqsupset", {226, 138, 144, 0} -"sqsupseteq", {226, 138, 146, 0} -"square", {226, 150, 161, 0} -"Square", {226, 150, 161, 0} -"SquareIntersection", {226, 138, 147, 0} -"SquareSubset", {226, 138, 143, 0} -"SquareSubsetEqual", {226, 138, 145, 0} -"SquareSuperset", {226, 138, 144, 0} -"SquareSupersetEqual", {226, 138, 146, 0} -"SquareUnion", {226, 138, 148, 0} -"squarf", {226, 150, 170, 0} -"squ", {226, 150, 161, 0} -"squf", {226, 150, 170, 0} -"srarr", {226, 134, 146, 0} -"Sscr", {240, 157, 146, 174} -"sscr", {240, 157, 147, 136} -"ssetmn", {226, 136, 150, 0} -"ssmile", {226, 140, 163, 0} -"sstarf", {226, 139, 134, 0} -"Star", {226, 139, 134, 0} -"star", {226, 152, 134, 0} -"starf", {226, 152, 133, 0} -"straightepsilon", {207, 181, 0} -"straightphi", {207, 149, 0} -"strns", {194, 175, 0} -"sub", {226, 138, 130, 0} -"Sub", {226, 139, 144, 0} -"subdot", {226, 170, 189, 0} -"subE", {226, 171, 133, 0} -"sube", {226, 138, 134, 0} -"subedot", {226, 171, 131, 0} -"submult", {226, 171, 129, 0} -"subnE", {226, 171, 139, 0} -"subne", {226, 138, 138, 0} -"subplus", {226, 170, 191, 0} -"subrarr", {226, 165, 185, 0} -"subset", {226, 138, 130, 0} -"Subset", {226, 139, 144, 0} -"subseteq", {226, 138, 134, 0} -"subseteqq", {226, 171, 133, 0} -"SubsetEqual", {226, 138, 134, 0} -"subsetneq", {226, 138, 138, 0} -"subsetneqq", {226, 171, 139, 0} -"subsim", {226, 171, 135, 0} -"subsub", {226, 171, 149, 0} -"subsup", {226, 171, 147, 0} -"succapprox", {226, 170, 184, 0} -"succ", {226, 137, 187, 0} -"succcurlyeq", {226, 137, 189, 0} -"Succeeds", {226, 137, 187, 0} -"SucceedsEqual", {226, 170, 176, 0} -"SucceedsSlantEqual", {226, 137, 189, 0} -"SucceedsTilde", {226, 137, 191, 0} -"succeq", {226, 170, 176, 0} -"succnapprox", {226, 170, 186, 0} -"succneqq", {226, 170, 182, 0} -"succnsim", {226, 139, 169, 0} -"succsim", {226, 137, 191, 0} -"SuchThat", {226, 136, 139, 0} -"sum", {226, 136, 145, 0} -"Sum", {226, 136, 145, 0} -"sung", {226, 153, 170, 0} -"sup1", {194, 185, 0} -"sup2", {194, 178, 0} -"sup3", {194, 179, 0} -"sup", {226, 138, 131, 0} -"Sup", {226, 139, 145, 0} -"supdot", {226, 170, 190, 0} -"supdsub", {226, 171, 152, 0} -"supE", {226, 171, 134, 0} -"supe", {226, 138, 135, 0} -"supedot", {226, 171, 132, 0} -"Superset", {226, 138, 131, 0} -"SupersetEqual", {226, 138, 135, 0} -"suphsol", {226, 159, 137, 0} -"suphsub", {226, 171, 151, 0} -"suplarr", {226, 165, 187, 0} -"supmult", {226, 171, 130, 0} -"supnE", {226, 171, 140, 0} -"supne", {226, 138, 139, 0} -"supplus", {226, 171, 128, 0} -"supset", {226, 138, 131, 0} -"Supset", {226, 139, 145, 0} -"supseteq", {226, 138, 135, 0} -"supseteqq", {226, 171, 134, 0} -"supsetneq", {226, 138, 139, 0} -"supsetneqq", {226, 171, 140, 0} -"supsim", {226, 171, 136, 0} -"supsub", {226, 171, 148, 0} -"supsup", {226, 171, 150, 0} -"swarhk", {226, 164, 166, 0} -"swarr", {226, 134, 153, 0} -"swArr", {226, 135, 153, 0} -"swarrow", {226, 134, 153, 0} -"swnwar", {226, 164, 170, 0} -"szlig", {195, 159, 0} -"Tab", {9, 0} -"target", {226, 140, 150, 0} -"Tau", {206, 164, 0} -"tau", {207, 132, 0} -"tbrk", {226, 142, 180, 0} -"Tcaron", {197, 164, 0} -"tcaron", {197, 165, 0} -"Tcedil", {197, 162, 0} -"tcedil", {197, 163, 0} -"Tcy", {208, 162, 0} -"tcy", {209, 130, 0} -"tdot", {226, 131, 155, 0} -"telrec", {226, 140, 149, 0} -"Tfr", {240, 157, 148, 151} -"tfr", {240, 157, 148, 177} -"there4", {226, 136, 180, 0} -"therefore", {226, 136, 180, 0} -"Therefore", {226, 136, 180, 0} -"Theta", {206, 152, 0} -"theta", {206, 184, 0} -"thetasym", {207, 145, 0} -"thetav", {207, 145, 0} -"thickapprox", {226, 137, 136, 0} -"thicksim", {226, 136, 188, 0} -"ThickSpace", {226, 129, 159, 0} -"ThinSpace", {226, 128, 137, 0} -"thinsp", {226, 128, 137, 0} -"thkap", {226, 137, 136, 0} -"thksim", {226, 136, 188, 0} -"THORN", {195, 158, 0} -"thorn", {195, 190, 0} -"tilde", {203, 156, 0} -"Tilde", {226, 136, 188, 0} -"TildeEqual", {226, 137, 131, 0} -"TildeFullEqual", {226, 137, 133, 0} -"TildeTilde", {226, 137, 136, 0} -"timesbar", {226, 168, 177, 0} -"timesb", {226, 138, 160, 0} -"times", {195, 151, 0} -"timesd", {226, 168, 176, 0} -"tint", {226, 136, 173, 0} -"toea", {226, 164, 168, 0} -"topbot", {226, 140, 182, 0} -"topcir", {226, 171, 177, 0} -"top", {226, 138, 164, 0} -"Topf", {240, 157, 149, 139} -"topf", {240, 157, 149, 165} -"topfork", {226, 171, 154, 0} -"tosa", {226, 164, 169, 0} -"tprime", {226, 128, 180, 0} -"trade", {226, 132, 162, 0} -"TRADE", {226, 132, 162, 0} -"triangle", {226, 150, 181, 0} -"triangledown", {226, 150, 191, 0} -"triangleleft", {226, 151, 131, 0} -"trianglelefteq", {226, 138, 180, 0} -"triangleq", {226, 137, 156, 0} -"triangleright", {226, 150, 185, 0} -"trianglerighteq", {226, 138, 181, 0} -"tridot", {226, 151, 172, 0} -"trie", {226, 137, 156, 0} -"triminus", {226, 168, 186, 0} -"TripleDot", {226, 131, 155, 0} -"triplus", {226, 168, 185, 0} -"trisb", {226, 167, 141, 0} -"tritime", {226, 168, 187, 0} -"trpezium", {226, 143, 162, 0} -"Tscr", {240, 157, 146, 175} -"tscr", {240, 157, 147, 137} -"TScy", {208, 166, 0} -"tscy", {209, 134, 0} -"TSHcy", {208, 139, 0} -"tshcy", {209, 155, 0} -"Tstrok", {197, 166, 0} -"tstrok", {197, 167, 0} -"twixt", {226, 137, 172, 0} -"twoheadleftarrow", {226, 134, 158, 0} -"twoheadrightarrow", {226, 134, 160, 0} -"Uacute", {195, 154, 0} -"uacute", {195, 186, 0} -"uarr", {226, 134, 145, 0} -"Uarr", {226, 134, 159, 0} -"uArr", {226, 135, 145, 0} -"Uarrocir", {226, 165, 137, 0} -"Ubrcy", {208, 142, 0} -"ubrcy", {209, 158, 0} -"Ubreve", {197, 172, 0} -"ubreve", {197, 173, 0} -"Ucirc", {195, 155, 0} -"ucirc", {195, 187, 0} -"Ucy", {208, 163, 0} -"ucy", {209, 131, 0} -"udarr", {226, 135, 133, 0} -"Udblac", {197, 176, 0} -"udblac", {197, 177, 0} -"udhar", {226, 165, 174, 0} -"ufisht", {226, 165, 190, 0} -"Ufr", {240, 157, 148, 152} -"ufr", {240, 157, 148, 178} -"Ugrave", {195, 153, 0} -"ugrave", {195, 185, 0} -"uHar", {226, 165, 163, 0} -"uharl", {226, 134, 191, 0} -"uharr", {226, 134, 190, 0} -"uhblk", {226, 150, 128, 0} -"ulcorn", {226, 140, 156, 0} -"ulcorner", {226, 140, 156, 0} -"ulcrop", {226, 140, 143, 0} -"ultri", {226, 151, 184, 0} -"Umacr", {197, 170, 0} -"umacr", {197, 171, 0} -"uml", {194, 168, 0} -"UnderBar", {95, 0} -"UnderBrace", {226, 143, 159, 0} -"UnderBracket", {226, 142, 181, 0} -"UnderParenthesis", {226, 143, 157, 0} -"Union", {226, 139, 131, 0} -"UnionPlus", {226, 138, 142, 0} -"Uogon", {197, 178, 0} -"uogon", {197, 179, 0} -"Uopf", {240, 157, 149, 140} -"uopf", {240, 157, 149, 166} -"UpArrowBar", {226, 164, 146, 0} -"uparrow", {226, 134, 145, 0} -"UpArrow", {226, 134, 145, 0} -"Uparrow", {226, 135, 145, 0} -"UpArrowDownArrow", {226, 135, 133, 0} -"updownarrow", {226, 134, 149, 0} -"UpDownArrow", {226, 134, 149, 0} -"Updownarrow", {226, 135, 149, 0} -"UpEquilibrium", {226, 165, 174, 0} -"upharpoonleft", {226, 134, 191, 0} -"upharpoonright", {226, 134, 190, 0} -"uplus", {226, 138, 142, 0} -"UpperLeftArrow", {226, 134, 150, 0} -"UpperRightArrow", {226, 134, 151, 0} -"upsi", {207, 133, 0} -"Upsi", {207, 146, 0} -"upsih", {207, 146, 0} -"Upsilon", {206, 165, 0} -"upsilon", {207, 133, 0} -"UpTeeArrow", {226, 134, 165, 0} -"UpTee", {226, 138, 165, 0} -"upuparrows", {226, 135, 136, 0} -"urcorn", {226, 140, 157, 0} -"urcorner", {226, 140, 157, 0} -"urcrop", {226, 140, 142, 0} -"Uring", {197, 174, 0} -"uring", {197, 175, 0} -"urtri", {226, 151, 185, 0} -"Uscr", {240, 157, 146, 176} -"uscr", {240, 157, 147, 138} -"utdot", {226, 139, 176, 0} -"Utilde", {197, 168, 0} -"utilde", {197, 169, 0} -"utri", {226, 150, 181, 0} -"utrif", {226, 150, 180, 0} -"uuarr", {226, 135, 136, 0} -"Uuml", {195, 156, 0} -"uuml", {195, 188, 0} -"uwangle", {226, 166, 167, 0} -"vangrt", {226, 166, 156, 0} -"varepsilon", {207, 181, 0} -"varkappa", {207, 176, 0} -"varnothing", {226, 136, 133, 0} -"varphi", {207, 149, 0} -"varpi", {207, 150, 0} -"varpropto", {226, 136, 157, 0} -"varr", {226, 134, 149, 0} -"vArr", {226, 135, 149, 0} -"varrho", {207, 177, 0} -"varsigma", {207, 130, 0} -"varsubsetneq", {226, 138, 138, 0} -"varsubsetneqq", {226, 171, 139, 0} -"varsupsetneq", {226, 138, 139, 0} -"varsupsetneqq", {226, 171, 140, 0} -"vartheta", {207, 145, 0} -"vartriangleleft", {226, 138, 178, 0} -"vartriangleright", {226, 138, 179, 0} -"vBar", {226, 171, 168, 0} -"Vbar", {226, 171, 171, 0} -"vBarv", {226, 171, 169, 0} -"Vcy", {208, 146, 0} -"vcy", {208, 178, 0} -"vdash", {226, 138, 162, 0} -"vDash", {226, 138, 168, 0} -"Vdash", {226, 138, 169, 0} -"VDash", {226, 138, 171, 0} -"Vdashl", {226, 171, 166, 0} -"veebar", {226, 138, 187, 0} -"vee", {226, 136, 168, 0} -"Vee", {226, 139, 129, 0} -"veeeq", {226, 137, 154, 0} -"vellip", {226, 139, 174, 0} -"verbar", {124, 0} -"Verbar", {226, 128, 150, 0} -"vert", {124, 0} -"Vert", {226, 128, 150, 0} -"VerticalBar", {226, 136, 163, 0} -"VerticalLine", {124, 0} -"VerticalSeparator", {226, 157, 152, 0} -"VerticalTilde", {226, 137, 128, 0} -"VeryThinSpace", {226, 128, 138, 0} -"Vfr", {240, 157, 148, 153} -"vfr", {240, 157, 148, 179} -"vltri", {226, 138, 178, 0} -"vnsub", {226, 138, 130, 0} -"vnsup", {226, 138, 131, 0} -"Vopf", {240, 157, 149, 141} -"vopf", {240, 157, 149, 167} -"vprop", {226, 136, 157, 0} -"vrtri", {226, 138, 179, 0} -"Vscr", {240, 157, 146, 177} -"vscr", {240, 157, 147, 139} -"vsubnE", {226, 171, 139, 0} -"vsubne", {226, 138, 138, 0} -"vsupnE", {226, 171, 140, 0} -"vsupne", {226, 138, 139, 0} -"Vvdash", {226, 138, 170, 0} -"vzigzag", {226, 166, 154, 0} -"Wcirc", {197, 180, 0} -"wcirc", {197, 181, 0} -"wedbar", {226, 169, 159, 0} -"wedge", {226, 136, 167, 0} -"Wedge", {226, 139, 128, 0} -"wedgeq", {226, 137, 153, 0} -"weierp", {226, 132, 152, 0} -"Wfr", {240, 157, 148, 154} -"wfr", {240, 157, 148, 180} -"Wopf", {240, 157, 149, 142} -"wopf", {240, 157, 149, 168} -"wp", {226, 132, 152, 0} -"wr", {226, 137, 128, 0} -"wreath", {226, 137, 128, 0} -"Wscr", {240, 157, 146, 178} -"wscr", {240, 157, 147, 140} -"xcap", {226, 139, 130, 0} -"xcirc", {226, 151, 175, 0} -"xcup", {226, 139, 131, 0} -"xdtri", {226, 150, 189, 0} -"Xfr", {240, 157, 148, 155} -"xfr", {240, 157, 148, 181} -"xharr", {226, 159, 183, 0} -"xhArr", {226, 159, 186, 0} -"Xi", {206, 158, 0} -"xi", {206, 190, 0} -"xlarr", {226, 159, 181, 0} -"xlArr", {226, 159, 184, 0} -"xmap", {226, 159, 188, 0} -"xnis", {226, 139, 187, 0} -"xodot", {226, 168, 128, 0} -"Xopf", {240, 157, 149, 143} -"xopf", {240, 157, 149, 169} -"xoplus", {226, 168, 129, 0} -"xotime", {226, 168, 130, 0} -"xrarr", {226, 159, 182, 0} -"xrArr", {226, 159, 185, 0} -"Xscr", {240, 157, 146, 179} -"xscr", {240, 157, 147, 141} -"xsqcup", {226, 168, 134, 0} -"xuplus", {226, 168, 132, 0} -"xutri", {226, 150, 179, 0} -"xvee", {226, 139, 129, 0} -"xwedge", {226, 139, 128, 0} -"Yacute", {195, 157, 0} -"yacute", {195, 189, 0} -"YAcy", {208, 175, 0} -"yacy", {209, 143, 0} -"Ycirc", {197, 182, 0} -"ycirc", {197, 183, 0} -"Ycy", {208, 171, 0} -"ycy", {209, 139, 0} -"yen", {194, 165, 0} -"Yfr", {240, 157, 148, 156} -"yfr", {240, 157, 148, 182} -"YIcy", {208, 135, 0} -"yicy", {209, 151, 0} -"Yopf", {240, 157, 149, 144} -"yopf", {240, 157, 149, 170} -"Yscr", {240, 157, 146, 180} -"yscr", {240, 157, 147, 142} -"YUcy", {208, 174, 0} -"yucy", {209, 142, 0} -"yuml", {195, 191, 0} -"Yuml", {197, 184, 0} -"Zacute", {197, 185, 0} -"zacute", {197, 186, 0} -"Zcaron", {197, 189, 0} -"zcaron", {197, 190, 0} -"Zcy", {208, 151, 0} -"zcy", {208, 183, 0} -"Zdot", {197, 187, 0} -"zdot", {197, 188, 0} -"zeetrf", {226, 132, 168, 0} -"ZeroWidthSpace", {226, 128, 139, 0} -"Zeta", {206, 150, 0} -"zeta", {206, 182, 0} -"zfr", {240, 157, 148, 183} -"Zfr", {226, 132, 168, 0} -"ZHcy", {208, 150, 0} -"zhcy", {208, 182, 0} -"zigrarr", {226, 135, 157, 0} -"zopf", {240, 157, 149, 171} -"Zopf", {226, 132, 164, 0} -"Zscr", {240, 157, 146, 181} -"zscr", {240, 157, 147, 143} -"zwj", {226, 128, 141, 0} -"zwnj", {226, 128, 140, 0} diff --git a/html_unescape.h b/html_unescape.h deleted file mode 100644 index 1eb318b..0000000 --- a/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/inlines.c b/inlines.c deleted file mode 100644 index 2c12408..0000000 --- a/inlines.c +++ /dev/null @@ -1,1031 +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" - - -// 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; - unsigned char delim_char; - int position; - 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); - -static void subject_from_buf(subject *e, cmark_strbuf *buffer, - cmark_reference_map *refmap); -static int subject_find_special_char(subject *subj); - -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; - } - } - - 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 { - *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; -} - -// Parse strong/emph or a fallback. -// Assumes the subject has '_' or '*' at the current position. -static cmark_node* handle_strong_emph(subject* subj, unsigned char c) -{ - int numdelims; - cmark_node * inl_text; - bool can_open, can_close; - - numdelims = scan_delims(subj, c, &can_open, &can_close); - - inl_text = make_str(cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims)); - - if (can_open || can_close) { - push_delimiter(subj, c, can_open, can_close, inl_text); - } - - return inl_text; -} - -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 == '_')) { - // 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 (opener != NULL && opener != start_delim) { - closer = S_insert_emph(subj, opener, closer); - } else { - 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) -{ - // "\n\\`&_*[]pos + 1; - - while (n < subj->input.len) { - if (SPECIAL_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) -{ - 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 '_': - new_inl = handle_strong_emph(subj, c); - 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); - 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) -{ - subject subj; - subject_from_buf(&subj, &parent->string_content, refmap); - - while (!is_eof(&subj) && parse_inline(&subj, parent)) ; - - 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/inlines.h b/inlines.h deleted file mode 100644 index d2ccfb4..0000000 --- a/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 cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/iterator.c b/iterator.c deleted file mode 100644 index eb7b49c..0000000 --- a/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_get_node(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/iterator.h b/iterator.h deleted file mode 100644 index 027b10b..0000000 --- a/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/libcmark.pc.in b/libcmark.pc.in deleted file mode 100644 index 9c3a9a9..0000000 --- a/libcmark.pc.in +++ /dev/null @@ -1,10 +0,0 @@ -prefix=@CMAKE_INSTALL_PREFIX@ -exec_prefix=@CMAKE_INSTALL_PREFIX@ -libdir=@CMAKE_INSTALL_PREFIX@/lib -includedir=@CMAKE_INSTALL_PREFIX@/include - -Name: libcmark -Description: CommonMark parsing, rendering, and manipulation -Version: @PROJECT_VERSION@ -Libs: -L${libdir} -lcmark -Cflags: -I${includedir} diff --git a/man.c b/man.c deleted file mode 100644 index f57eb75..0000000 --- a/man.c +++ /dev/null @@ -1,250 +0,0 @@ -#include -#include -#include -#include - -#include "config.h" -#include "cmark.h" -#include "node.h" -#include "buffer.h" - -// Functions to convert cmark_nodes to groff man strings. - -static void escape_man(cmark_strbuf *dest, const unsigned char *source, int length) -{ - int i; - unsigned char c; - bool beginLine = true; - - for (i = 0; i < length; i++) { - c = source[i]; - if (c == '.' && beginLine) { - cmark_strbuf_puts(dest, "\\&."); - } else if (c == '\'' && beginLine) { - cmark_strbuf_puts(dest, "\\&'"); - } else if (c == '-') { - cmark_strbuf_puts(dest, "\\-"); - } else if (c == '\\') { - cmark_strbuf_puts(dest, "\\e"); - } else { - cmark_strbuf_putc(dest, source[i]); - } - beginLine = (c == '\n'); - } -} - -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, long 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/node.c b/node.c deleted file mode 100644 index fe3dac3..0000000 --- a/node.c +++ /dev/null @@ -1,871 +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/node.h b/node.h deleted file mode 100644 index 74eddd4..0000000 --- a/node.h +++ /dev/null @@ -1,79 +0,0 @@ -#ifndef CMARK_NODE_H -#define CMARK_NODE_H - -#ifdef __cplusplus -extern "C" { -#endif - -#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 { - bool fenced; - int fence_length; - int fence_offset; - unsigned char fence_char; - cmark_chunk info; - cmark_chunk literal; -} cmark_code; - -typedef struct { - int level; - bool setext; -} cmark_header; - -typedef struct { - unsigned char *url; - unsigned char *title; -} cmark_link; - -struct cmark_node { - cmark_node_type type; - - 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; - 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/parser.h b/parser.h deleted file mode 100644 index 3c8def9..0000000 --- a/parser.h +++ /dev/null @@ -1,28 +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; -}; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/references.c b/references.c deleted file mode 100644 index 37bf4cb..0000000 --- a/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/references.h b/references.h deleted file mode 100644 index 69325bb..0000000 --- a/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/scanners.c b/scanners.c deleted file mode 100644 index 440cf83..0000000 --- a/scanners.c +++ /dev/null @@ -1,12391 +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, 230, 230, 230, 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 <= '\n') 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 >= '\v') 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 <= '\n') 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 >= '\v') 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 <= '\n') 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 <= '\n') { - 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 <= '\n') 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 <= '\n') 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 <= '\n') 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 <= '\n') { - 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 <= '\n') 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 <= '\n') 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 <= '\n') 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 <= '\n') { - 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 >= '\v') 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 <= '\n') { - 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 <= '\n') { - 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 <= '\n') 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 <= '\n') 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 <= '\n') 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, 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') { - if (yych <= 0x08) goto yy1174; - if (yych <= '\t') goto yy1171; - goto yy1172; - } else { - 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/scanners.h b/scanners.h deleted file mode 100644 index f360505..0000000 --- a/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/scanners.re b/scanners.re deleted file mode 100644 index 28a6991..0000000 --- a/scanners.re +++ /dev/null @@ -1,236 +0,0 @@ -#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; -} - -/*!re2c - re2c:define:YYCTYPE = "unsigned char"; - re2c:define:YYCURSOR = p; - re2c:define:YYMARKER = marker; - re2c:define:YYCTXMARKER = marker; - re2c:yyfill:enable = 0; - - wordchar = [^\x00-\x20]; - - spacechar = [ \t\n]; - - reg_char = [^\\()\x00-\x20]; - - escaped_char = [\\][!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~-]; - - tagname = [A-Za-z][A-Za-z0-9]*; - - blocktagname = 'article'|'header'|'aside'|'hgroup'|'iframe'|'blockquote'|'hr'|'body'|'li'|'map'|'button'|'object'|'canvas'|'ol'|'caption'|'output'|'col'|'p'|'colgroup'|'pre'|'dd'|'progress'|'div'|'section'|'dl'|'table'|'td'|'dt'|'tbody'|'embed'|'textarea'|'fieldset'|'tfoot'|'figcaption'|'th'|'figure'|'thead'|'footer'|'footer'|'tr'|'form'|'ul'|'h1'|'h2'|'h3'|'h4'|'h5'|'h6'|'video'|'script'|'style'; - - attributename = [a-zA-Z_:][a-zA-Z0-9:._-]*; - - unquotedvalue = [^\"'=<>`\x00]+; - singlequotedvalue = ['][^'\x00]*[']; - doublequotedvalue = [\"][^\"\x00]*[\"]; - - attributevalue = unquotedvalue | singlequotedvalue | doublequotedvalue; - - attributevaluespec = spacechar* [=] spacechar* attributevalue; - - attribute = spacechar+ attributename attributevaluespec?; - - opentag = tagname attribute* spacechar* [/]? [>]; - closetag = [/] tagname spacechar* [>]; - - htmlcomment = "!---->" | ("!--" ([-]? [^\x00>-]) ([-]? [^\x00-])* "-->"); - - processinginstruction = "?" ([^?>\x00]+ | [?][^>\x00] | [>])* "?>"; - - declaration = "!" [A-Z]+ spacechar+ [^>\x00]* ">"; - - cdata = "![CDATA[" ([^\]\x00]+ | "]" [^\]\x00] | "]]" [^>\x00])* "]]>"; - - htmltag = opentag | closetag | htmlcomment | processinginstruction | - declaration | cdata; - - in_parens_nosp = [(] (reg_char|escaped_char)* [)]; - - in_double_quotes = ["] (escaped_char|[^"\x00])* ["]; - in_single_quotes = ['] (escaped_char|[^'\x00])* [']; - in_parens = [(] (escaped_char|[^)\x00])* [)]; - - scheme = 'coap'|'doi'|'javascript'|'aaa'|'aaas'|'about'|'acap'|'cap'|'cid'|'crid'|'data'|'dav'|'dict'|'dns'|'file'|'ftp'|'geo'|'go'|'gopher'|'h323'|'http'|'https'|'iax'|'icap'|'im'|'imap'|'info'|'ipp'|'iris'|'iris.beep'|'iris.xpc'|'iris.xpcs'|'iris.lwz'|'ldap'|'mailto'|'mid'|'msrp'|'msrps'|'mtqp'|'mupdate'|'news'|'nfs'|'ni'|'nih'|'nntp'|'opaquelocktoken'|'pop'|'pres'|'rtsp'|'service'|'session'|'shttp'|'sieve'|'sip'|'sips'|'sms'|'snmp'|'soap.beep'|'soap.beeps'|'tag'|'tel'|'telnet'|'tftp'|'thismessage'|'tn3270'|'tip'|'tv'|'urn'|'vemmi'|'ws'|'wss'|'xcon'|'xcon-userid'|'xmlrpc.beep'|'xmlrpc.beeps'|'xmpp'|'z39.50r'|'z39.50s'|'adiumxtra'|'afp'|'afs'|'aim'|'apt'|'attachment'|'aw'|'beshare'|'bitcoin'|'bolo'|'callto'|'chrome'|'chrome-extension'|'com-eventbrite-attendee'|'content'|'cvs'|'dlna-playsingle'|'dlna-playcontainer'|'dtn'|'dvb'|'ed2k'|'facetime'|'feed'|'finger'|'fish'|'gg'|'git'|'gizmoproject'|'gtalk'|'hcp'|'icon'|'ipn'|'irc'|'irc6'|'ircs'|'itms'|'jar'|'jms'|'keyparc'|'lastfm'|'ldaps'|'magnet'|'maps'|'market'|'message'|'mms'|'ms-help'|'msnim'|'mumble'|'mvn'|'notes'|'oid'|'palm'|'paparazzi'|'platform'|'proxy'|'psyc'|'query'|'res'|'resource'|'rmi'|'rsync'|'rtmp'|'secondlife'|'sftp'|'sgn'|'skype'|'smb'|'soldat'|'spotify'|'ssh'|'steam'|'svn'|'teamspeak'|'things'|'udp'|'unreal'|'ut2004'|'ventrilo'|'view-source'|'webcal'|'wtai'|'wyciwyg'|'xfire'|'xri'|'ymsgr'; -*/ - -// 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; -/*!re2c - scheme [:][^\x00-\x20<>]*[>] { return (p - start); } - .? { return 0; } -*/ -} - -// 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; -/*!re2c - [a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+ - [@] - [a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])? - ([.][a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)* - [>] { return (p - start); } - .? { return 0; } -*/ -} - -// 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; -/*!re2c - htmltag { return (p - start); } - .? { return 0; } -*/ -} - -// 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; -/*!re2c - [<] [/] blocktagname (spacechar | [>]) { return (p - start); } - [<] blocktagname (spacechar | [/>]) { return (p - start); } - [<] [!?] { return (p - start); } - .? { return 0; } -*/ -} - -// 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; -/*!re2c - [ \n]* [<] ([^<>\n\\\x00] | escaped_char | [\\])* [>] { return (p - start); } - [ \n]* (reg_char+ | escaped_char | in_parens_nosp)* { return (p - start); } - .? { return 0; } -*/ -} - -// 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; -/*!re2c - ["] (escaped_char|[^"\x00])* ["] { return (p - start); } - ['] (escaped_char|[^'\x00])* ['] { return (p - start); } - [(] (escaped_char|[^)\x00])* [)] { return (p - start); } - .? { return 0; } -*/ -} - -// Match space characters, including newlines. -int _scan_spacechars(const unsigned char *p) -{ - const unsigned char *start = p; \ -/*!re2c - [ \t\n]* { return (p - start); } - . { 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; -/*!re2c - [#]{1,6} ([ ]+|[\n]) { return (p - start); } - .? { return 0; } -*/ -} - -// 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; -/*!re2c - [=]+ [ ]* [\n] { return 1; } - [-]+ [ ]* [\n] { return 2; } - .? { return 0; } -*/ -} - -// 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; -/*!re2c - ([*][ ]*){3,} [ \t]* [\n] { return (p - start); } - ([_][ ]*){3,} [ \t]* [\n] { return (p - start); } - ([-][ ]*){3,} [ \t]* [\n] { return (p - start); } - .? { return 0; } -*/ -} - -// Scan an opening code fence. -int _scan_open_code_fence(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; -/*!re2c - [`]{3,} / [^`\n\x00]*[\n] { return (p - start); } - [~]{3,} / [^~\n\x00]*[\n] { return (p - start); } - .? { return 0; } -*/ -} - -// 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; -/*!re2c - [`]{3,} / [ \t]*[\n] { return (p - start); } - [~]{3,} / [ \t]*[\n] { return (p - start); } - .? { return 0; } -*/ -} - -// 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; -/*!re2c - [&] ([#] ([Xx][A-Fa-f0-9]{1,8}|[0-9]{1,8}) |[A-Za-z][A-Za-z0-9]{1,31} ) [;] - { return (p - start); } - .? { return 0; } -*/ -} diff --git a/utf8.c b/utf8.c deleted file mode 100644 index d77c5d1..0000000 --- a/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/utf8.h b/utf8.h deleted file mode 100644 index 7df1573..0000000 --- a/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/xml.c b/xml.c deleted file mode 100644 index f169241..0000000 --- a/xml.c +++ /dev/null @@ -1,174 +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, long 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, long options) -{ - char *result; - cmark_strbuf xml = GH_BUF_INIT; - cmark_event_type ev_type; - cmark_node *cur; - struct render_state state = { &xml, 0 }; - - if (options & CMARK_OPT_NORMALIZE) { - cmark_consolidate_text_nodes(root); - } - - 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; -} From 1d3b543cd20562acce6419996628385cf5834c10 Mon Sep 17 00:00:00 2001 From: Tim Shannon Date: Fri, 13 Feb 2015 09:33:40 -0600 Subject: [PATCH 03/26] Re-added commits from commit 825524d01662233fc80181e4b745a828e799b1c2 --- CMakeLists.txt | 149 + bench.h | 27 + blocks.c | 878 +++ buffer.c | 381 ++ buffer.h | 113 + case_fold_switch.inc | 2637 ++++++++ chunk.h | 110 + cmark.c | 24 + cmark.h | 556 ++ cmark_ctype.c | 53 + cmark_ctype.h | 24 + cmark_export.h | 35 + cmark_version.h | 7 + cmark_version.h.in | 7 + commonmark.go | 2 +- config.h | 23 + config.h.in | 23 + debug.h | 36 + houdini.h | 52 + houdini_href_e.c | 107 + houdini_html_e.c | 81 + houdini_html_u.c | 116 + html.c | 323 + html_unescape.gperf | 2130 +++++++ html_unescape.h | 13375 +++++++++++++++++++++++++++++++++++++++++ inlines.c | 1031 ++++ inlines.h | 19 + iterator.c | 146 + iterator.h | 25 + libcmark.pc.in | 10 + man.c | 250 + node.c | 871 +++ node.h | 79 + parser.h | 28 + references.c | 154 + references.h | 37 + scanners.c | 12391 ++++++++++++++++++++++++++++++++++++++ scanners.h | 39 + scanners.re | 236 + utf8.c | 453 ++ utf8.h | 22 + xml.c | 174 + 42 files changed, 37233 insertions(+), 1 deletion(-) create mode 100644 CMakeLists.txt create mode 100644 bench.h create mode 100644 blocks.c create mode 100644 buffer.c create mode 100644 buffer.h create mode 100644 case_fold_switch.inc create mode 100644 chunk.h create mode 100644 cmark.c create mode 100644 cmark.h create mode 100644 cmark_ctype.c create mode 100644 cmark_ctype.h create mode 100644 cmark_export.h create mode 100644 cmark_version.h create mode 100644 cmark_version.h.in create mode 100644 config.h create mode 100644 config.h.in create mode 100644 debug.h create mode 100644 houdini.h create mode 100644 houdini_href_e.c create mode 100644 houdini_html_e.c create mode 100644 houdini_html_u.c create mode 100644 html.c create mode 100644 html_unescape.gperf create mode 100644 html_unescape.h create mode 100644 inlines.c create mode 100644 inlines.h create mode 100644 iterator.c create mode 100644 iterator.h create mode 100644 libcmark.pc.in create mode 100644 man.c create mode 100644 node.c create mode 100644 node.h create mode 100644 parser.h create mode 100644 references.c create mode 100644 references.h create mode 100644 scanners.c create mode 100644 scanners.h create mode 100644 scanners.re create mode 100644 utf8.c create mode 100644 utf8.h create mode 100644 xml.c diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..2179c08 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,149 @@ +cmake_minimum_required(VERSION 2.8) +set(LIBRARY "libcmark") +set(HEADERS + cmark.h + parser.h + buffer.h + node.h + iterator.h + chunk.h + references.h + debug.h + bench.h + utf8.h + scanners.h + inlines.h + html_unescape.h + houdini.h + cmark_ctype.h + ) +set(LIBRARY_SOURCES + cmark.c + node.c + iterator.c + blocks.c + inlines.c + scanners.c + scanners.re + utf8.c + buffer.c + references.c + man.c + xml.c + html.c + html_unescape.gperf + houdini_href_e.c + houdini_html_e.c + houdini_html_u.c + cmark_ctype.c + ${HEADERS} + ) + +set(PROGRAM "cmark") +set(PROGRAM_SOURCES + ${LIBRARY_SOURCES} + main.c + ) + +include_directories(. ${CMAKE_CURRENT_BINARY_DIR}) + +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmark_version.h.in + ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h) + +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc @ONLY) +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc + DESTINATION lib/pkgconfig) + +include (GenerateExportHeader) + +add_executable(${PROGRAM} ${PROGRAM_SOURCES}) +add_compiler_export_flags() + +# Disable the PUBLIC declarations when compiling the executable: +set_target_properties(${PROGRAM} PROPERTIES + COMPILE_FLAGS -DCMARK_STATIC_DEFINE) + +# Check integrity of node structure when compiled as debug: +set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -pg -DCMARK_DEBUG_NODES") +set(CMAKE_LINKER_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -pg") + +set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -pg") +set(CMAKE_LINKER_PROFILE "${CMAKE_LINKER_FLAGS_RELEASE} -pg") + +if (${CMAKE_MAJOR_VERSION} GREATER 1 AND ${CMAKE_MINOR_VERSION} GREATER 8) + set(CMAKE_C_VISIBILITY_PRESET hidden) + set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) +elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") +endif () + +add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES}) +# Include minor version in soname as long as major version is 0. +set_target_properties(${LIBRARY} PROPERTIES + OUTPUT_NAME "cmark" + SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR} + VERSION ${PROJECT_VERSION}) + +set_property(TARGET ${LIBRARY} + APPEND PROPERTY MACOSX_RPATH true) + +generate_export_header(${LIBRARY} + BASE_NAME ${PROJECT_NAME}) + +if (MSVC) + set_property(TARGET ${PROGRAM} + APPEND PROPERTY LINK_FLAGS /INCREMENTAL:NO) +endif(MSVC) + +install(TARGETS ${PROGRAM} ${LIBRARY} + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ) + +install(FILES + cmark.h + ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h + ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h + DESTINATION include + ) + +# Feature tests +include(CheckIncludeFile) +include(CheckCSourceCompiles) +include(CheckSymbolExists) +CHECK_INCLUDE_FILE(stdbool.h HAVE_STDBOOL_H) +CHECK_C_SOURCE_COMPILES( + "int main() { __builtin_expect(0,0); return 0; }" + HAVE___BUILTIN_EXPECT) +CHECK_C_SOURCE_COMPILES(" + int f(void) __attribute__ (()); + int main() { return 0; } +" HAVE___ATTRIBUTE__) +CHECK_SYMBOL_EXISTS(va_copy stdarg.h HAVE_VA_COPY) + +CONFIGURE_FILE( + ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in + ${CMAKE_CURRENT_BINARY_DIR}/config.h) + +# Always compile with warnings +if(MSVC) + # Force to always compile with W4 + if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") + else() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4") + endif() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127 /wd4244 /wd4267 /wd4706 /wd4800 /D_CRT_SECURE_NO_WARNINGS") +elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=c99 -pedantic") +endif() + +# Compile as C++ under MSVC +if(MSVC) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /TP") +endif() + +if($ENV{TIMER}) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DTIMER=1") +endif($ENV{TIMER}) diff --git a/bench.h b/bench.h new file mode 100644 index 0000000..bbea2c6 --- /dev/null +++ b/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/blocks.c b/blocks.c new file mode 100644 index 0000000..806f7a6 --- /dev/null +++ b/blocks.c @@ -0,0 +1,878 @@ +#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 cmark_node. +static cmark_node* make_document() +{ + cmark_node *e = make_block(NODE_DOCUMENT, 1, 1); + return e; +} + +cmark_parser *cmark_parser_new() +{ + 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; + + 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 cmark_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 cmark_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 cmark_node that can accept this child, + // then back up til we hit a cmark_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 cmark_node and all children, recursively, parsing +// string content into inline content where appropriate. +static void process_inlines(cmark_node* root, cmark_reference_map *refmap) +{ + 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); + } + } + } + + 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); + + return parser->root; +} + +cmark_node *cmark_parse_file(FILE *f) +{ + unsigned char buffer[4096]; + cmark_parser *parser = cmark_parser_new(); + 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) +{ + cmark_parser *parser = cmark_parser_new(); + 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; + cmark_node* cur = parser->current; + bool blank = false; + int first_nonspace; + int indent; + cmark_chunk input; + + 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 cmark_node, try to parse the associated line start. + // bail out on failure: container will point to the last matching cmark_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 cmark_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); + } + + // unless last matched container is code cmark_node, 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 (cur->type != NODE_PARAGRAPH && !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; + } + } + + // 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 (cur != last_matched_container && + container == last_matched_container && + !blank && + cur->type == NODE_PARAGRAPH && + cmark_strbuf_len(&cur->string_content) > 0) { + + add_line(cur, &input, offset); + + } else { // not a lazy continuation + + // finalize any blocks that were not matched and set cur to container: + while (cur != last_matched_container) { + cur = finalize(parser, cur); + assert(cur != 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); + cmark_strbuf_free(parser->curline); +#if CMARK_DEBUG_NODES + if (cmark_node_check(parser->root, stderr)) { + abort(); + } +#endif + return parser->root; +} diff --git a/buffer.c b/buffer.c new file mode 100644 index 0000000..0df6561 --- /dev/null +++ b/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/buffer.h b/buffer.h new file mode 100644 index 0000000..fb9f910 --- /dev/null +++ b/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/case_fold_switch.inc b/case_fold_switch.inc new file mode 100644 index 0000000..70fdd75 --- /dev/null +++ b/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/chunk.h b/chunk.h new file mode 100644 index 0000000..54c4b16 --- /dev/null +++ b/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/cmark.c b/cmark.c new file mode 100644 index 0000000..2ec9be9 --- /dev/null +++ b/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) +{ + cmark_node *doc; + char *result; + + doc = cmark_parse_document(text, len); + + result = cmark_render_html(doc, CMARK_OPT_DEFAULT); + cmark_node_free(doc); + + return result; +} + diff --git a/cmark.h b/cmark.h new file mode 100644 index 0000000..64d8d47 --- /dev/null +++ b/cmark.h @@ -0,0 +1,556 @@ +#ifndef CMARK_H +#define CMARK_H + +#include +#include "cmark_export.h" +#include "cmark_version.h" + +#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); + +/** ## 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); + * + * Streaming interface: + * + * cmark_parser *parser = cmark_parser_new(); + * 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(); + +/** 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); + +/** Parse a CommonMark document in file 'f', returning a pointer to + * a tree of nodes. + */ +CMARK_EXPORT +cmark_node *cmark_parse_file(FILE *f); + +/** + * ## Rendering + */ + +/** Render a 'node' tree as XML. + */ +CMARK_EXPORT +char *cmark_render_xml(cmark_node *root, long 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, long options); + +/** Render a 'node' tree as a groff man page, without the header. + */ +CMARK_EXPORT +char *cmark_render_man(cmark_node *root, long 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 + +/** + * ## 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 NODE_LINK_LABEL CMARK_NODE_LINK_LABEL +#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_ctype.c b/cmark_ctype.c new file mode 100644 index 0000000..5de8199 --- /dev/null +++ b/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/cmark_ctype.h b/cmark_ctype.h new file mode 100644 index 0000000..f803946 --- /dev/null +++ b/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/cmark_export.h b/cmark_export.h new file mode 100644 index 0000000..1102c36 --- /dev/null +++ b/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/cmark_version.h b/cmark_version.h new file mode 100644 index 0000000..f86b6aa --- /dev/null +++ b/cmark_version.h @@ -0,0 +1,7 @@ +#ifndef CMARK_VERSION_H +#define CMARK_VERSION_H + +#define CMARK_VERSION ((0 << 16) | (17 << 8) | 0) +#define CMARK_VERSION_STRING "0.17.0" + +#endif diff --git a/cmark_version.h.in b/cmark_version.h.in new file mode 100644 index 0000000..41de3ac --- /dev/null +++ b/cmark_version.h.in @@ -0,0 +1,7 @@ +#ifndef CMARK_VERSION_H +#define CMARK_VERSION_H + +#define CMARK_VERSION ((@PROJECT_VERSION_MAJOR@ << 16) | (@PROJECT_VERSION_MINOR@ << 8) | @PROJECT_VERSION_PATCH@) +#define CMARK_VERSION_STRING "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@" + +#endif diff --git a/commonmark.go b/commonmark.go index bebf08b..987b39a 100644 --- a/commonmark.go +++ b/commonmark.go @@ -2,7 +2,7 @@ package commonmark /* -#cgo LDFLAGS: -lcmark +#cgo CFLAGS: -std=gnu99 #include #include #include "cmark.h" diff --git a/config.h b/config.h new file mode 100644 index 0000000..3de8c11 --- /dev/null +++ b/config.h @@ -0,0 +1,23 @@ +#define HAVE_STDBOOL_H + +#ifdef HAVE_STDBOOL_H + #include +#elif !defined(__cplusplus) + typedef char bool; +#endif + +#define 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/config.h.in b/config.h.in new file mode 100644 index 0000000..c1e9597 --- /dev/null +++ b/config.h.in @@ -0,0 +1,23 @@ +#cmakedefine HAVE_STDBOOL_H + +#ifdef HAVE_STDBOOL_H + #include +#elif !defined(__cplusplus) + typedef char bool; +#endif + +#cmakedefine HAVE___BUILTIN_EXPECT + +#cmakedefine HAVE___ATTRIBUTE__ + +#ifdef HAVE___ATTRIBUTE__ + #define CMARK_ATTRIBUTE(list) __attribute__ (list) +#else + #define CMARK_ATTRIBUTE(list) +#endif + +#cmakedefine HAVE_VA_COPY + +#ifndef HAVE_VA_COPY + #define va_copy(dest, src) ((dest) = (src)) +#endif diff --git a/debug.h b/debug.h new file mode 100644 index 0000000..fd2ef62 --- /dev/null +++ b/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/houdini.h b/houdini.h new file mode 100644 index 0000000..9f00f6d --- /dev/null +++ b/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/houdini_href_e.c b/houdini_href_e.c new file mode 100644 index 0000000..7527780 --- /dev/null +++ b/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/houdini_html_e.c b/houdini_html_e.c new file mode 100644 index 0000000..1a4c3e1 --- /dev/null +++ b/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/houdini_html_u.c b/houdini_html_u.c new file mode 100644 index 0000000..2cb14b4 --- /dev/null +++ b/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/html.c b/html.c new file mode 100644 index 0000000..8ccb495 --- /dev/null +++ b/html.c @@ -0,0 +1,323 @@ +#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, long 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, long 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, long 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/html_unescape.gperf b/html_unescape.gperf new file mode 100644 index 0000000..74173a6 --- /dev/null +++ b/html_unescape.gperf @@ -0,0 +1,2130 @@ +struct html_ent { + int entity; + unsigned char utf8[4]; +}; +%% +"Aacute", {195, 129, 0} +"aacute", {195, 161, 0} +"Abreve", {196, 130, 0} +"abreve", {196, 131, 0} +"ac", {226, 136, 190, 0} +"acd", {226, 136, 191, 0} +"acE", {226, 136, 190, 0} +"Acirc", {195, 130, 0} +"acirc", {195, 162, 0} +"acute", {194, 180, 0} +"Acy", {208, 144, 0} +"acy", {208, 176, 0} +"AElig", {195, 134, 0} +"aelig", {195, 166, 0} +"af", {226, 129, 161, 0} +"Afr", {240, 157, 148, 132} +"afr", {240, 157, 148, 158} +"Agrave", {195, 128, 0} +"agrave", {195, 160, 0} +"alefsym", {226, 132, 181, 0} +"aleph", {226, 132, 181, 0} +"Alpha", {206, 145, 0} +"alpha", {206, 177, 0} +"Amacr", {196, 128, 0} +"amacr", {196, 129, 0} +"amalg", {226, 168, 191, 0} +"amp", {38, 0} +"AMP", {38, 0} +"andand", {226, 169, 149, 0} +"And", {226, 169, 147, 0} +"and", {226, 136, 167, 0} +"andd", {226, 169, 156, 0} +"andslope", {226, 169, 152, 0} +"andv", {226, 169, 154, 0} +"ang", {226, 136, 160, 0} +"ange", {226, 166, 164, 0} +"angle", {226, 136, 160, 0} +"angmsdaa", {226, 166, 168, 0} +"angmsdab", {226, 166, 169, 0} +"angmsdac", {226, 166, 170, 0} +"angmsdad", {226, 166, 171, 0} +"angmsdae", {226, 166, 172, 0} +"angmsdaf", {226, 166, 173, 0} +"angmsdag", {226, 166, 174, 0} +"angmsdah", {226, 166, 175, 0} +"angmsd", {226, 136, 161, 0} +"angrt", {226, 136, 159, 0} +"angrtvb", {226, 138, 190, 0} +"angrtvbd", {226, 166, 157, 0} +"angsph", {226, 136, 162, 0} +"angst", {195, 133, 0} +"angzarr", {226, 141, 188, 0} +"Aogon", {196, 132, 0} +"aogon", {196, 133, 0} +"Aopf", {240, 157, 148, 184} +"aopf", {240, 157, 149, 146} +"apacir", {226, 169, 175, 0} +"ap", {226, 137, 136, 0} +"apE", {226, 169, 176, 0} +"ape", {226, 137, 138, 0} +"apid", {226, 137, 139, 0} +"apos", {39, 0} +"ApplyFunction", {226, 129, 161, 0} +"approx", {226, 137, 136, 0} +"approxeq", {226, 137, 138, 0} +"Aring", {195, 133, 0} +"aring", {195, 165, 0} +"Ascr", {240, 157, 146, 156} +"ascr", {240, 157, 146, 182} +"Assign", {226, 137, 148, 0} +"ast", {42, 0} +"asymp", {226, 137, 136, 0} +"asympeq", {226, 137, 141, 0} +"Atilde", {195, 131, 0} +"atilde", {195, 163, 0} +"Auml", {195, 132, 0} +"auml", {195, 164, 0} +"awconint", {226, 136, 179, 0} +"awint", {226, 168, 145, 0} +"backcong", {226, 137, 140, 0} +"backepsilon", {207, 182, 0} +"backprime", {226, 128, 181, 0} +"backsim", {226, 136, 189, 0} +"backsimeq", {226, 139, 141, 0} +"Backslash", {226, 136, 150, 0} +"Barv", {226, 171, 167, 0} +"barvee", {226, 138, 189, 0} +"barwed", {226, 140, 133, 0} +"Barwed", {226, 140, 134, 0} +"barwedge", {226, 140, 133, 0} +"bbrk", {226, 142, 181, 0} +"bbrktbrk", {226, 142, 182, 0} +"bcong", {226, 137, 140, 0} +"Bcy", {208, 145, 0} +"bcy", {208, 177, 0} +"bdquo", {226, 128, 158, 0} +"becaus", {226, 136, 181, 0} +"because", {226, 136, 181, 0} +"Because", {226, 136, 181, 0} +"bemptyv", {226, 166, 176, 0} +"bepsi", {207, 182, 0} +"bernou", {226, 132, 172, 0} +"Bernoullis", {226, 132, 172, 0} +"Beta", {206, 146, 0} +"beta", {206, 178, 0} +"beth", {226, 132, 182, 0} +"between", {226, 137, 172, 0} +"Bfr", {240, 157, 148, 133} +"bfr", {240, 157, 148, 159} +"bigcap", {226, 139, 130, 0} +"bigcirc", {226, 151, 175, 0} +"bigcup", {226, 139, 131, 0} +"bigodot", {226, 168, 128, 0} +"bigoplus", {226, 168, 129, 0} +"bigotimes", {226, 168, 130, 0} +"bigsqcup", {226, 168, 134, 0} +"bigstar", {226, 152, 133, 0} +"bigtriangledown", {226, 150, 189, 0} +"bigtriangleup", {226, 150, 179, 0} +"biguplus", {226, 168, 132, 0} +"bigvee", {226, 139, 129, 0} +"bigwedge", {226, 139, 128, 0} +"bkarow", {226, 164, 141, 0} +"blacklozenge", {226, 167, 171, 0} +"blacksquare", {226, 150, 170, 0} +"blacktriangle", {226, 150, 180, 0} +"blacktriangledown", {226, 150, 190, 0} +"blacktriangleleft", {226, 151, 130, 0} +"blacktriangleright", {226, 150, 184, 0} +"blank", {226, 144, 163, 0} +"blk12", {226, 150, 146, 0} +"blk14", {226, 150, 145, 0} +"blk34", {226, 150, 147, 0} +"block", {226, 150, 136, 0} +"bne", {61, 0} +"bnequiv", {226, 137, 161, 0} +"bNot", {226, 171, 173, 0} +"bnot", {226, 140, 144, 0} +"Bopf", {240, 157, 148, 185} +"bopf", {240, 157, 149, 147} +"bot", {226, 138, 165, 0} +"bottom", {226, 138, 165, 0} +"bowtie", {226, 139, 136, 0} +"boxbox", {226, 167, 137, 0} +"boxdl", {226, 148, 144, 0} +"boxdL", {226, 149, 149, 0} +"boxDl", {226, 149, 150, 0} +"boxDL", {226, 149, 151, 0} +"boxdr", {226, 148, 140, 0} +"boxdR", {226, 149, 146, 0} +"boxDr", {226, 149, 147, 0} +"boxDR", {226, 149, 148, 0} +"boxh", {226, 148, 128, 0} +"boxH", {226, 149, 144, 0} +"boxhd", {226, 148, 172, 0} +"boxHd", {226, 149, 164, 0} +"boxhD", {226, 149, 165, 0} +"boxHD", {226, 149, 166, 0} +"boxhu", {226, 148, 180, 0} +"boxHu", {226, 149, 167, 0} +"boxhU", {226, 149, 168, 0} +"boxHU", {226, 149, 169, 0} +"boxminus", {226, 138, 159, 0} +"boxplus", {226, 138, 158, 0} +"boxtimes", {226, 138, 160, 0} +"boxul", {226, 148, 152, 0} +"boxuL", {226, 149, 155, 0} +"boxUl", {226, 149, 156, 0} +"boxUL", {226, 149, 157, 0} +"boxur", {226, 148, 148, 0} +"boxuR", {226, 149, 152, 0} +"boxUr", {226, 149, 153, 0} +"boxUR", {226, 149, 154, 0} +"boxv", {226, 148, 130, 0} +"boxV", {226, 149, 145, 0} +"boxvh", {226, 148, 188, 0} +"boxvH", {226, 149, 170, 0} +"boxVh", {226, 149, 171, 0} +"boxVH", {226, 149, 172, 0} +"boxvl", {226, 148, 164, 0} +"boxvL", {226, 149, 161, 0} +"boxVl", {226, 149, 162, 0} +"boxVL", {226, 149, 163, 0} +"boxvr", {226, 148, 156, 0} +"boxvR", {226, 149, 158, 0} +"boxVr", {226, 149, 159, 0} +"boxVR", {226, 149, 160, 0} +"bprime", {226, 128, 181, 0} +"breve", {203, 152, 0} +"Breve", {203, 152, 0} +"brvbar", {194, 166, 0} +"bscr", {240, 157, 146, 183} +"Bscr", {226, 132, 172, 0} +"bsemi", {226, 129, 143, 0} +"bsim", {226, 136, 189, 0} +"bsime", {226, 139, 141, 0} +"bsolb", {226, 167, 133, 0} +"bsol", {92, 0} +"bsolhsub", {226, 159, 136, 0} +"bull", {226, 128, 162, 0} +"bullet", {226, 128, 162, 0} +"bump", {226, 137, 142, 0} +"bumpE", {226, 170, 174, 0} +"bumpe", {226, 137, 143, 0} +"Bumpeq", {226, 137, 142, 0} +"bumpeq", {226, 137, 143, 0} +"Cacute", {196, 134, 0} +"cacute", {196, 135, 0} +"capand", {226, 169, 132, 0} +"capbrcup", {226, 169, 137, 0} +"capcap", {226, 169, 139, 0} +"cap", {226, 136, 169, 0} +"Cap", {226, 139, 146, 0} +"capcup", {226, 169, 135, 0} +"capdot", {226, 169, 128, 0} +"CapitalDifferentialD", {226, 133, 133, 0} +"caps", {226, 136, 169, 0} +"caret", {226, 129, 129, 0} +"caron", {203, 135, 0} +"Cayleys", {226, 132, 173, 0} +"ccaps", {226, 169, 141, 0} +"Ccaron", {196, 140, 0} +"ccaron", {196, 141, 0} +"Ccedil", {195, 135, 0} +"ccedil", {195, 167, 0} +"Ccirc", {196, 136, 0} +"ccirc", {196, 137, 0} +"Cconint", {226, 136, 176, 0} +"ccups", {226, 169, 140, 0} +"ccupssm", {226, 169, 144, 0} +"Cdot", {196, 138, 0} +"cdot", {196, 139, 0} +"cedil", {194, 184, 0} +"Cedilla", {194, 184, 0} +"cemptyv", {226, 166, 178, 0} +"cent", {194, 162, 0} +"centerdot", {194, 183, 0} +"CenterDot", {194, 183, 0} +"cfr", {240, 157, 148, 160} +"Cfr", {226, 132, 173, 0} +"CHcy", {208, 167, 0} +"chcy", {209, 135, 0} +"check", {226, 156, 147, 0} +"checkmark", {226, 156, 147, 0} +"Chi", {206, 167, 0} +"chi", {207, 135, 0} +"circ", {203, 134, 0} +"circeq", {226, 137, 151, 0} +"circlearrowleft", {226, 134, 186, 0} +"circlearrowright", {226, 134, 187, 0} +"circledast", {226, 138, 155, 0} +"circledcirc", {226, 138, 154, 0} +"circleddash", {226, 138, 157, 0} +"CircleDot", {226, 138, 153, 0} +"circledR", {194, 174, 0} +"circledS", {226, 147, 136, 0} +"CircleMinus", {226, 138, 150, 0} +"CirclePlus", {226, 138, 149, 0} +"CircleTimes", {226, 138, 151, 0} +"cir", {226, 151, 139, 0} +"cirE", {226, 167, 131, 0} +"cire", {226, 137, 151, 0} +"cirfnint", {226, 168, 144, 0} +"cirmid", {226, 171, 175, 0} +"cirscir", {226, 167, 130, 0} +"ClockwiseContourIntegral", {226, 136, 178, 0} +"CloseCurlyDoubleQuote", {226, 128, 157, 0} +"CloseCurlyQuote", {226, 128, 153, 0} +"clubs", {226, 153, 163, 0} +"clubsuit", {226, 153, 163, 0} +"colon", {58, 0} +"Colon", {226, 136, 183, 0} +"Colone", {226, 169, 180, 0} +"colone", {226, 137, 148, 0} +"coloneq", {226, 137, 148, 0} +"comma", {44, 0} +"commat", {64, 0} +"comp", {226, 136, 129, 0} +"compfn", {226, 136, 152, 0} +"complement", {226, 136, 129, 0} +"complexes", {226, 132, 130, 0} +"cong", {226, 137, 133, 0} +"congdot", {226, 169, 173, 0} +"Congruent", {226, 137, 161, 0} +"conint", {226, 136, 174, 0} +"Conint", {226, 136, 175, 0} +"ContourIntegral", {226, 136, 174, 0} +"copf", {240, 157, 149, 148} +"Copf", {226, 132, 130, 0} +"coprod", {226, 136, 144, 0} +"Coproduct", {226, 136, 144, 0} +"copy", {194, 169, 0} +"COPY", {194, 169, 0} +"copysr", {226, 132, 151, 0} +"CounterClockwiseContourIntegral", {226, 136, 179, 0} +"crarr", {226, 134, 181, 0} +"cross", {226, 156, 151, 0} +"Cross", {226, 168, 175, 0} +"Cscr", {240, 157, 146, 158} +"cscr", {240, 157, 146, 184} +"csub", {226, 171, 143, 0} +"csube", {226, 171, 145, 0} +"csup", {226, 171, 144, 0} +"csupe", {226, 171, 146, 0} +"ctdot", {226, 139, 175, 0} +"cudarrl", {226, 164, 184, 0} +"cudarrr", {226, 164, 181, 0} +"cuepr", {226, 139, 158, 0} +"cuesc", {226, 139, 159, 0} +"cularr", {226, 134, 182, 0} +"cularrp", {226, 164, 189, 0} +"cupbrcap", {226, 169, 136, 0} +"cupcap", {226, 169, 134, 0} +"CupCap", {226, 137, 141, 0} +"cup", {226, 136, 170, 0} +"Cup", {226, 139, 147, 0} +"cupcup", {226, 169, 138, 0} +"cupdot", {226, 138, 141, 0} +"cupor", {226, 169, 133, 0} +"cups", {226, 136, 170, 0} +"curarr", {226, 134, 183, 0} +"curarrm", {226, 164, 188, 0} +"curlyeqprec", {226, 139, 158, 0} +"curlyeqsucc", {226, 139, 159, 0} +"curlyvee", {226, 139, 142, 0} +"curlywedge", {226, 139, 143, 0} +"curren", {194, 164, 0} +"curvearrowleft", {226, 134, 182, 0} +"curvearrowright", {226, 134, 183, 0} +"cuvee", {226, 139, 142, 0} +"cuwed", {226, 139, 143, 0} +"cwconint", {226, 136, 178, 0} +"cwint", {226, 136, 177, 0} +"cylcty", {226, 140, 173, 0} +"dagger", {226, 128, 160, 0} +"Dagger", {226, 128, 161, 0} +"daleth", {226, 132, 184, 0} +"darr", {226, 134, 147, 0} +"Darr", {226, 134, 161, 0} +"dArr", {226, 135, 147, 0} +"dash", {226, 128, 144, 0} +"Dashv", {226, 171, 164, 0} +"dashv", {226, 138, 163, 0} +"dbkarow", {226, 164, 143, 0} +"dblac", {203, 157, 0} +"Dcaron", {196, 142, 0} +"dcaron", {196, 143, 0} +"Dcy", {208, 148, 0} +"dcy", {208, 180, 0} +"ddagger", {226, 128, 161, 0} +"ddarr", {226, 135, 138, 0} +"DD", {226, 133, 133, 0} +"dd", {226, 133, 134, 0} +"DDotrahd", {226, 164, 145, 0} +"ddotseq", {226, 169, 183, 0} +"deg", {194, 176, 0} +"Del", {226, 136, 135, 0} +"Delta", {206, 148, 0} +"delta", {206, 180, 0} +"demptyv", {226, 166, 177, 0} +"dfisht", {226, 165, 191, 0} +"Dfr", {240, 157, 148, 135} +"dfr", {240, 157, 148, 161} +"dHar", {226, 165, 165, 0} +"dharl", {226, 135, 131, 0} +"dharr", {226, 135, 130, 0} +"DiacriticalAcute", {194, 180, 0} +"DiacriticalDot", {203, 153, 0} +"DiacriticalDoubleAcute", {203, 157, 0} +"DiacriticalGrave", {96, 0} +"DiacriticalTilde", {203, 156, 0} +"diam", {226, 139, 132, 0} +"diamond", {226, 139, 132, 0} +"Diamond", {226, 139, 132, 0} +"diamondsuit", {226, 153, 166, 0} +"diams", {226, 153, 166, 0} +"die", {194, 168, 0} +"DifferentialD", {226, 133, 134, 0} +"digamma", {207, 157, 0} +"disin", {226, 139, 178, 0} +"div", {195, 183, 0} +"divide", {195, 183, 0} +"divideontimes", {226, 139, 135, 0} +"divonx", {226, 139, 135, 0} +"DJcy", {208, 130, 0} +"djcy", {209, 146, 0} +"dlcorn", {226, 140, 158, 0} +"dlcrop", {226, 140, 141, 0} +"dollar", {36, 0} +"Dopf", {240, 157, 148, 187} +"dopf", {240, 157, 149, 149} +"Dot", {194, 168, 0} +"dot", {203, 153, 0} +"DotDot", {226, 131, 156, 0} +"doteq", {226, 137, 144, 0} +"doteqdot", {226, 137, 145, 0} +"DotEqual", {226, 137, 144, 0} +"dotminus", {226, 136, 184, 0} +"dotplus", {226, 136, 148, 0} +"dotsquare", {226, 138, 161, 0} +"doublebarwedge", {226, 140, 134, 0} +"DoubleContourIntegral", {226, 136, 175, 0} +"DoubleDot", {194, 168, 0} +"DoubleDownArrow", {226, 135, 147, 0} +"DoubleLeftArrow", {226, 135, 144, 0} +"DoubleLeftRightArrow", {226, 135, 148, 0} +"DoubleLeftTee", {226, 171, 164, 0} +"DoubleLongLeftArrow", {226, 159, 184, 0} +"DoubleLongLeftRightArrow", {226, 159, 186, 0} +"DoubleLongRightArrow", {226, 159, 185, 0} +"DoubleRightArrow", {226, 135, 146, 0} +"DoubleRightTee", {226, 138, 168, 0} +"DoubleUpArrow", {226, 135, 145, 0} +"DoubleUpDownArrow", {226, 135, 149, 0} +"DoubleVerticalBar", {226, 136, 165, 0} +"DownArrowBar", {226, 164, 147, 0} +"downarrow", {226, 134, 147, 0} +"DownArrow", {226, 134, 147, 0} +"Downarrow", {226, 135, 147, 0} +"DownArrowUpArrow", {226, 135, 181, 0} +"DownBreve", {204, 145, 0} +"downdownarrows", {226, 135, 138, 0} +"downharpoonleft", {226, 135, 131, 0} +"downharpoonright", {226, 135, 130, 0} +"DownLeftRightVector", {226, 165, 144, 0} +"DownLeftTeeVector", {226, 165, 158, 0} +"DownLeftVectorBar", {226, 165, 150, 0} +"DownLeftVector", {226, 134, 189, 0} +"DownRightTeeVector", {226, 165, 159, 0} +"DownRightVectorBar", {226, 165, 151, 0} +"DownRightVector", {226, 135, 129, 0} +"DownTeeArrow", {226, 134, 167, 0} +"DownTee", {226, 138, 164, 0} +"drbkarow", {226, 164, 144, 0} +"drcorn", {226, 140, 159, 0} +"drcrop", {226, 140, 140, 0} +"Dscr", {240, 157, 146, 159} +"dscr", {240, 157, 146, 185} +"DScy", {208, 133, 0} +"dscy", {209, 149, 0} +"dsol", {226, 167, 182, 0} +"Dstrok", {196, 144, 0} +"dstrok", {196, 145, 0} +"dtdot", {226, 139, 177, 0} +"dtri", {226, 150, 191, 0} +"dtrif", {226, 150, 190, 0} +"duarr", {226, 135, 181, 0} +"duhar", {226, 165, 175, 0} +"dwangle", {226, 166, 166, 0} +"DZcy", {208, 143, 0} +"dzcy", {209, 159, 0} +"dzigrarr", {226, 159, 191, 0} +"Eacute", {195, 137, 0} +"eacute", {195, 169, 0} +"easter", {226, 169, 174, 0} +"Ecaron", {196, 154, 0} +"ecaron", {196, 155, 0} +"Ecirc", {195, 138, 0} +"ecirc", {195, 170, 0} +"ecir", {226, 137, 150, 0} +"ecolon", {226, 137, 149, 0} +"Ecy", {208, 173, 0} +"ecy", {209, 141, 0} +"eDDot", {226, 169, 183, 0} +"Edot", {196, 150, 0} +"edot", {196, 151, 0} +"eDot", {226, 137, 145, 0} +"ee", {226, 133, 135, 0} +"efDot", {226, 137, 146, 0} +"Efr", {240, 157, 148, 136} +"efr", {240, 157, 148, 162} +"eg", {226, 170, 154, 0} +"Egrave", {195, 136, 0} +"egrave", {195, 168, 0} +"egs", {226, 170, 150, 0} +"egsdot", {226, 170, 152, 0} +"el", {226, 170, 153, 0} +"Element", {226, 136, 136, 0} +"elinters", {226, 143, 167, 0} +"ell", {226, 132, 147, 0} +"els", {226, 170, 149, 0} +"elsdot", {226, 170, 151, 0} +"Emacr", {196, 146, 0} +"emacr", {196, 147, 0} +"empty", {226, 136, 133, 0} +"emptyset", {226, 136, 133, 0} +"EmptySmallSquare", {226, 151, 187, 0} +"emptyv", {226, 136, 133, 0} +"EmptyVerySmallSquare", {226, 150, 171, 0} +"emsp13", {226, 128, 132, 0} +"emsp14", {226, 128, 133, 0} +"emsp", {226, 128, 131, 0} +"ENG", {197, 138, 0} +"eng", {197, 139, 0} +"ensp", {226, 128, 130, 0} +"Eogon", {196, 152, 0} +"eogon", {196, 153, 0} +"Eopf", {240, 157, 148, 188} +"eopf", {240, 157, 149, 150} +"epar", {226, 139, 149, 0} +"eparsl", {226, 167, 163, 0} +"eplus", {226, 169, 177, 0} +"epsi", {206, 181, 0} +"Epsilon", {206, 149, 0} +"epsilon", {206, 181, 0} +"epsiv", {207, 181, 0} +"eqcirc", {226, 137, 150, 0} +"eqcolon", {226, 137, 149, 0} +"eqsim", {226, 137, 130, 0} +"eqslantgtr", {226, 170, 150, 0} +"eqslantless", {226, 170, 149, 0} +"Equal", {226, 169, 181, 0} +"equals", {61, 0} +"EqualTilde", {226, 137, 130, 0} +"equest", {226, 137, 159, 0} +"Equilibrium", {226, 135, 140, 0} +"equiv", {226, 137, 161, 0} +"equivDD", {226, 169, 184, 0} +"eqvparsl", {226, 167, 165, 0} +"erarr", {226, 165, 177, 0} +"erDot", {226, 137, 147, 0} +"escr", {226, 132, 175, 0} +"Escr", {226, 132, 176, 0} +"esdot", {226, 137, 144, 0} +"Esim", {226, 169, 179, 0} +"esim", {226, 137, 130, 0} +"Eta", {206, 151, 0} +"eta", {206, 183, 0} +"ETH", {195, 144, 0} +"eth", {195, 176, 0} +"Euml", {195, 139, 0} +"euml", {195, 171, 0} +"euro", {226, 130, 172, 0} +"excl", {33, 0} +"exist", {226, 136, 131, 0} +"Exists", {226, 136, 131, 0} +"expectation", {226, 132, 176, 0} +"exponentiale", {226, 133, 135, 0} +"ExponentialE", {226, 133, 135, 0} +"fallingdotseq", {226, 137, 146, 0} +"Fcy", {208, 164, 0} +"fcy", {209, 132, 0} +"female", {226, 153, 128, 0} +"ffilig", {239, 172, 131, 0} +"fflig", {239, 172, 128, 0} +"ffllig", {239, 172, 132, 0} +"Ffr", {240, 157, 148, 137} +"ffr", {240, 157, 148, 163} +"filig", {239, 172, 129, 0} +"FilledSmallSquare", {226, 151, 188, 0} +"FilledVerySmallSquare", {226, 150, 170, 0} +"fjlig", {102, 0} +"flat", {226, 153, 173, 0} +"fllig", {239, 172, 130, 0} +"fltns", {226, 150, 177, 0} +"fnof", {198, 146, 0} +"Fopf", {240, 157, 148, 189} +"fopf", {240, 157, 149, 151} +"forall", {226, 136, 128, 0} +"ForAll", {226, 136, 128, 0} +"fork", {226, 139, 148, 0} +"forkv", {226, 171, 153, 0} +"Fouriertrf", {226, 132, 177, 0} +"fpartint", {226, 168, 141, 0} +"frac12", {194, 189, 0} +"frac13", {226, 133, 147, 0} +"frac14", {194, 188, 0} +"frac15", {226, 133, 149, 0} +"frac16", {226, 133, 153, 0} +"frac18", {226, 133, 155, 0} +"frac23", {226, 133, 148, 0} +"frac25", {226, 133, 150, 0} +"frac34", {194, 190, 0} +"frac35", {226, 133, 151, 0} +"frac38", {226, 133, 156, 0} +"frac45", {226, 133, 152, 0} +"frac56", {226, 133, 154, 0} +"frac58", {226, 133, 157, 0} +"frac78", {226, 133, 158, 0} +"frasl", {226, 129, 132, 0} +"frown", {226, 140, 162, 0} +"fscr", {240, 157, 146, 187} +"Fscr", {226, 132, 177, 0} +"gacute", {199, 181, 0} +"Gamma", {206, 147, 0} +"gamma", {206, 179, 0} +"Gammad", {207, 156, 0} +"gammad", {207, 157, 0} +"gap", {226, 170, 134, 0} +"Gbreve", {196, 158, 0} +"gbreve", {196, 159, 0} +"Gcedil", {196, 162, 0} +"Gcirc", {196, 156, 0} +"gcirc", {196, 157, 0} +"Gcy", {208, 147, 0} +"gcy", {208, 179, 0} +"Gdot", {196, 160, 0} +"gdot", {196, 161, 0} +"ge", {226, 137, 165, 0} +"gE", {226, 137, 167, 0} +"gEl", {226, 170, 140, 0} +"gel", {226, 139, 155, 0} +"geq", {226, 137, 165, 0} +"geqq", {226, 137, 167, 0} +"geqslant", {226, 169, 190, 0} +"gescc", {226, 170, 169, 0} +"ges", {226, 169, 190, 0} +"gesdot", {226, 170, 128, 0} +"gesdoto", {226, 170, 130, 0} +"gesdotol", {226, 170, 132, 0} +"gesl", {226, 139, 155, 0} +"gesles", {226, 170, 148, 0} +"Gfr", {240, 157, 148, 138} +"gfr", {240, 157, 148, 164} +"gg", {226, 137, 171, 0} +"Gg", {226, 139, 153, 0} +"ggg", {226, 139, 153, 0} +"gimel", {226, 132, 183, 0} +"GJcy", {208, 131, 0} +"gjcy", {209, 147, 0} +"gla", {226, 170, 165, 0} +"gl", {226, 137, 183, 0} +"glE", {226, 170, 146, 0} +"glj", {226, 170, 164, 0} +"gnap", {226, 170, 138, 0} +"gnapprox", {226, 170, 138, 0} +"gne", {226, 170, 136, 0} +"gnE", {226, 137, 169, 0} +"gneq", {226, 170, 136, 0} +"gneqq", {226, 137, 169, 0} +"gnsim", {226, 139, 167, 0} +"Gopf", {240, 157, 148, 190} +"gopf", {240, 157, 149, 152} +"grave", {96, 0} +"GreaterEqual", {226, 137, 165, 0} +"GreaterEqualLess", {226, 139, 155, 0} +"GreaterFullEqual", {226, 137, 167, 0} +"GreaterGreater", {226, 170, 162, 0} +"GreaterLess", {226, 137, 183, 0} +"GreaterSlantEqual", {226, 169, 190, 0} +"GreaterTilde", {226, 137, 179, 0} +"Gscr", {240, 157, 146, 162} +"gscr", {226, 132, 138, 0} +"gsim", {226, 137, 179, 0} +"gsime", {226, 170, 142, 0} +"gsiml", {226, 170, 144, 0} +"gtcc", {226, 170, 167, 0} +"gtcir", {226, 169, 186, 0} +"gt", {62, 0} +"GT", {62, 0} +"Gt", {226, 137, 171, 0} +"gtdot", {226, 139, 151, 0} +"gtlPar", {226, 166, 149, 0} +"gtquest", {226, 169, 188, 0} +"gtrapprox", {226, 170, 134, 0} +"gtrarr", {226, 165, 184, 0} +"gtrdot", {226, 139, 151, 0} +"gtreqless", {226, 139, 155, 0} +"gtreqqless", {226, 170, 140, 0} +"gtrless", {226, 137, 183, 0} +"gtrsim", {226, 137, 179, 0} +"gvertneqq", {226, 137, 169, 0} +"gvnE", {226, 137, 169, 0} +"Hacek", {203, 135, 0} +"hairsp", {226, 128, 138, 0} +"half", {194, 189, 0} +"hamilt", {226, 132, 139, 0} +"HARDcy", {208, 170, 0} +"hardcy", {209, 138, 0} +"harrcir", {226, 165, 136, 0} +"harr", {226, 134, 148, 0} +"hArr", {226, 135, 148, 0} +"harrw", {226, 134, 173, 0} +"Hat", {94, 0} +"hbar", {226, 132, 143, 0} +"Hcirc", {196, 164, 0} +"hcirc", {196, 165, 0} +"hearts", {226, 153, 165, 0} +"heartsuit", {226, 153, 165, 0} +"hellip", {226, 128, 166, 0} +"hercon", {226, 138, 185, 0} +"hfr", {240, 157, 148, 165} +"Hfr", {226, 132, 140, 0} +"HilbertSpace", {226, 132, 139, 0} +"hksearow", {226, 164, 165, 0} +"hkswarow", {226, 164, 166, 0} +"hoarr", {226, 135, 191, 0} +"homtht", {226, 136, 187, 0} +"hookleftarrow", {226, 134, 169, 0} +"hookrightarrow", {226, 134, 170, 0} +"hopf", {240, 157, 149, 153} +"Hopf", {226, 132, 141, 0} +"horbar", {226, 128, 149, 0} +"HorizontalLine", {226, 148, 128, 0} +"hscr", {240, 157, 146, 189} +"Hscr", {226, 132, 139, 0} +"hslash", {226, 132, 143, 0} +"Hstrok", {196, 166, 0} +"hstrok", {196, 167, 0} +"HumpDownHump", {226, 137, 142, 0} +"HumpEqual", {226, 137, 143, 0} +"hybull", {226, 129, 131, 0} +"hyphen", {226, 128, 144, 0} +"Iacute", {195, 141, 0} +"iacute", {195, 173, 0} +"ic", {226, 129, 163, 0} +"Icirc", {195, 142, 0} +"icirc", {195, 174, 0} +"Icy", {208, 152, 0} +"icy", {208, 184, 0} +"Idot", {196, 176, 0} +"IEcy", {208, 149, 0} +"iecy", {208, 181, 0} +"iexcl", {194, 161, 0} +"iff", {226, 135, 148, 0} +"ifr", {240, 157, 148, 166} +"Ifr", {226, 132, 145, 0} +"Igrave", {195, 140, 0} +"igrave", {195, 172, 0} +"ii", {226, 133, 136, 0} +"iiiint", {226, 168, 140, 0} +"iiint", {226, 136, 173, 0} +"iinfin", {226, 167, 156, 0} +"iiota", {226, 132, 169, 0} +"IJlig", {196, 178, 0} +"ijlig", {196, 179, 0} +"Imacr", {196, 170, 0} +"imacr", {196, 171, 0} +"image", {226, 132, 145, 0} +"ImaginaryI", {226, 133, 136, 0} +"imagline", {226, 132, 144, 0} +"imagpart", {226, 132, 145, 0} +"imath", {196, 177, 0} +"Im", {226, 132, 145, 0} +"imof", {226, 138, 183, 0} +"imped", {198, 181, 0} +"Implies", {226, 135, 146, 0} +"incare", {226, 132, 133, 0} +"in", {226, 136, 136, 0} +"infin", {226, 136, 158, 0} +"infintie", {226, 167, 157, 0} +"inodot", {196, 177, 0} +"intcal", {226, 138, 186, 0} +"int", {226, 136, 171, 0} +"Int", {226, 136, 172, 0} +"integers", {226, 132, 164, 0} +"Integral", {226, 136, 171, 0} +"intercal", {226, 138, 186, 0} +"Intersection", {226, 139, 130, 0} +"intlarhk", {226, 168, 151, 0} +"intprod", {226, 168, 188, 0} +"InvisibleComma", {226, 129, 163, 0} +"InvisibleTimes", {226, 129, 162, 0} +"IOcy", {208, 129, 0} +"iocy", {209, 145, 0} +"Iogon", {196, 174, 0} +"iogon", {196, 175, 0} +"Iopf", {240, 157, 149, 128} +"iopf", {240, 157, 149, 154} +"Iota", {206, 153, 0} +"iota", {206, 185, 0} +"iprod", {226, 168, 188, 0} +"iquest", {194, 191, 0} +"iscr", {240, 157, 146, 190} +"Iscr", {226, 132, 144, 0} +"isin", {226, 136, 136, 0} +"isindot", {226, 139, 181, 0} +"isinE", {226, 139, 185, 0} +"isins", {226, 139, 180, 0} +"isinsv", {226, 139, 179, 0} +"isinv", {226, 136, 136, 0} +"it", {226, 129, 162, 0} +"Itilde", {196, 168, 0} +"itilde", {196, 169, 0} +"Iukcy", {208, 134, 0} +"iukcy", {209, 150, 0} +"Iuml", {195, 143, 0} +"iuml", {195, 175, 0} +"Jcirc", {196, 180, 0} +"jcirc", {196, 181, 0} +"Jcy", {208, 153, 0} +"jcy", {208, 185, 0} +"Jfr", {240, 157, 148, 141} +"jfr", {240, 157, 148, 167} +"jmath", {200, 183, 0} +"Jopf", {240, 157, 149, 129} +"jopf", {240, 157, 149, 155} +"Jscr", {240, 157, 146, 165} +"jscr", {240, 157, 146, 191} +"Jsercy", {208, 136, 0} +"jsercy", {209, 152, 0} +"Jukcy", {208, 132, 0} +"jukcy", {209, 148, 0} +"Kappa", {206, 154, 0} +"kappa", {206, 186, 0} +"kappav", {207, 176, 0} +"Kcedil", {196, 182, 0} +"kcedil", {196, 183, 0} +"Kcy", {208, 154, 0} +"kcy", {208, 186, 0} +"Kfr", {240, 157, 148, 142} +"kfr", {240, 157, 148, 168} +"kgreen", {196, 184, 0} +"KHcy", {208, 165, 0} +"khcy", {209, 133, 0} +"KJcy", {208, 140, 0} +"kjcy", {209, 156, 0} +"Kopf", {240, 157, 149, 130} +"kopf", {240, 157, 149, 156} +"Kscr", {240, 157, 146, 166} +"kscr", {240, 157, 147, 128} +"lAarr", {226, 135, 154, 0} +"Lacute", {196, 185, 0} +"lacute", {196, 186, 0} +"laemptyv", {226, 166, 180, 0} +"lagran", {226, 132, 146, 0} +"Lambda", {206, 155, 0} +"lambda", {206, 187, 0} +"lang", {226, 159, 168, 0} +"Lang", {226, 159, 170, 0} +"langd", {226, 166, 145, 0} +"langle", {226, 159, 168, 0} +"lap", {226, 170, 133, 0} +"Laplacetrf", {226, 132, 146, 0} +"laquo", {194, 171, 0} +"larrb", {226, 135, 164, 0} +"larrbfs", {226, 164, 159, 0} +"larr", {226, 134, 144, 0} +"Larr", {226, 134, 158, 0} +"lArr", {226, 135, 144, 0} +"larrfs", {226, 164, 157, 0} +"larrhk", {226, 134, 169, 0} +"larrlp", {226, 134, 171, 0} +"larrpl", {226, 164, 185, 0} +"larrsim", {226, 165, 179, 0} +"larrtl", {226, 134, 162, 0} +"latail", {226, 164, 153, 0} +"lAtail", {226, 164, 155, 0} +"lat", {226, 170, 171, 0} +"late", {226, 170, 173, 0} +"lates", {226, 170, 173, 0} +"lbarr", {226, 164, 140, 0} +"lBarr", {226, 164, 142, 0} +"lbbrk", {226, 157, 178, 0} +"lbrace", {123, 0} +"lbrack", {91, 0} +"lbrke", {226, 166, 139, 0} +"lbrksld", {226, 166, 143, 0} +"lbrkslu", {226, 166, 141, 0} +"Lcaron", {196, 189, 0} +"lcaron", {196, 190, 0} +"Lcedil", {196, 187, 0} +"lcedil", {196, 188, 0} +"lceil", {226, 140, 136, 0} +"lcub", {123, 0} +"Lcy", {208, 155, 0} +"lcy", {208, 187, 0} +"ldca", {226, 164, 182, 0} +"ldquo", {226, 128, 156, 0} +"ldquor", {226, 128, 158, 0} +"ldrdhar", {226, 165, 167, 0} +"ldrushar", {226, 165, 139, 0} +"ldsh", {226, 134, 178, 0} +"le", {226, 137, 164, 0} +"lE", {226, 137, 166, 0} +"LeftAngleBracket", {226, 159, 168, 0} +"LeftArrowBar", {226, 135, 164, 0} +"leftarrow", {226, 134, 144, 0} +"LeftArrow", {226, 134, 144, 0} +"Leftarrow", {226, 135, 144, 0} +"LeftArrowRightArrow", {226, 135, 134, 0} +"leftarrowtail", {226, 134, 162, 0} +"LeftCeiling", {226, 140, 136, 0} +"LeftDoubleBracket", {226, 159, 166, 0} +"LeftDownTeeVector", {226, 165, 161, 0} +"LeftDownVectorBar", {226, 165, 153, 0} +"LeftDownVector", {226, 135, 131, 0} +"LeftFloor", {226, 140, 138, 0} +"leftharpoondown", {226, 134, 189, 0} +"leftharpoonup", {226, 134, 188, 0} +"leftleftarrows", {226, 135, 135, 0} +"leftrightarrow", {226, 134, 148, 0} +"LeftRightArrow", {226, 134, 148, 0} +"Leftrightarrow", {226, 135, 148, 0} +"leftrightarrows", {226, 135, 134, 0} +"leftrightharpoons", {226, 135, 139, 0} +"leftrightsquigarrow", {226, 134, 173, 0} +"LeftRightVector", {226, 165, 142, 0} +"LeftTeeArrow", {226, 134, 164, 0} +"LeftTee", {226, 138, 163, 0} +"LeftTeeVector", {226, 165, 154, 0} +"leftthreetimes", {226, 139, 139, 0} +"LeftTriangleBar", {226, 167, 143, 0} +"LeftTriangle", {226, 138, 178, 0} +"LeftTriangleEqual", {226, 138, 180, 0} +"LeftUpDownVector", {226, 165, 145, 0} +"LeftUpTeeVector", {226, 165, 160, 0} +"LeftUpVectorBar", {226, 165, 152, 0} +"LeftUpVector", {226, 134, 191, 0} +"LeftVectorBar", {226, 165, 146, 0} +"LeftVector", {226, 134, 188, 0} +"lEg", {226, 170, 139, 0} +"leg", {226, 139, 154, 0} +"leq", {226, 137, 164, 0} +"leqq", {226, 137, 166, 0} +"leqslant", {226, 169, 189, 0} +"lescc", {226, 170, 168, 0} +"les", {226, 169, 189, 0} +"lesdot", {226, 169, 191, 0} +"lesdoto", {226, 170, 129, 0} +"lesdotor", {226, 170, 131, 0} +"lesg", {226, 139, 154, 0} +"lesges", {226, 170, 147, 0} +"lessapprox", {226, 170, 133, 0} +"lessdot", {226, 139, 150, 0} +"lesseqgtr", {226, 139, 154, 0} +"lesseqqgtr", {226, 170, 139, 0} +"LessEqualGreater", {226, 139, 154, 0} +"LessFullEqual", {226, 137, 166, 0} +"LessGreater", {226, 137, 182, 0} +"lessgtr", {226, 137, 182, 0} +"LessLess", {226, 170, 161, 0} +"lesssim", {226, 137, 178, 0} +"LessSlantEqual", {226, 169, 189, 0} +"LessTilde", {226, 137, 178, 0} +"lfisht", {226, 165, 188, 0} +"lfloor", {226, 140, 138, 0} +"Lfr", {240, 157, 148, 143} +"lfr", {240, 157, 148, 169} +"lg", {226, 137, 182, 0} +"lgE", {226, 170, 145, 0} +"lHar", {226, 165, 162, 0} +"lhard", {226, 134, 189, 0} +"lharu", {226, 134, 188, 0} +"lharul", {226, 165, 170, 0} +"lhblk", {226, 150, 132, 0} +"LJcy", {208, 137, 0} +"ljcy", {209, 153, 0} +"llarr", {226, 135, 135, 0} +"ll", {226, 137, 170, 0} +"Ll", {226, 139, 152, 0} +"llcorner", {226, 140, 158, 0} +"Lleftarrow", {226, 135, 154, 0} +"llhard", {226, 165, 171, 0} +"lltri", {226, 151, 186, 0} +"Lmidot", {196, 191, 0} +"lmidot", {197, 128, 0} +"lmoustache", {226, 142, 176, 0} +"lmoust", {226, 142, 176, 0} +"lnap", {226, 170, 137, 0} +"lnapprox", {226, 170, 137, 0} +"lne", {226, 170, 135, 0} +"lnE", {226, 137, 168, 0} +"lneq", {226, 170, 135, 0} +"lneqq", {226, 137, 168, 0} +"lnsim", {226, 139, 166, 0} +"loang", {226, 159, 172, 0} +"loarr", {226, 135, 189, 0} +"lobrk", {226, 159, 166, 0} +"longleftarrow", {226, 159, 181, 0} +"LongLeftArrow", {226, 159, 181, 0} +"Longleftarrow", {226, 159, 184, 0} +"longleftrightarrow", {226, 159, 183, 0} +"LongLeftRightArrow", {226, 159, 183, 0} +"Longleftrightarrow", {226, 159, 186, 0} +"longmapsto", {226, 159, 188, 0} +"longrightarrow", {226, 159, 182, 0} +"LongRightArrow", {226, 159, 182, 0} +"Longrightarrow", {226, 159, 185, 0} +"looparrowleft", {226, 134, 171, 0} +"looparrowright", {226, 134, 172, 0} +"lopar", {226, 166, 133, 0} +"Lopf", {240, 157, 149, 131} +"lopf", {240, 157, 149, 157} +"loplus", {226, 168, 173, 0} +"lotimes", {226, 168, 180, 0} +"lowast", {226, 136, 151, 0} +"lowbar", {95, 0} +"LowerLeftArrow", {226, 134, 153, 0} +"LowerRightArrow", {226, 134, 152, 0} +"loz", {226, 151, 138, 0} +"lozenge", {226, 151, 138, 0} +"lozf", {226, 167, 171, 0} +"lpar", {40, 0} +"lparlt", {226, 166, 147, 0} +"lrarr", {226, 135, 134, 0} +"lrcorner", {226, 140, 159, 0} +"lrhar", {226, 135, 139, 0} +"lrhard", {226, 165, 173, 0} +"lrm", {226, 128, 142, 0} +"lrtri", {226, 138, 191, 0} +"lsaquo", {226, 128, 185, 0} +"lscr", {240, 157, 147, 129} +"Lscr", {226, 132, 146, 0} +"lsh", {226, 134, 176, 0} +"Lsh", {226, 134, 176, 0} +"lsim", {226, 137, 178, 0} +"lsime", {226, 170, 141, 0} +"lsimg", {226, 170, 143, 0} +"lsqb", {91, 0} +"lsquo", {226, 128, 152, 0} +"lsquor", {226, 128, 154, 0} +"Lstrok", {197, 129, 0} +"lstrok", {197, 130, 0} +"ltcc", {226, 170, 166, 0} +"ltcir", {226, 169, 185, 0} +"lt", {60, 0} +"LT", {60, 0} +"Lt", {226, 137, 170, 0} +"ltdot", {226, 139, 150, 0} +"lthree", {226, 139, 139, 0} +"ltimes", {226, 139, 137, 0} +"ltlarr", {226, 165, 182, 0} +"ltquest", {226, 169, 187, 0} +"ltri", {226, 151, 131, 0} +"ltrie", {226, 138, 180, 0} +"ltrif", {226, 151, 130, 0} +"ltrPar", {226, 166, 150, 0} +"lurdshar", {226, 165, 138, 0} +"luruhar", {226, 165, 166, 0} +"lvertneqq", {226, 137, 168, 0} +"lvnE", {226, 137, 168, 0} +"macr", {194, 175, 0} +"male", {226, 153, 130, 0} +"malt", {226, 156, 160, 0} +"maltese", {226, 156, 160, 0} +"Map", {226, 164, 133, 0} +"map", {226, 134, 166, 0} +"mapsto", {226, 134, 166, 0} +"mapstodown", {226, 134, 167, 0} +"mapstoleft", {226, 134, 164, 0} +"mapstoup", {226, 134, 165, 0} +"marker", {226, 150, 174, 0} +"mcomma", {226, 168, 169, 0} +"Mcy", {208, 156, 0} +"mcy", {208, 188, 0} +"mdash", {226, 128, 148, 0} +"mDDot", {226, 136, 186, 0} +"measuredangle", {226, 136, 161, 0} +"MediumSpace", {226, 129, 159, 0} +"Mellintrf", {226, 132, 179, 0} +"Mfr", {240, 157, 148, 144} +"mfr", {240, 157, 148, 170} +"mho", {226, 132, 167, 0} +"micro", {194, 181, 0} +"midast", {42, 0} +"midcir", {226, 171, 176, 0} +"mid", {226, 136, 163, 0} +"middot", {194, 183, 0} +"minusb", {226, 138, 159, 0} +"minus", {226, 136, 146, 0} +"minusd", {226, 136, 184, 0} +"minusdu", {226, 168, 170, 0} +"MinusPlus", {226, 136, 147, 0} +"mlcp", {226, 171, 155, 0} +"mldr", {226, 128, 166, 0} +"mnplus", {226, 136, 147, 0} +"models", {226, 138, 167, 0} +"Mopf", {240, 157, 149, 132} +"mopf", {240, 157, 149, 158} +"mp", {226, 136, 147, 0} +"mscr", {240, 157, 147, 130} +"Mscr", {226, 132, 179, 0} +"mstpos", {226, 136, 190, 0} +"Mu", {206, 156, 0} +"mu", {206, 188, 0} +"multimap", {226, 138, 184, 0} +"mumap", {226, 138, 184, 0} +"nabla", {226, 136, 135, 0} +"Nacute", {197, 131, 0} +"nacute", {197, 132, 0} +"nang", {226, 136, 160, 0} +"nap", {226, 137, 137, 0} +"napE", {226, 169, 176, 0} +"napid", {226, 137, 139, 0} +"napos", {197, 137, 0} +"napprox", {226, 137, 137, 0} +"natural", {226, 153, 174, 0} +"naturals", {226, 132, 149, 0} +"natur", {226, 153, 174, 0} +"nbsp", {194, 160, 0} +"nbump", {226, 137, 142, 0} +"nbumpe", {226, 137, 143, 0} +"ncap", {226, 169, 131, 0} +"Ncaron", {197, 135, 0} +"ncaron", {197, 136, 0} +"Ncedil", {197, 133, 0} +"ncedil", {197, 134, 0} +"ncong", {226, 137, 135, 0} +"ncongdot", {226, 169, 173, 0} +"ncup", {226, 169, 130, 0} +"Ncy", {208, 157, 0} +"ncy", {208, 189, 0} +"ndash", {226, 128, 147, 0} +"nearhk", {226, 164, 164, 0} +"nearr", {226, 134, 151, 0} +"neArr", {226, 135, 151, 0} +"nearrow", {226, 134, 151, 0} +"ne", {226, 137, 160, 0} +"nedot", {226, 137, 144, 0} +"NegativeMediumSpace", {226, 128, 139, 0} +"NegativeThickSpace", {226, 128, 139, 0} +"NegativeThinSpace", {226, 128, 139, 0} +"NegativeVeryThinSpace", {226, 128, 139, 0} +"nequiv", {226, 137, 162, 0} +"nesear", {226, 164, 168, 0} +"nesim", {226, 137, 130, 0} +"NestedGreaterGreater", {226, 137, 171, 0} +"NestedLessLess", {226, 137, 170, 0} +"NewLine", {10, 0} +"nexist", {226, 136, 132, 0} +"nexists", {226, 136, 132, 0} +"Nfr", {240, 157, 148, 145} +"nfr", {240, 157, 148, 171} +"ngE", {226, 137, 167, 0} +"nge", {226, 137, 177, 0} +"ngeq", {226, 137, 177, 0} +"ngeqq", {226, 137, 167, 0} +"ngeqslant", {226, 169, 190, 0} +"nges", {226, 169, 190, 0} +"nGg", {226, 139, 153, 0} +"ngsim", {226, 137, 181, 0} +"nGt", {226, 137, 171, 0} +"ngt", {226, 137, 175, 0} +"ngtr", {226, 137, 175, 0} +"nGtv", {226, 137, 171, 0} +"nharr", {226, 134, 174, 0} +"nhArr", {226, 135, 142, 0} +"nhpar", {226, 171, 178, 0} +"ni", {226, 136, 139, 0} +"nis", {226, 139, 188, 0} +"nisd", {226, 139, 186, 0} +"niv", {226, 136, 139, 0} +"NJcy", {208, 138, 0} +"njcy", {209, 154, 0} +"nlarr", {226, 134, 154, 0} +"nlArr", {226, 135, 141, 0} +"nldr", {226, 128, 165, 0} +"nlE", {226, 137, 166, 0} +"nle", {226, 137, 176, 0} +"nleftarrow", {226, 134, 154, 0} +"nLeftarrow", {226, 135, 141, 0} +"nleftrightarrow", {226, 134, 174, 0} +"nLeftrightarrow", {226, 135, 142, 0} +"nleq", {226, 137, 176, 0} +"nleqq", {226, 137, 166, 0} +"nleqslant", {226, 169, 189, 0} +"nles", {226, 169, 189, 0} +"nless", {226, 137, 174, 0} +"nLl", {226, 139, 152, 0} +"nlsim", {226, 137, 180, 0} +"nLt", {226, 137, 170, 0} +"nlt", {226, 137, 174, 0} +"nltri", {226, 139, 170, 0} +"nltrie", {226, 139, 172, 0} +"nLtv", {226, 137, 170, 0} +"nmid", {226, 136, 164, 0} +"NoBreak", {226, 129, 160, 0} +"NonBreakingSpace", {194, 160, 0} +"nopf", {240, 157, 149, 159} +"Nopf", {226, 132, 149, 0} +"Not", {226, 171, 172, 0} +"not", {194, 172, 0} +"NotCongruent", {226, 137, 162, 0} +"NotCupCap", {226, 137, 173, 0} +"NotDoubleVerticalBar", {226, 136, 166, 0} +"NotElement", {226, 136, 137, 0} +"NotEqual", {226, 137, 160, 0} +"NotEqualTilde", {226, 137, 130, 0} +"NotExists", {226, 136, 132, 0} +"NotGreater", {226, 137, 175, 0} +"NotGreaterEqual", {226, 137, 177, 0} +"NotGreaterFullEqual", {226, 137, 167, 0} +"NotGreaterGreater", {226, 137, 171, 0} +"NotGreaterLess", {226, 137, 185, 0} +"NotGreaterSlantEqual", {226, 169, 190, 0} +"NotGreaterTilde", {226, 137, 181, 0} +"NotHumpDownHump", {226, 137, 142, 0} +"NotHumpEqual", {226, 137, 143, 0} +"notin", {226, 136, 137, 0} +"notindot", {226, 139, 181, 0} +"notinE", {226, 139, 185, 0} +"notinva", {226, 136, 137, 0} +"notinvb", {226, 139, 183, 0} +"notinvc", {226, 139, 182, 0} +"NotLeftTriangleBar", {226, 167, 143, 0} +"NotLeftTriangle", {226, 139, 170, 0} +"NotLeftTriangleEqual", {226, 139, 172, 0} +"NotLess", {226, 137, 174, 0} +"NotLessEqual", {226, 137, 176, 0} +"NotLessGreater", {226, 137, 184, 0} +"NotLessLess", {226, 137, 170, 0} +"NotLessSlantEqual", {226, 169, 189, 0} +"NotLessTilde", {226, 137, 180, 0} +"NotNestedGreaterGreater", {226, 170, 162, 0} +"NotNestedLessLess", {226, 170, 161, 0} +"notni", {226, 136, 140, 0} +"notniva", {226, 136, 140, 0} +"notnivb", {226, 139, 190, 0} +"notnivc", {226, 139, 189, 0} +"NotPrecedes", {226, 138, 128, 0} +"NotPrecedesEqual", {226, 170, 175, 0} +"NotPrecedesSlantEqual", {226, 139, 160, 0} +"NotReverseElement", {226, 136, 140, 0} +"NotRightTriangleBar", {226, 167, 144, 0} +"NotRightTriangle", {226, 139, 171, 0} +"NotRightTriangleEqual", {226, 139, 173, 0} +"NotSquareSubset", {226, 138, 143, 0} +"NotSquareSubsetEqual", {226, 139, 162, 0} +"NotSquareSuperset", {226, 138, 144, 0} +"NotSquareSupersetEqual", {226, 139, 163, 0} +"NotSubset", {226, 138, 130, 0} +"NotSubsetEqual", {226, 138, 136, 0} +"NotSucceeds", {226, 138, 129, 0} +"NotSucceedsEqual", {226, 170, 176, 0} +"NotSucceedsSlantEqual", {226, 139, 161, 0} +"NotSucceedsTilde", {226, 137, 191, 0} +"NotSuperset", {226, 138, 131, 0} +"NotSupersetEqual", {226, 138, 137, 0} +"NotTilde", {226, 137, 129, 0} +"NotTildeEqual", {226, 137, 132, 0} +"NotTildeFullEqual", {226, 137, 135, 0} +"NotTildeTilde", {226, 137, 137, 0} +"NotVerticalBar", {226, 136, 164, 0} +"nparallel", {226, 136, 166, 0} +"npar", {226, 136, 166, 0} +"nparsl", {226, 171, 189, 0} +"npart", {226, 136, 130, 0} +"npolint", {226, 168, 148, 0} +"npr", {226, 138, 128, 0} +"nprcue", {226, 139, 160, 0} +"nprec", {226, 138, 128, 0} +"npreceq", {226, 170, 175, 0} +"npre", {226, 170, 175, 0} +"nrarrc", {226, 164, 179, 0} +"nrarr", {226, 134, 155, 0} +"nrArr", {226, 135, 143, 0} +"nrarrw", {226, 134, 157, 0} +"nrightarrow", {226, 134, 155, 0} +"nRightarrow", {226, 135, 143, 0} +"nrtri", {226, 139, 171, 0} +"nrtrie", {226, 139, 173, 0} +"nsc", {226, 138, 129, 0} +"nsccue", {226, 139, 161, 0} +"nsce", {226, 170, 176, 0} +"Nscr", {240, 157, 146, 169} +"nscr", {240, 157, 147, 131} +"nshortmid", {226, 136, 164, 0} +"nshortparallel", {226, 136, 166, 0} +"nsim", {226, 137, 129, 0} +"nsime", {226, 137, 132, 0} +"nsimeq", {226, 137, 132, 0} +"nsmid", {226, 136, 164, 0} +"nspar", {226, 136, 166, 0} +"nsqsube", {226, 139, 162, 0} +"nsqsupe", {226, 139, 163, 0} +"nsub", {226, 138, 132, 0} +"nsubE", {226, 171, 133, 0} +"nsube", {226, 138, 136, 0} +"nsubset", {226, 138, 130, 0} +"nsubseteq", {226, 138, 136, 0} +"nsubseteqq", {226, 171, 133, 0} +"nsucc", {226, 138, 129, 0} +"nsucceq", {226, 170, 176, 0} +"nsup", {226, 138, 133, 0} +"nsupE", {226, 171, 134, 0} +"nsupe", {226, 138, 137, 0} +"nsupset", {226, 138, 131, 0} +"nsupseteq", {226, 138, 137, 0} +"nsupseteqq", {226, 171, 134, 0} +"ntgl", {226, 137, 185, 0} +"Ntilde", {195, 145, 0} +"ntilde", {195, 177, 0} +"ntlg", {226, 137, 184, 0} +"ntriangleleft", {226, 139, 170, 0} +"ntrianglelefteq", {226, 139, 172, 0} +"ntriangleright", {226, 139, 171, 0} +"ntrianglerighteq", {226, 139, 173, 0} +"Nu", {206, 157, 0} +"nu", {206, 189, 0} +"num", {35, 0} +"numero", {226, 132, 150, 0} +"numsp", {226, 128, 135, 0} +"nvap", {226, 137, 141, 0} +"nvdash", {226, 138, 172, 0} +"nvDash", {226, 138, 173, 0} +"nVdash", {226, 138, 174, 0} +"nVDash", {226, 138, 175, 0} +"nvge", {226, 137, 165, 0} +"nvgt", {62, 0} +"nvHarr", {226, 164, 132, 0} +"nvinfin", {226, 167, 158, 0} +"nvlArr", {226, 164, 130, 0} +"nvle", {226, 137, 164, 0} +"nvlt", {60, 0} +"nvltrie", {226, 138, 180, 0} +"nvrArr", {226, 164, 131, 0} +"nvrtrie", {226, 138, 181, 0} +"nvsim", {226, 136, 188, 0} +"nwarhk", {226, 164, 163, 0} +"nwarr", {226, 134, 150, 0} +"nwArr", {226, 135, 150, 0} +"nwarrow", {226, 134, 150, 0} +"nwnear", {226, 164, 167, 0} +"Oacute", {195, 147, 0} +"oacute", {195, 179, 0} +"oast", {226, 138, 155, 0} +"Ocirc", {195, 148, 0} +"ocirc", {195, 180, 0} +"ocir", {226, 138, 154, 0} +"Ocy", {208, 158, 0} +"ocy", {208, 190, 0} +"odash", {226, 138, 157, 0} +"Odblac", {197, 144, 0} +"odblac", {197, 145, 0} +"odiv", {226, 168, 184, 0} +"odot", {226, 138, 153, 0} +"odsold", {226, 166, 188, 0} +"OElig", {197, 146, 0} +"oelig", {197, 147, 0} +"ofcir", {226, 166, 191, 0} +"Ofr", {240, 157, 148, 146} +"ofr", {240, 157, 148, 172} +"ogon", {203, 155, 0} +"Ograve", {195, 146, 0} +"ograve", {195, 178, 0} +"ogt", {226, 167, 129, 0} +"ohbar", {226, 166, 181, 0} +"ohm", {206, 169, 0} +"oint", {226, 136, 174, 0} +"olarr", {226, 134, 186, 0} +"olcir", {226, 166, 190, 0} +"olcross", {226, 166, 187, 0} +"oline", {226, 128, 190, 0} +"olt", {226, 167, 128, 0} +"Omacr", {197, 140, 0} +"omacr", {197, 141, 0} +"Omega", {206, 169, 0} +"omega", {207, 137, 0} +"Omicron", {206, 159, 0} +"omicron", {206, 191, 0} +"omid", {226, 166, 182, 0} +"ominus", {226, 138, 150, 0} +"Oopf", {240, 157, 149, 134} +"oopf", {240, 157, 149, 160} +"opar", {226, 166, 183, 0} +"OpenCurlyDoubleQuote", {226, 128, 156, 0} +"OpenCurlyQuote", {226, 128, 152, 0} +"operp", {226, 166, 185, 0} +"oplus", {226, 138, 149, 0} +"orarr", {226, 134, 187, 0} +"Or", {226, 169, 148, 0} +"or", {226, 136, 168, 0} +"ord", {226, 169, 157, 0} +"order", {226, 132, 180, 0} +"orderof", {226, 132, 180, 0} +"ordf", {194, 170, 0} +"ordm", {194, 186, 0} +"origof", {226, 138, 182, 0} +"oror", {226, 169, 150, 0} +"orslope", {226, 169, 151, 0} +"orv", {226, 169, 155, 0} +"oS", {226, 147, 136, 0} +"Oscr", {240, 157, 146, 170} +"oscr", {226, 132, 180, 0} +"Oslash", {195, 152, 0} +"oslash", {195, 184, 0} +"osol", {226, 138, 152, 0} +"Otilde", {195, 149, 0} +"otilde", {195, 181, 0} +"otimesas", {226, 168, 182, 0} +"Otimes", {226, 168, 183, 0} +"otimes", {226, 138, 151, 0} +"Ouml", {195, 150, 0} +"ouml", {195, 182, 0} +"ovbar", {226, 140, 189, 0} +"OverBar", {226, 128, 190, 0} +"OverBrace", {226, 143, 158, 0} +"OverBracket", {226, 142, 180, 0} +"OverParenthesis", {226, 143, 156, 0} +"para", {194, 182, 0} +"parallel", {226, 136, 165, 0} +"par", {226, 136, 165, 0} +"parsim", {226, 171, 179, 0} +"parsl", {226, 171, 189, 0} +"part", {226, 136, 130, 0} +"PartialD", {226, 136, 130, 0} +"Pcy", {208, 159, 0} +"pcy", {208, 191, 0} +"percnt", {37, 0} +"period", {46, 0} +"permil", {226, 128, 176, 0} +"perp", {226, 138, 165, 0} +"pertenk", {226, 128, 177, 0} +"Pfr", {240, 157, 148, 147} +"pfr", {240, 157, 148, 173} +"Phi", {206, 166, 0} +"phi", {207, 134, 0} +"phiv", {207, 149, 0} +"phmmat", {226, 132, 179, 0} +"phone", {226, 152, 142, 0} +"Pi", {206, 160, 0} +"pi", {207, 128, 0} +"pitchfork", {226, 139, 148, 0} +"piv", {207, 150, 0} +"planck", {226, 132, 143, 0} +"planckh", {226, 132, 142, 0} +"plankv", {226, 132, 143, 0} +"plusacir", {226, 168, 163, 0} +"plusb", {226, 138, 158, 0} +"pluscir", {226, 168, 162, 0} +"plus", {43, 0} +"plusdo", {226, 136, 148, 0} +"plusdu", {226, 168, 165, 0} +"pluse", {226, 169, 178, 0} +"PlusMinus", {194, 177, 0} +"plusmn", {194, 177, 0} +"plussim", {226, 168, 166, 0} +"plustwo", {226, 168, 167, 0} +"pm", {194, 177, 0} +"Poincareplane", {226, 132, 140, 0} +"pointint", {226, 168, 149, 0} +"popf", {240, 157, 149, 161} +"Popf", {226, 132, 153, 0} +"pound", {194, 163, 0} +"prap", {226, 170, 183, 0} +"Pr", {226, 170, 187, 0} +"pr", {226, 137, 186, 0} +"prcue", {226, 137, 188, 0} +"precapprox", {226, 170, 183, 0} +"prec", {226, 137, 186, 0} +"preccurlyeq", {226, 137, 188, 0} +"Precedes", {226, 137, 186, 0} +"PrecedesEqual", {226, 170, 175, 0} +"PrecedesSlantEqual", {226, 137, 188, 0} +"PrecedesTilde", {226, 137, 190, 0} +"preceq", {226, 170, 175, 0} +"precnapprox", {226, 170, 185, 0} +"precneqq", {226, 170, 181, 0} +"precnsim", {226, 139, 168, 0} +"pre", {226, 170, 175, 0} +"prE", {226, 170, 179, 0} +"precsim", {226, 137, 190, 0} +"prime", {226, 128, 178, 0} +"Prime", {226, 128, 179, 0} +"primes", {226, 132, 153, 0} +"prnap", {226, 170, 185, 0} +"prnE", {226, 170, 181, 0} +"prnsim", {226, 139, 168, 0} +"prod", {226, 136, 143, 0} +"Product", {226, 136, 143, 0} +"profalar", {226, 140, 174, 0} +"profline", {226, 140, 146, 0} +"profsurf", {226, 140, 147, 0} +"prop", {226, 136, 157, 0} +"Proportional", {226, 136, 157, 0} +"Proportion", {226, 136, 183, 0} +"propto", {226, 136, 157, 0} +"prsim", {226, 137, 190, 0} +"prurel", {226, 138, 176, 0} +"Pscr", {240, 157, 146, 171} +"pscr", {240, 157, 147, 133} +"Psi", {206, 168, 0} +"psi", {207, 136, 0} +"puncsp", {226, 128, 136, 0} +"Qfr", {240, 157, 148, 148} +"qfr", {240, 157, 148, 174} +"qint", {226, 168, 140, 0} +"qopf", {240, 157, 149, 162} +"Qopf", {226, 132, 154, 0} +"qprime", {226, 129, 151, 0} +"Qscr", {240, 157, 146, 172} +"qscr", {240, 157, 147, 134} +"quaternions", {226, 132, 141, 0} +"quatint", {226, 168, 150, 0} +"quest", {63, 0} +"questeq", {226, 137, 159, 0} +"quot", {34, 0} +"QUOT", {34, 0} +"rAarr", {226, 135, 155, 0} +"race", {226, 136, 189, 0} +"Racute", {197, 148, 0} +"racute", {197, 149, 0} +"radic", {226, 136, 154, 0} +"raemptyv", {226, 166, 179, 0} +"rang", {226, 159, 169, 0} +"Rang", {226, 159, 171, 0} +"rangd", {226, 166, 146, 0} +"range", {226, 166, 165, 0} +"rangle", {226, 159, 169, 0} +"raquo", {194, 187, 0} +"rarrap", {226, 165, 181, 0} +"rarrb", {226, 135, 165, 0} +"rarrbfs", {226, 164, 160, 0} +"rarrc", {226, 164, 179, 0} +"rarr", {226, 134, 146, 0} +"Rarr", {226, 134, 160, 0} +"rArr", {226, 135, 146, 0} +"rarrfs", {226, 164, 158, 0} +"rarrhk", {226, 134, 170, 0} +"rarrlp", {226, 134, 172, 0} +"rarrpl", {226, 165, 133, 0} +"rarrsim", {226, 165, 180, 0} +"Rarrtl", {226, 164, 150, 0} +"rarrtl", {226, 134, 163, 0} +"rarrw", {226, 134, 157, 0} +"ratail", {226, 164, 154, 0} +"rAtail", {226, 164, 156, 0} +"ratio", {226, 136, 182, 0} +"rationals", {226, 132, 154, 0} +"rbarr", {226, 164, 141, 0} +"rBarr", {226, 164, 143, 0} +"RBarr", {226, 164, 144, 0} +"rbbrk", {226, 157, 179, 0} +"rbrace", {125, 0} +"rbrack", {93, 0} +"rbrke", {226, 166, 140, 0} +"rbrksld", {226, 166, 142, 0} +"rbrkslu", {226, 166, 144, 0} +"Rcaron", {197, 152, 0} +"rcaron", {197, 153, 0} +"Rcedil", {197, 150, 0} +"rcedil", {197, 151, 0} +"rceil", {226, 140, 137, 0} +"rcub", {125, 0} +"Rcy", {208, 160, 0} +"rcy", {209, 128, 0} +"rdca", {226, 164, 183, 0} +"rdldhar", {226, 165, 169, 0} +"rdquo", {226, 128, 157, 0} +"rdquor", {226, 128, 157, 0} +"rdsh", {226, 134, 179, 0} +"real", {226, 132, 156, 0} +"realine", {226, 132, 155, 0} +"realpart", {226, 132, 156, 0} +"reals", {226, 132, 157, 0} +"Re", {226, 132, 156, 0} +"rect", {226, 150, 173, 0} +"reg", {194, 174, 0} +"REG", {194, 174, 0} +"ReverseElement", {226, 136, 139, 0} +"ReverseEquilibrium", {226, 135, 139, 0} +"ReverseUpEquilibrium", {226, 165, 175, 0} +"rfisht", {226, 165, 189, 0} +"rfloor", {226, 140, 139, 0} +"rfr", {240, 157, 148, 175} +"Rfr", {226, 132, 156, 0} +"rHar", {226, 165, 164, 0} +"rhard", {226, 135, 129, 0} +"rharu", {226, 135, 128, 0} +"rharul", {226, 165, 172, 0} +"Rho", {206, 161, 0} +"rho", {207, 129, 0} +"rhov", {207, 177, 0} +"RightAngleBracket", {226, 159, 169, 0} +"RightArrowBar", {226, 135, 165, 0} +"rightarrow", {226, 134, 146, 0} +"RightArrow", {226, 134, 146, 0} +"Rightarrow", {226, 135, 146, 0} +"RightArrowLeftArrow", {226, 135, 132, 0} +"rightarrowtail", {226, 134, 163, 0} +"RightCeiling", {226, 140, 137, 0} +"RightDoubleBracket", {226, 159, 167, 0} +"RightDownTeeVector", {226, 165, 157, 0} +"RightDownVectorBar", {226, 165, 149, 0} +"RightDownVector", {226, 135, 130, 0} +"RightFloor", {226, 140, 139, 0} +"rightharpoondown", {226, 135, 129, 0} +"rightharpoonup", {226, 135, 128, 0} +"rightleftarrows", {226, 135, 132, 0} +"rightleftharpoons", {226, 135, 140, 0} +"rightrightarrows", {226, 135, 137, 0} +"rightsquigarrow", {226, 134, 157, 0} +"RightTeeArrow", {226, 134, 166, 0} +"RightTee", {226, 138, 162, 0} +"RightTeeVector", {226, 165, 155, 0} +"rightthreetimes", {226, 139, 140, 0} +"RightTriangleBar", {226, 167, 144, 0} +"RightTriangle", {226, 138, 179, 0} +"RightTriangleEqual", {226, 138, 181, 0} +"RightUpDownVector", {226, 165, 143, 0} +"RightUpTeeVector", {226, 165, 156, 0} +"RightUpVectorBar", {226, 165, 148, 0} +"RightUpVector", {226, 134, 190, 0} +"RightVectorBar", {226, 165, 147, 0} +"RightVector", {226, 135, 128, 0} +"ring", {203, 154, 0} +"risingdotseq", {226, 137, 147, 0} +"rlarr", {226, 135, 132, 0} +"rlhar", {226, 135, 140, 0} +"rlm", {226, 128, 143, 0} +"rmoustache", {226, 142, 177, 0} +"rmoust", {226, 142, 177, 0} +"rnmid", {226, 171, 174, 0} +"roang", {226, 159, 173, 0} +"roarr", {226, 135, 190, 0} +"robrk", {226, 159, 167, 0} +"ropar", {226, 166, 134, 0} +"ropf", {240, 157, 149, 163} +"Ropf", {226, 132, 157, 0} +"roplus", {226, 168, 174, 0} +"rotimes", {226, 168, 181, 0} +"RoundImplies", {226, 165, 176, 0} +"rpar", {41, 0} +"rpargt", {226, 166, 148, 0} +"rppolint", {226, 168, 146, 0} +"rrarr", {226, 135, 137, 0} +"Rrightarrow", {226, 135, 155, 0} +"rsaquo", {226, 128, 186, 0} +"rscr", {240, 157, 147, 135} +"Rscr", {226, 132, 155, 0} +"rsh", {226, 134, 177, 0} +"Rsh", {226, 134, 177, 0} +"rsqb", {93, 0} +"rsquo", {226, 128, 153, 0} +"rsquor", {226, 128, 153, 0} +"rthree", {226, 139, 140, 0} +"rtimes", {226, 139, 138, 0} +"rtri", {226, 150, 185, 0} +"rtrie", {226, 138, 181, 0} +"rtrif", {226, 150, 184, 0} +"rtriltri", {226, 167, 142, 0} +"RuleDelayed", {226, 167, 180, 0} +"ruluhar", {226, 165, 168, 0} +"rx", {226, 132, 158, 0} +"Sacute", {197, 154, 0} +"sacute", {197, 155, 0} +"sbquo", {226, 128, 154, 0} +"scap", {226, 170, 184, 0} +"Scaron", {197, 160, 0} +"scaron", {197, 161, 0} +"Sc", {226, 170, 188, 0} +"sc", {226, 137, 187, 0} +"sccue", {226, 137, 189, 0} +"sce", {226, 170, 176, 0} +"scE", {226, 170, 180, 0} +"Scedil", {197, 158, 0} +"scedil", {197, 159, 0} +"Scirc", {197, 156, 0} +"scirc", {197, 157, 0} +"scnap", {226, 170, 186, 0} +"scnE", {226, 170, 182, 0} +"scnsim", {226, 139, 169, 0} +"scpolint", {226, 168, 147, 0} +"scsim", {226, 137, 191, 0} +"Scy", {208, 161, 0} +"scy", {209, 129, 0} +"sdotb", {226, 138, 161, 0} +"sdot", {226, 139, 133, 0} +"sdote", {226, 169, 166, 0} +"searhk", {226, 164, 165, 0} +"searr", {226, 134, 152, 0} +"seArr", {226, 135, 152, 0} +"searrow", {226, 134, 152, 0} +"sect", {194, 167, 0} +"semi", {59, 0} +"seswar", {226, 164, 169, 0} +"setminus", {226, 136, 150, 0} +"setmn", {226, 136, 150, 0} +"sext", {226, 156, 182, 0} +"Sfr", {240, 157, 148, 150} +"sfr", {240, 157, 148, 176} +"sfrown", {226, 140, 162, 0} +"sharp", {226, 153, 175, 0} +"SHCHcy", {208, 169, 0} +"shchcy", {209, 137, 0} +"SHcy", {208, 168, 0} +"shcy", {209, 136, 0} +"ShortDownArrow", {226, 134, 147, 0} +"ShortLeftArrow", {226, 134, 144, 0} +"shortmid", {226, 136, 163, 0} +"shortparallel", {226, 136, 165, 0} +"ShortRightArrow", {226, 134, 146, 0} +"ShortUpArrow", {226, 134, 145, 0} +"shy", {194, 173, 0} +"Sigma", {206, 163, 0} +"sigma", {207, 131, 0} +"sigmaf", {207, 130, 0} +"sigmav", {207, 130, 0} +"sim", {226, 136, 188, 0} +"simdot", {226, 169, 170, 0} +"sime", {226, 137, 131, 0} +"simeq", {226, 137, 131, 0} +"simg", {226, 170, 158, 0} +"simgE", {226, 170, 160, 0} +"siml", {226, 170, 157, 0} +"simlE", {226, 170, 159, 0} +"simne", {226, 137, 134, 0} +"simplus", {226, 168, 164, 0} +"simrarr", {226, 165, 178, 0} +"slarr", {226, 134, 144, 0} +"SmallCircle", {226, 136, 152, 0} +"smallsetminus", {226, 136, 150, 0} +"smashp", {226, 168, 179, 0} +"smeparsl", {226, 167, 164, 0} +"smid", {226, 136, 163, 0} +"smile", {226, 140, 163, 0} +"smt", {226, 170, 170, 0} +"smte", {226, 170, 172, 0} +"smtes", {226, 170, 172, 0} +"SOFTcy", {208, 172, 0} +"softcy", {209, 140, 0} +"solbar", {226, 140, 191, 0} +"solb", {226, 167, 132, 0} +"sol", {47, 0} +"Sopf", {240, 157, 149, 138} +"sopf", {240, 157, 149, 164} +"spades", {226, 153, 160, 0} +"spadesuit", {226, 153, 160, 0} +"spar", {226, 136, 165, 0} +"sqcap", {226, 138, 147, 0} +"sqcaps", {226, 138, 147, 0} +"sqcup", {226, 138, 148, 0} +"sqcups", {226, 138, 148, 0} +"Sqrt", {226, 136, 154, 0} +"sqsub", {226, 138, 143, 0} +"sqsube", {226, 138, 145, 0} +"sqsubset", {226, 138, 143, 0} +"sqsubseteq", {226, 138, 145, 0} +"sqsup", {226, 138, 144, 0} +"sqsupe", {226, 138, 146, 0} +"sqsupset", {226, 138, 144, 0} +"sqsupseteq", {226, 138, 146, 0} +"square", {226, 150, 161, 0} +"Square", {226, 150, 161, 0} +"SquareIntersection", {226, 138, 147, 0} +"SquareSubset", {226, 138, 143, 0} +"SquareSubsetEqual", {226, 138, 145, 0} +"SquareSuperset", {226, 138, 144, 0} +"SquareSupersetEqual", {226, 138, 146, 0} +"SquareUnion", {226, 138, 148, 0} +"squarf", {226, 150, 170, 0} +"squ", {226, 150, 161, 0} +"squf", {226, 150, 170, 0} +"srarr", {226, 134, 146, 0} +"Sscr", {240, 157, 146, 174} +"sscr", {240, 157, 147, 136} +"ssetmn", {226, 136, 150, 0} +"ssmile", {226, 140, 163, 0} +"sstarf", {226, 139, 134, 0} +"Star", {226, 139, 134, 0} +"star", {226, 152, 134, 0} +"starf", {226, 152, 133, 0} +"straightepsilon", {207, 181, 0} +"straightphi", {207, 149, 0} +"strns", {194, 175, 0} +"sub", {226, 138, 130, 0} +"Sub", {226, 139, 144, 0} +"subdot", {226, 170, 189, 0} +"subE", {226, 171, 133, 0} +"sube", {226, 138, 134, 0} +"subedot", {226, 171, 131, 0} +"submult", {226, 171, 129, 0} +"subnE", {226, 171, 139, 0} +"subne", {226, 138, 138, 0} +"subplus", {226, 170, 191, 0} +"subrarr", {226, 165, 185, 0} +"subset", {226, 138, 130, 0} +"Subset", {226, 139, 144, 0} +"subseteq", {226, 138, 134, 0} +"subseteqq", {226, 171, 133, 0} +"SubsetEqual", {226, 138, 134, 0} +"subsetneq", {226, 138, 138, 0} +"subsetneqq", {226, 171, 139, 0} +"subsim", {226, 171, 135, 0} +"subsub", {226, 171, 149, 0} +"subsup", {226, 171, 147, 0} +"succapprox", {226, 170, 184, 0} +"succ", {226, 137, 187, 0} +"succcurlyeq", {226, 137, 189, 0} +"Succeeds", {226, 137, 187, 0} +"SucceedsEqual", {226, 170, 176, 0} +"SucceedsSlantEqual", {226, 137, 189, 0} +"SucceedsTilde", {226, 137, 191, 0} +"succeq", {226, 170, 176, 0} +"succnapprox", {226, 170, 186, 0} +"succneqq", {226, 170, 182, 0} +"succnsim", {226, 139, 169, 0} +"succsim", {226, 137, 191, 0} +"SuchThat", {226, 136, 139, 0} +"sum", {226, 136, 145, 0} +"Sum", {226, 136, 145, 0} +"sung", {226, 153, 170, 0} +"sup1", {194, 185, 0} +"sup2", {194, 178, 0} +"sup3", {194, 179, 0} +"sup", {226, 138, 131, 0} +"Sup", {226, 139, 145, 0} +"supdot", {226, 170, 190, 0} +"supdsub", {226, 171, 152, 0} +"supE", {226, 171, 134, 0} +"supe", {226, 138, 135, 0} +"supedot", {226, 171, 132, 0} +"Superset", {226, 138, 131, 0} +"SupersetEqual", {226, 138, 135, 0} +"suphsol", {226, 159, 137, 0} +"suphsub", {226, 171, 151, 0} +"suplarr", {226, 165, 187, 0} +"supmult", {226, 171, 130, 0} +"supnE", {226, 171, 140, 0} +"supne", {226, 138, 139, 0} +"supplus", {226, 171, 128, 0} +"supset", {226, 138, 131, 0} +"Supset", {226, 139, 145, 0} +"supseteq", {226, 138, 135, 0} +"supseteqq", {226, 171, 134, 0} +"supsetneq", {226, 138, 139, 0} +"supsetneqq", {226, 171, 140, 0} +"supsim", {226, 171, 136, 0} +"supsub", {226, 171, 148, 0} +"supsup", {226, 171, 150, 0} +"swarhk", {226, 164, 166, 0} +"swarr", {226, 134, 153, 0} +"swArr", {226, 135, 153, 0} +"swarrow", {226, 134, 153, 0} +"swnwar", {226, 164, 170, 0} +"szlig", {195, 159, 0} +"Tab", {9, 0} +"target", {226, 140, 150, 0} +"Tau", {206, 164, 0} +"tau", {207, 132, 0} +"tbrk", {226, 142, 180, 0} +"Tcaron", {197, 164, 0} +"tcaron", {197, 165, 0} +"Tcedil", {197, 162, 0} +"tcedil", {197, 163, 0} +"Tcy", {208, 162, 0} +"tcy", {209, 130, 0} +"tdot", {226, 131, 155, 0} +"telrec", {226, 140, 149, 0} +"Tfr", {240, 157, 148, 151} +"tfr", {240, 157, 148, 177} +"there4", {226, 136, 180, 0} +"therefore", {226, 136, 180, 0} +"Therefore", {226, 136, 180, 0} +"Theta", {206, 152, 0} +"theta", {206, 184, 0} +"thetasym", {207, 145, 0} +"thetav", {207, 145, 0} +"thickapprox", {226, 137, 136, 0} +"thicksim", {226, 136, 188, 0} +"ThickSpace", {226, 129, 159, 0} +"ThinSpace", {226, 128, 137, 0} +"thinsp", {226, 128, 137, 0} +"thkap", {226, 137, 136, 0} +"thksim", {226, 136, 188, 0} +"THORN", {195, 158, 0} +"thorn", {195, 190, 0} +"tilde", {203, 156, 0} +"Tilde", {226, 136, 188, 0} +"TildeEqual", {226, 137, 131, 0} +"TildeFullEqual", {226, 137, 133, 0} +"TildeTilde", {226, 137, 136, 0} +"timesbar", {226, 168, 177, 0} +"timesb", {226, 138, 160, 0} +"times", {195, 151, 0} +"timesd", {226, 168, 176, 0} +"tint", {226, 136, 173, 0} +"toea", {226, 164, 168, 0} +"topbot", {226, 140, 182, 0} +"topcir", {226, 171, 177, 0} +"top", {226, 138, 164, 0} +"Topf", {240, 157, 149, 139} +"topf", {240, 157, 149, 165} +"topfork", {226, 171, 154, 0} +"tosa", {226, 164, 169, 0} +"tprime", {226, 128, 180, 0} +"trade", {226, 132, 162, 0} +"TRADE", {226, 132, 162, 0} +"triangle", {226, 150, 181, 0} +"triangledown", {226, 150, 191, 0} +"triangleleft", {226, 151, 131, 0} +"trianglelefteq", {226, 138, 180, 0} +"triangleq", {226, 137, 156, 0} +"triangleright", {226, 150, 185, 0} +"trianglerighteq", {226, 138, 181, 0} +"tridot", {226, 151, 172, 0} +"trie", {226, 137, 156, 0} +"triminus", {226, 168, 186, 0} +"TripleDot", {226, 131, 155, 0} +"triplus", {226, 168, 185, 0} +"trisb", {226, 167, 141, 0} +"tritime", {226, 168, 187, 0} +"trpezium", {226, 143, 162, 0} +"Tscr", {240, 157, 146, 175} +"tscr", {240, 157, 147, 137} +"TScy", {208, 166, 0} +"tscy", {209, 134, 0} +"TSHcy", {208, 139, 0} +"tshcy", {209, 155, 0} +"Tstrok", {197, 166, 0} +"tstrok", {197, 167, 0} +"twixt", {226, 137, 172, 0} +"twoheadleftarrow", {226, 134, 158, 0} +"twoheadrightarrow", {226, 134, 160, 0} +"Uacute", {195, 154, 0} +"uacute", {195, 186, 0} +"uarr", {226, 134, 145, 0} +"Uarr", {226, 134, 159, 0} +"uArr", {226, 135, 145, 0} +"Uarrocir", {226, 165, 137, 0} +"Ubrcy", {208, 142, 0} +"ubrcy", {209, 158, 0} +"Ubreve", {197, 172, 0} +"ubreve", {197, 173, 0} +"Ucirc", {195, 155, 0} +"ucirc", {195, 187, 0} +"Ucy", {208, 163, 0} +"ucy", {209, 131, 0} +"udarr", {226, 135, 133, 0} +"Udblac", {197, 176, 0} +"udblac", {197, 177, 0} +"udhar", {226, 165, 174, 0} +"ufisht", {226, 165, 190, 0} +"Ufr", {240, 157, 148, 152} +"ufr", {240, 157, 148, 178} +"Ugrave", {195, 153, 0} +"ugrave", {195, 185, 0} +"uHar", {226, 165, 163, 0} +"uharl", {226, 134, 191, 0} +"uharr", {226, 134, 190, 0} +"uhblk", {226, 150, 128, 0} +"ulcorn", {226, 140, 156, 0} +"ulcorner", {226, 140, 156, 0} +"ulcrop", {226, 140, 143, 0} +"ultri", {226, 151, 184, 0} +"Umacr", {197, 170, 0} +"umacr", {197, 171, 0} +"uml", {194, 168, 0} +"UnderBar", {95, 0} +"UnderBrace", {226, 143, 159, 0} +"UnderBracket", {226, 142, 181, 0} +"UnderParenthesis", {226, 143, 157, 0} +"Union", {226, 139, 131, 0} +"UnionPlus", {226, 138, 142, 0} +"Uogon", {197, 178, 0} +"uogon", {197, 179, 0} +"Uopf", {240, 157, 149, 140} +"uopf", {240, 157, 149, 166} +"UpArrowBar", {226, 164, 146, 0} +"uparrow", {226, 134, 145, 0} +"UpArrow", {226, 134, 145, 0} +"Uparrow", {226, 135, 145, 0} +"UpArrowDownArrow", {226, 135, 133, 0} +"updownarrow", {226, 134, 149, 0} +"UpDownArrow", {226, 134, 149, 0} +"Updownarrow", {226, 135, 149, 0} +"UpEquilibrium", {226, 165, 174, 0} +"upharpoonleft", {226, 134, 191, 0} +"upharpoonright", {226, 134, 190, 0} +"uplus", {226, 138, 142, 0} +"UpperLeftArrow", {226, 134, 150, 0} +"UpperRightArrow", {226, 134, 151, 0} +"upsi", {207, 133, 0} +"Upsi", {207, 146, 0} +"upsih", {207, 146, 0} +"Upsilon", {206, 165, 0} +"upsilon", {207, 133, 0} +"UpTeeArrow", {226, 134, 165, 0} +"UpTee", {226, 138, 165, 0} +"upuparrows", {226, 135, 136, 0} +"urcorn", {226, 140, 157, 0} +"urcorner", {226, 140, 157, 0} +"urcrop", {226, 140, 142, 0} +"Uring", {197, 174, 0} +"uring", {197, 175, 0} +"urtri", {226, 151, 185, 0} +"Uscr", {240, 157, 146, 176} +"uscr", {240, 157, 147, 138} +"utdot", {226, 139, 176, 0} +"Utilde", {197, 168, 0} +"utilde", {197, 169, 0} +"utri", {226, 150, 181, 0} +"utrif", {226, 150, 180, 0} +"uuarr", {226, 135, 136, 0} +"Uuml", {195, 156, 0} +"uuml", {195, 188, 0} +"uwangle", {226, 166, 167, 0} +"vangrt", {226, 166, 156, 0} +"varepsilon", {207, 181, 0} +"varkappa", {207, 176, 0} +"varnothing", {226, 136, 133, 0} +"varphi", {207, 149, 0} +"varpi", {207, 150, 0} +"varpropto", {226, 136, 157, 0} +"varr", {226, 134, 149, 0} +"vArr", {226, 135, 149, 0} +"varrho", {207, 177, 0} +"varsigma", {207, 130, 0} +"varsubsetneq", {226, 138, 138, 0} +"varsubsetneqq", {226, 171, 139, 0} +"varsupsetneq", {226, 138, 139, 0} +"varsupsetneqq", {226, 171, 140, 0} +"vartheta", {207, 145, 0} +"vartriangleleft", {226, 138, 178, 0} +"vartriangleright", {226, 138, 179, 0} +"vBar", {226, 171, 168, 0} +"Vbar", {226, 171, 171, 0} +"vBarv", {226, 171, 169, 0} +"Vcy", {208, 146, 0} +"vcy", {208, 178, 0} +"vdash", {226, 138, 162, 0} +"vDash", {226, 138, 168, 0} +"Vdash", {226, 138, 169, 0} +"VDash", {226, 138, 171, 0} +"Vdashl", {226, 171, 166, 0} +"veebar", {226, 138, 187, 0} +"vee", {226, 136, 168, 0} +"Vee", {226, 139, 129, 0} +"veeeq", {226, 137, 154, 0} +"vellip", {226, 139, 174, 0} +"verbar", {124, 0} +"Verbar", {226, 128, 150, 0} +"vert", {124, 0} +"Vert", {226, 128, 150, 0} +"VerticalBar", {226, 136, 163, 0} +"VerticalLine", {124, 0} +"VerticalSeparator", {226, 157, 152, 0} +"VerticalTilde", {226, 137, 128, 0} +"VeryThinSpace", {226, 128, 138, 0} +"Vfr", {240, 157, 148, 153} +"vfr", {240, 157, 148, 179} +"vltri", {226, 138, 178, 0} +"vnsub", {226, 138, 130, 0} +"vnsup", {226, 138, 131, 0} +"Vopf", {240, 157, 149, 141} +"vopf", {240, 157, 149, 167} +"vprop", {226, 136, 157, 0} +"vrtri", {226, 138, 179, 0} +"Vscr", {240, 157, 146, 177} +"vscr", {240, 157, 147, 139} +"vsubnE", {226, 171, 139, 0} +"vsubne", {226, 138, 138, 0} +"vsupnE", {226, 171, 140, 0} +"vsupne", {226, 138, 139, 0} +"Vvdash", {226, 138, 170, 0} +"vzigzag", {226, 166, 154, 0} +"Wcirc", {197, 180, 0} +"wcirc", {197, 181, 0} +"wedbar", {226, 169, 159, 0} +"wedge", {226, 136, 167, 0} +"Wedge", {226, 139, 128, 0} +"wedgeq", {226, 137, 153, 0} +"weierp", {226, 132, 152, 0} +"Wfr", {240, 157, 148, 154} +"wfr", {240, 157, 148, 180} +"Wopf", {240, 157, 149, 142} +"wopf", {240, 157, 149, 168} +"wp", {226, 132, 152, 0} +"wr", {226, 137, 128, 0} +"wreath", {226, 137, 128, 0} +"Wscr", {240, 157, 146, 178} +"wscr", {240, 157, 147, 140} +"xcap", {226, 139, 130, 0} +"xcirc", {226, 151, 175, 0} +"xcup", {226, 139, 131, 0} +"xdtri", {226, 150, 189, 0} +"Xfr", {240, 157, 148, 155} +"xfr", {240, 157, 148, 181} +"xharr", {226, 159, 183, 0} +"xhArr", {226, 159, 186, 0} +"Xi", {206, 158, 0} +"xi", {206, 190, 0} +"xlarr", {226, 159, 181, 0} +"xlArr", {226, 159, 184, 0} +"xmap", {226, 159, 188, 0} +"xnis", {226, 139, 187, 0} +"xodot", {226, 168, 128, 0} +"Xopf", {240, 157, 149, 143} +"xopf", {240, 157, 149, 169} +"xoplus", {226, 168, 129, 0} +"xotime", {226, 168, 130, 0} +"xrarr", {226, 159, 182, 0} +"xrArr", {226, 159, 185, 0} +"Xscr", {240, 157, 146, 179} +"xscr", {240, 157, 147, 141} +"xsqcup", {226, 168, 134, 0} +"xuplus", {226, 168, 132, 0} +"xutri", {226, 150, 179, 0} +"xvee", {226, 139, 129, 0} +"xwedge", {226, 139, 128, 0} +"Yacute", {195, 157, 0} +"yacute", {195, 189, 0} +"YAcy", {208, 175, 0} +"yacy", {209, 143, 0} +"Ycirc", {197, 182, 0} +"ycirc", {197, 183, 0} +"Ycy", {208, 171, 0} +"ycy", {209, 139, 0} +"yen", {194, 165, 0} +"Yfr", {240, 157, 148, 156} +"yfr", {240, 157, 148, 182} +"YIcy", {208, 135, 0} +"yicy", {209, 151, 0} +"Yopf", {240, 157, 149, 144} +"yopf", {240, 157, 149, 170} +"Yscr", {240, 157, 146, 180} +"yscr", {240, 157, 147, 142} +"YUcy", {208, 174, 0} +"yucy", {209, 142, 0} +"yuml", {195, 191, 0} +"Yuml", {197, 184, 0} +"Zacute", {197, 185, 0} +"zacute", {197, 186, 0} +"Zcaron", {197, 189, 0} +"zcaron", {197, 190, 0} +"Zcy", {208, 151, 0} +"zcy", {208, 183, 0} +"Zdot", {197, 187, 0} +"zdot", {197, 188, 0} +"zeetrf", {226, 132, 168, 0} +"ZeroWidthSpace", {226, 128, 139, 0} +"Zeta", {206, 150, 0} +"zeta", {206, 182, 0} +"zfr", {240, 157, 148, 183} +"Zfr", {226, 132, 168, 0} +"ZHcy", {208, 150, 0} +"zhcy", {208, 182, 0} +"zigrarr", {226, 135, 157, 0} +"zopf", {240, 157, 149, 171} +"Zopf", {226, 132, 164, 0} +"Zscr", {240, 157, 146, 181} +"zscr", {240, 157, 147, 143} +"zwj", {226, 128, 141, 0} +"zwnj", {226, 128, 140, 0} diff --git a/html_unescape.h b/html_unescape.h new file mode 100644 index 0000000..1eb318b --- /dev/null +++ b/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/inlines.c b/inlines.c new file mode 100644 index 0000000..2c12408 --- /dev/null +++ b/inlines.c @@ -0,0 +1,1031 @@ +#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" + + +// 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; + unsigned char delim_char; + int position; + 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); + +static void subject_from_buf(subject *e, cmark_strbuf *buffer, + cmark_reference_map *refmap); +static int subject_find_special_char(subject *subj); + +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; + } + } + + 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 { + *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; +} + +// Parse strong/emph or a fallback. +// Assumes the subject has '_' or '*' at the current position. +static cmark_node* handle_strong_emph(subject* subj, unsigned char c) +{ + int numdelims; + cmark_node * inl_text; + bool can_open, can_close; + + numdelims = scan_delims(subj, c, &can_open, &can_close); + + inl_text = make_str(cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims)); + + if (can_open || can_close) { + push_delimiter(subj, c, can_open, can_close, inl_text); + } + + return inl_text; +} + +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 == '_')) { + // 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 (opener != NULL && opener != start_delim) { + closer = S_insert_emph(subj, opener, closer); + } else { + 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) +{ + // "\n\\`&_*[]pos + 1; + + while (n < subj->input.len) { + if (SPECIAL_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) +{ + 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 '_': + new_inl = handle_strong_emph(subj, c); + 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); + 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) +{ + subject subj; + subject_from_buf(&subj, &parent->string_content, refmap); + + while (!is_eof(&subj) && parse_inline(&subj, parent)) ; + + 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/inlines.h b/inlines.h new file mode 100644 index 0000000..d2ccfb4 --- /dev/null +++ b/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 cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/iterator.c b/iterator.c new file mode 100644 index 0000000..eb7b49c --- /dev/null +++ b/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_get_node(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/iterator.h b/iterator.h new file mode 100644 index 0000000..027b10b --- /dev/null +++ b/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/libcmark.pc.in b/libcmark.pc.in new file mode 100644 index 0000000..9c3a9a9 --- /dev/null +++ b/libcmark.pc.in @@ -0,0 +1,10 @@ +prefix=@CMAKE_INSTALL_PREFIX@ +exec_prefix=@CMAKE_INSTALL_PREFIX@ +libdir=@CMAKE_INSTALL_PREFIX@/lib +includedir=@CMAKE_INSTALL_PREFIX@/include + +Name: libcmark +Description: CommonMark parsing, rendering, and manipulation +Version: @PROJECT_VERSION@ +Libs: -L${libdir} -lcmark +Cflags: -I${includedir} diff --git a/man.c b/man.c new file mode 100644 index 0000000..f57eb75 --- /dev/null +++ b/man.c @@ -0,0 +1,250 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" + +// Functions to convert cmark_nodes to groff man strings. + +static void escape_man(cmark_strbuf *dest, const unsigned char *source, int length) +{ + int i; + unsigned char c; + bool beginLine = true; + + for (i = 0; i < length; i++) { + c = source[i]; + if (c == '.' && beginLine) { + cmark_strbuf_puts(dest, "\\&."); + } else if (c == '\'' && beginLine) { + cmark_strbuf_puts(dest, "\\&'"); + } else if (c == '-') { + cmark_strbuf_puts(dest, "\\-"); + } else if (c == '\\') { + cmark_strbuf_puts(dest, "\\e"); + } else { + cmark_strbuf_putc(dest, source[i]); + } + beginLine = (c == '\n'); + } +} + +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, long 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/node.c b/node.c new file mode 100644 index 0000000..fe3dac3 --- /dev/null +++ b/node.c @@ -0,0 +1,871 @@ +#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/node.h b/node.h new file mode 100644 index 0000000..74eddd4 --- /dev/null +++ b/node.h @@ -0,0 +1,79 @@ +#ifndef CMARK_NODE_H +#define CMARK_NODE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#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 { + bool fenced; + int fence_length; + int fence_offset; + unsigned char fence_char; + cmark_chunk info; + cmark_chunk literal; +} cmark_code; + +typedef struct { + int level; + bool setext; +} cmark_header; + +typedef struct { + unsigned char *url; + unsigned char *title; +} cmark_link; + +struct cmark_node { + cmark_node_type type; + + 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; + 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/parser.h b/parser.h new file mode 100644 index 0000000..3c8def9 --- /dev/null +++ b/parser.h @@ -0,0 +1,28 @@ +#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; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/references.c b/references.c new file mode 100644 index 0000000..37bf4cb --- /dev/null +++ b/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/references.h b/references.h new file mode 100644 index 0000000..69325bb --- /dev/null +++ b/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/scanners.c b/scanners.c new file mode 100644 index 0000000..440cf83 --- /dev/null +++ b/scanners.c @@ -0,0 +1,12391 @@ +/* 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, 230, 230, 230, 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 <= '\n') 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 >= '\v') 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 <= '\n') 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 >= '\v') 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 <= '\n') 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 <= '\n') { + 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 <= '\n') 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 <= '\n') 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 <= '\n') 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 <= '\n') { + 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 <= '\n') 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 <= '\n') 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 <= '\n') 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 <= '\n') { + 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 >= '\v') 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 <= '\n') { + 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 <= '\n') { + 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 <= '\n') 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 <= '\n') 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 <= '\n') 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, 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') { + if (yych <= 0x08) goto yy1174; + if (yych <= '\t') goto yy1171; + goto yy1172; + } else { + 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/scanners.h b/scanners.h new file mode 100644 index 0000000..f360505 --- /dev/null +++ b/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/scanners.re b/scanners.re new file mode 100644 index 0000000..28a6991 --- /dev/null +++ b/scanners.re @@ -0,0 +1,236 @@ +#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; +} + +/*!re2c + re2c:define:YYCTYPE = "unsigned char"; + re2c:define:YYCURSOR = p; + re2c:define:YYMARKER = marker; + re2c:define:YYCTXMARKER = marker; + re2c:yyfill:enable = 0; + + wordchar = [^\x00-\x20]; + + spacechar = [ \t\n]; + + reg_char = [^\\()\x00-\x20]; + + escaped_char = [\\][!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~-]; + + tagname = [A-Za-z][A-Za-z0-9]*; + + blocktagname = 'article'|'header'|'aside'|'hgroup'|'iframe'|'blockquote'|'hr'|'body'|'li'|'map'|'button'|'object'|'canvas'|'ol'|'caption'|'output'|'col'|'p'|'colgroup'|'pre'|'dd'|'progress'|'div'|'section'|'dl'|'table'|'td'|'dt'|'tbody'|'embed'|'textarea'|'fieldset'|'tfoot'|'figcaption'|'th'|'figure'|'thead'|'footer'|'footer'|'tr'|'form'|'ul'|'h1'|'h2'|'h3'|'h4'|'h5'|'h6'|'video'|'script'|'style'; + + attributename = [a-zA-Z_:][a-zA-Z0-9:._-]*; + + unquotedvalue = [^\"'=<>`\x00]+; + singlequotedvalue = ['][^'\x00]*[']; + doublequotedvalue = [\"][^\"\x00]*[\"]; + + attributevalue = unquotedvalue | singlequotedvalue | doublequotedvalue; + + attributevaluespec = spacechar* [=] spacechar* attributevalue; + + attribute = spacechar+ attributename attributevaluespec?; + + opentag = tagname attribute* spacechar* [/]? [>]; + closetag = [/] tagname spacechar* [>]; + + htmlcomment = "!---->" | ("!--" ([-]? [^\x00>-]) ([-]? [^\x00-])* "-->"); + + processinginstruction = "?" ([^?>\x00]+ | [?][^>\x00] | [>])* "?>"; + + declaration = "!" [A-Z]+ spacechar+ [^>\x00]* ">"; + + cdata = "![CDATA[" ([^\]\x00]+ | "]" [^\]\x00] | "]]" [^>\x00])* "]]>"; + + htmltag = opentag | closetag | htmlcomment | processinginstruction | + declaration | cdata; + + in_parens_nosp = [(] (reg_char|escaped_char)* [)]; + + in_double_quotes = ["] (escaped_char|[^"\x00])* ["]; + in_single_quotes = ['] (escaped_char|[^'\x00])* [']; + in_parens = [(] (escaped_char|[^)\x00])* [)]; + + scheme = 'coap'|'doi'|'javascript'|'aaa'|'aaas'|'about'|'acap'|'cap'|'cid'|'crid'|'data'|'dav'|'dict'|'dns'|'file'|'ftp'|'geo'|'go'|'gopher'|'h323'|'http'|'https'|'iax'|'icap'|'im'|'imap'|'info'|'ipp'|'iris'|'iris.beep'|'iris.xpc'|'iris.xpcs'|'iris.lwz'|'ldap'|'mailto'|'mid'|'msrp'|'msrps'|'mtqp'|'mupdate'|'news'|'nfs'|'ni'|'nih'|'nntp'|'opaquelocktoken'|'pop'|'pres'|'rtsp'|'service'|'session'|'shttp'|'sieve'|'sip'|'sips'|'sms'|'snmp'|'soap.beep'|'soap.beeps'|'tag'|'tel'|'telnet'|'tftp'|'thismessage'|'tn3270'|'tip'|'tv'|'urn'|'vemmi'|'ws'|'wss'|'xcon'|'xcon-userid'|'xmlrpc.beep'|'xmlrpc.beeps'|'xmpp'|'z39.50r'|'z39.50s'|'adiumxtra'|'afp'|'afs'|'aim'|'apt'|'attachment'|'aw'|'beshare'|'bitcoin'|'bolo'|'callto'|'chrome'|'chrome-extension'|'com-eventbrite-attendee'|'content'|'cvs'|'dlna-playsingle'|'dlna-playcontainer'|'dtn'|'dvb'|'ed2k'|'facetime'|'feed'|'finger'|'fish'|'gg'|'git'|'gizmoproject'|'gtalk'|'hcp'|'icon'|'ipn'|'irc'|'irc6'|'ircs'|'itms'|'jar'|'jms'|'keyparc'|'lastfm'|'ldaps'|'magnet'|'maps'|'market'|'message'|'mms'|'ms-help'|'msnim'|'mumble'|'mvn'|'notes'|'oid'|'palm'|'paparazzi'|'platform'|'proxy'|'psyc'|'query'|'res'|'resource'|'rmi'|'rsync'|'rtmp'|'secondlife'|'sftp'|'sgn'|'skype'|'smb'|'soldat'|'spotify'|'ssh'|'steam'|'svn'|'teamspeak'|'things'|'udp'|'unreal'|'ut2004'|'ventrilo'|'view-source'|'webcal'|'wtai'|'wyciwyg'|'xfire'|'xri'|'ymsgr'; +*/ + +// 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; +/*!re2c + scheme [:][^\x00-\x20<>]*[>] { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+ + [@] + [a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])? + ([.][a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)* + [>] { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + htmltag { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [<] [/] blocktagname (spacechar | [>]) { return (p - start); } + [<] blocktagname (spacechar | [/>]) { return (p - start); } + [<] [!?] { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [ \n]* [<] ([^<>\n\\\x00] | escaped_char | [\\])* [>] { return (p - start); } + [ \n]* (reg_char+ | escaped_char | in_parens_nosp)* { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + ["] (escaped_char|[^"\x00])* ["] { return (p - start); } + ['] (escaped_char|[^'\x00])* ['] { return (p - start); } + [(] (escaped_char|[^)\x00])* [)] { return (p - start); } + .? { return 0; } +*/ +} + +// Match space characters, including newlines. +int _scan_spacechars(const unsigned char *p) +{ + const unsigned char *start = p; \ +/*!re2c + [ \t\n]* { return (p - start); } + . { 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; +/*!re2c + [#]{1,6} ([ ]+|[\n]) { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [=]+ [ ]* [\n] { return 1; } + [-]+ [ ]* [\n] { return 2; } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + ([*][ ]*){3,} [ \t]* [\n] { return (p - start); } + ([_][ ]*){3,} [ \t]* [\n] { return (p - start); } + ([-][ ]*){3,} [ \t]* [\n] { return (p - start); } + .? { return 0; } +*/ +} + +// Scan an opening code fence. +int _scan_open_code_fence(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [`]{3,} / [^`\n\x00]*[\n] { return (p - start); } + [~]{3,} / [^~\n\x00]*[\n] { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [`]{3,} / [ \t]*[\n] { return (p - start); } + [~]{3,} / [ \t]*[\n] { return (p - start); } + .? { return 0; } +*/ +} + +// 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; +/*!re2c + [&] ([#] ([Xx][A-Fa-f0-9]{1,8}|[0-9]{1,8}) |[A-Za-z][A-Za-z0-9]{1,31} ) [;] + { return (p - start); } + .? { return 0; } +*/ +} diff --git a/utf8.c b/utf8.c new file mode 100644 index 0000000..d77c5d1 --- /dev/null +++ b/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/utf8.h b/utf8.h new file mode 100644 index 0000000..7df1573 --- /dev/null +++ b/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/xml.c b/xml.c new file mode 100644 index 0000000..f169241 --- /dev/null +++ b/xml.c @@ -0,0 +1,174 @@ +#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, long 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, long options) +{ + char *result; + cmark_strbuf xml = GH_BUF_INIT; + cmark_event_type ev_type; + cmark_node *cur; + struct render_state state = { &xml, 0 }; + + if (options & CMARK_OPT_NORMALIZE) { + cmark_consolidate_text_nodes(root); + } + + 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; +} From b5055f8daafb4ba0bb7b7cfc2c3fd67fa42f3820 Mon Sep 17 00:00:00 2001 From: James Adam Date: Fri, 13 Feb 2015 20:23:58 -0500 Subject: [PATCH 04/26] some cleanup. License updates --- .travis.yml | 7 --- CMakeLists.txt | 149 --------------------------------------------- LICENSE | 111 +++++++++++++++++++++++++++++++++ README.md | 11 +--- cmark_version.h.in | 7 --- config.h.in | 23 ------- libcmark.pc.in | 10 --- 7 files changed, 113 insertions(+), 205 deletions(-) delete mode 100644 CMakeLists.txt delete mode 100644 cmark_version.h.in delete mode 100644 config.h.in delete mode 100644 libcmark.pc.in diff --git a/.travis.yml b/.travis.yml index 9133db9..114b357 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,16 +8,9 @@ before_install: - sudo apt-get update -qq - sudo apt-get install gcc - sudo apt-get install build-essential - - sudo apt-get install cmake - sudo apt-get install python3 - sudo apt-get install re2c - sudo apt-get install pandoc - - git clone --branch 0.17 https://github.com/jgm/cmark ~/cm - - cd ~/cm - - make - - sudo make install - - LD_LIBRARY_PATH=/usr/local/lib - - export LD_LIBRARY_PATH - cd $HOME/gopath/src/github.com/rhinoman/go-commonmark script: - go test -v ./... diff --git a/CMakeLists.txt b/CMakeLists.txt deleted file mode 100644 index 2179c08..0000000 --- a/CMakeLists.txt +++ /dev/null @@ -1,149 +0,0 @@ -cmake_minimum_required(VERSION 2.8) -set(LIBRARY "libcmark") -set(HEADERS - cmark.h - parser.h - buffer.h - node.h - iterator.h - chunk.h - references.h - debug.h - bench.h - utf8.h - scanners.h - inlines.h - html_unescape.h - houdini.h - cmark_ctype.h - ) -set(LIBRARY_SOURCES - cmark.c - node.c - iterator.c - blocks.c - inlines.c - scanners.c - scanners.re - utf8.c - buffer.c - references.c - man.c - xml.c - html.c - html_unescape.gperf - houdini_href_e.c - houdini_html_e.c - houdini_html_u.c - cmark_ctype.c - ${HEADERS} - ) - -set(PROGRAM "cmark") -set(PROGRAM_SOURCES - ${LIBRARY_SOURCES} - main.c - ) - -include_directories(. ${CMAKE_CURRENT_BINARY_DIR}) - -configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmark_version.h.in - ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h) - -configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark.pc.in - ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc @ONLY) -install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc - DESTINATION lib/pkgconfig) - -include (GenerateExportHeader) - -add_executable(${PROGRAM} ${PROGRAM_SOURCES}) -add_compiler_export_flags() - -# Disable the PUBLIC declarations when compiling the executable: -set_target_properties(${PROGRAM} PROPERTIES - COMPILE_FLAGS -DCMARK_STATIC_DEFINE) - -# Check integrity of node structure when compiled as debug: -set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -pg -DCMARK_DEBUG_NODES") -set(CMAKE_LINKER_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -pg") - -set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -pg") -set(CMAKE_LINKER_PROFILE "${CMAKE_LINKER_FLAGS_RELEASE} -pg") - -if (${CMAKE_MAJOR_VERSION} GREATER 1 AND ${CMAKE_MINOR_VERSION} GREATER 8) - set(CMAKE_C_VISIBILITY_PRESET hidden) - set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) -elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") -endif () - -add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES}) -# Include minor version in soname as long as major version is 0. -set_target_properties(${LIBRARY} PROPERTIES - OUTPUT_NAME "cmark" - SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR} - VERSION ${PROJECT_VERSION}) - -set_property(TARGET ${LIBRARY} - APPEND PROPERTY MACOSX_RPATH true) - -generate_export_header(${LIBRARY} - BASE_NAME ${PROJECT_NAME}) - -if (MSVC) - set_property(TARGET ${PROGRAM} - APPEND PROPERTY LINK_FLAGS /INCREMENTAL:NO) -endif(MSVC) - -install(TARGETS ${PROGRAM} ${LIBRARY} - RUNTIME DESTINATION bin - LIBRARY DESTINATION lib - ) - -install(FILES - cmark.h - ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h - ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h - DESTINATION include - ) - -# Feature tests -include(CheckIncludeFile) -include(CheckCSourceCompiles) -include(CheckSymbolExists) -CHECK_INCLUDE_FILE(stdbool.h HAVE_STDBOOL_H) -CHECK_C_SOURCE_COMPILES( - "int main() { __builtin_expect(0,0); return 0; }" - HAVE___BUILTIN_EXPECT) -CHECK_C_SOURCE_COMPILES(" - int f(void) __attribute__ (()); - int main() { return 0; } -" HAVE___ATTRIBUTE__) -CHECK_SYMBOL_EXISTS(va_copy stdarg.h HAVE_VA_COPY) - -CONFIGURE_FILE( - ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in - ${CMAKE_CURRENT_BINARY_DIR}/config.h) - -# Always compile with warnings -if(MSVC) - # Force to always compile with W4 - if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") - string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") - else() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4") - endif() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127 /wd4244 /wd4267 /wd4706 /wd4800 /D_CRT_SECURE_NO_WARNINGS") -elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=c99 -pedantic") -endif() - -# Compile as C++ under MSVC -if(MSVC) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /TP") -endif() - -if($ENV{TIMER}) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DTIMER=1") -endif($ENV{TIMER}) diff --git a/LICENSE b/LICENSE index 9eb4714..94ab5d6 100644 --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,5 @@ +go-commonmark + Copyright (c) 2014 James Adam All rights reserved. @@ -28,3 +30,112 @@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +------- + +cmark + +Copyright (c) 2014, John MacFarlane + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +----- + +houdini.h, houdini_href_e.c, houdini_html_e.c, houdini_html_u.c, +html_unescape.gperf, html_unescape.h + +derive from https://github.com/vmg/houdini (with some modifications) + +Copyright (C) 2012 Vicent Martí + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +----- + +buffer.h, buffer.c, chunk.h + +are derived from code (C) 2012 Github, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +----- + +utf8.c and utf8.c + +are derived from utf8proc +(), +(C) 2009 Public Software Group e. V., Berlin, Germany. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + diff --git a/README.md b/README.md index 837f883..6faffee 100644 --- a/README.md +++ b/README.md @@ -7,24 +7,17 @@ go-commonmark Description ----------- -go-commonmark is a [Go](http://golang.org) (golang) wrapper for the CommonMark C library +go-commonmark is a [Go](http://golang.org) (golang) wrapper for the [CommonMark](http://commonmark.org/) C library Installation ------------ -1.) First, install the CommonMark C library located at: https://github.com/jgm/cmark - -2.) Make sure the directory you install libcmark to is somewhere your system will find it at runtime (i.e., somewhere in your /etc/ld.so.conf: /usr/lib, etc.). Or you can be lazy and add its location to your LD_LIBRARY_PATH. - -3.) Then, just: - ``` go get github.com/rhinoman/go-commonmark ``` -**Note:** The C library is still considered 'pre-release' and is under fairly heavy development. Thus, changes that break this wrapper can happen from time to time, and I'll be playing catch-up when that occurs. It's probably best to use one of the tags with it's corresponding version branch/tag of CommonMark (0.17 is the most recent as of this writing). - +**Note:** The [cmark](https://github.com/jgm/cmark) C reference implementation has been folded into this repository, no need to install it separately. It will be built automagically by cgo. Documentation ------------- diff --git a/cmark_version.h.in b/cmark_version.h.in deleted file mode 100644 index 41de3ac..0000000 --- a/cmark_version.h.in +++ /dev/null @@ -1,7 +0,0 @@ -#ifndef CMARK_VERSION_H -#define CMARK_VERSION_H - -#define CMARK_VERSION ((@PROJECT_VERSION_MAJOR@ << 16) | (@PROJECT_VERSION_MINOR@ << 8) | @PROJECT_VERSION_PATCH@) -#define CMARK_VERSION_STRING "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@" - -#endif diff --git a/config.h.in b/config.h.in deleted file mode 100644 index c1e9597..0000000 --- a/config.h.in +++ /dev/null @@ -1,23 +0,0 @@ -#cmakedefine HAVE_STDBOOL_H - -#ifdef HAVE_STDBOOL_H - #include -#elif !defined(__cplusplus) - typedef char bool; -#endif - -#cmakedefine HAVE___BUILTIN_EXPECT - -#cmakedefine HAVE___ATTRIBUTE__ - -#ifdef HAVE___ATTRIBUTE__ - #define CMARK_ATTRIBUTE(list) __attribute__ (list) -#else - #define CMARK_ATTRIBUTE(list) -#endif - -#cmakedefine HAVE_VA_COPY - -#ifndef HAVE_VA_COPY - #define va_copy(dest, src) ((dest) = (src)) -#endif diff --git a/libcmark.pc.in b/libcmark.pc.in deleted file mode 100644 index 9c3a9a9..0000000 --- a/libcmark.pc.in +++ /dev/null @@ -1,10 +0,0 @@ -prefix=@CMAKE_INSTALL_PREFIX@ -exec_prefix=@CMAKE_INSTALL_PREFIX@ -libdir=@CMAKE_INSTALL_PREFIX@/lib -includedir=@CMAKE_INSTALL_PREFIX@/include - -Name: libcmark -Description: CommonMark parsing, rendering, and manipulation -Version: @PROJECT_VERSION@ -Libs: -L${libdir} -lcmark -Cflags: -I${includedir} From a8ab513ba534721b81d162a769c7db85302ea7af Mon Sep 17 00:00:00 2001 From: James Adam Date: Fri, 13 Feb 2015 20:34:26 -0500 Subject: [PATCH 05/26] adding .gitattribute file --- .gitattributes | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 .gitattributes diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..ab5d2d3 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +*.c linguist-vendored=true +*.h linguist-vendored=true +*.inc linguist-vendored=true +*.gperf linguist-vendored=true +*.re linguist-vendored=true From 69c0fcebc3d15ef0bdbbd11efe5748f57d1fab59 Mon Sep 17 00:00:00 2001 From: James Adam Date: Wed, 4 Mar 2015 18:54:19 -0500 Subject: [PATCH 06/26] Upgraded to cmark 0.18 --- blocks.c | 71 ++++++++++--------- cmark.c | 2 +- cmark.h | 14 ++-- cmark_export.h | 10 ++- cmark_version.h | 4 +- commonmark.go | 13 ++-- commonmark_test.go | 11 ++- html.c | 9 ++- inlines.c | 166 ++++++++++++++++++++++++++++++++++++++------- inlines.h | 2 +- iterator.c | 2 +- man.c | 62 +++++++++++++---- node.c | 6 +- node.go | 7 +- node.h | 15 ++-- parser.h | 1 + scanners.c | 45 ++++++------ xml.c | 8 +-- 18 files changed, 314 insertions(+), 134 deletions(-) diff --git a/blocks.c b/blocks.c index 806f7a6..fc9cbb4 100644 --- a/blocks.c +++ b/blocks.c @@ -43,14 +43,14 @@ static cmark_node* make_block(cmark_node_type tag, int start_line, int start_col return e; } -// Create a root document cmark_node. +// 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() +cmark_parser *cmark_parser_new(int options) { cmark_parser *parser = (cmark_parser*)malloc(sizeof(cmark_parser)); cmark_node *document = make_document(); @@ -66,6 +66,7 @@ cmark_parser *cmark_parser_new() parser->curline = line; parser->last_line_length = 0; parser->linebuf = buf; + parser->options = options; return parser; } @@ -143,7 +144,7 @@ static void remove_trailing_blank_lines(cmark_strbuf *ln) cmark_strbuf_truncate(ln, i); } -// Check to see if a cmark_node ends with a blank line, descending +// 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) { @@ -287,14 +288,14 @@ finalize(cmark_parser *parser, cmark_node* b) return parent; } -// Add a cmark_node as child of another. Return pointer to child. +// 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 cmark_node that can accept this child, - // then back up til we hit a cmark_node that can. + // 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); } @@ -314,9 +315,9 @@ static cmark_node* add_child(cmark_parser *parser, cmark_node* parent, } -// Walk through cmark_node and all children, recursively, parsing +// 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) +static void process_inlines(cmark_node* root, cmark_reference_map *refmap, int options) { cmark_iter *iter = cmark_iter_new(root); cmark_node *cur; @@ -327,7 +328,7 @@ static void process_inlines(cmark_node* root, cmark_reference_map *refmap) if (ev_type == CMARK_EVENT_ENTER) { if (cur->type == NODE_PARAGRAPH || cur->type == NODE_HEADER) { - cmark_parse_inlines(cur, refmap); + cmark_parse_inlines(cur, refmap, options); } } } @@ -416,15 +417,15 @@ static cmark_node *finalize_document(cmark_parser *parser) } finalize(parser, parser->root); - process_inlines(parser->root, parser->refmap); + process_inlines(parser->root, parser->refmap, parser->options); return parser->root; } -cmark_node *cmark_parse_file(FILE *f) +cmark_node *cmark_parse_file(FILE *f, int options) { unsigned char buffer[4096]; - cmark_parser *parser = cmark_parser_new(); + cmark_parser *parser = cmark_parser_new(options); size_t bytes; cmark_node *document; @@ -441,9 +442,9 @@ cmark_node *cmark_parse_file(FILE *f) return document; } -cmark_node *cmark_parse_document(const char *buffer, size_t len) +cmark_node *cmark_parse_document(const char *buffer, size_t len, int options) { - cmark_parser *parser = cmark_parser_new(); + cmark_parser *parser = cmark_parser_new(options); cmark_node *document; S_parser_feed(parser, (const unsigned char *)buffer, len, true); @@ -522,11 +523,11 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) cmark_list *data = NULL; bool all_matched = true; cmark_node* container; - cmark_node* cur = parser->current; bool blank = false; int first_nonspace; int indent; cmark_chunk input; + bool maybe_lazy; utf8proc_detab(parser->curline, buffer, bytes); @@ -543,8 +544,8 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) parser->line_number++; - // for each containing cmark_node, try to parse the associated line start. - // bail out on failure: container will point to the last matching cmark_node. + // 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; @@ -592,10 +593,10 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) } else { // fenced matched = 0; if (indent <= 3 && - (peek_at(&input, first_nonspace) == - container->as.code.fence_char)) { + (peek_at(&input, first_nonspace) == + container->as.code.fence_char)) { matched = scan_close_code_fence(&input, - first_nonspace); + first_nonspace); } if (matched >= container->as.code.fence_length) { // closing fence - and since we're at @@ -608,7 +609,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) // skip opt. spaces of fence offset i = container->as.code.fence_offset; while (i > 0 && - peek_at(&input, offset) == ' ') { + peek_at(&input, offset) == ' ') { offset++; i--; } @@ -634,7 +635,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) } if (!all_matched) { - container = container->parent; // back up to last matching cmark_node + container = container->parent; // back up to last matching node break; } } @@ -646,7 +647,8 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) break_out_of_lists(parser, &container); } - // unless last matched container is code cmark_node, try new container starts: + maybe_lazy = parser->current->type == NODE_PARAGRAPH; + // try new container starts: while (container->type != NODE_CODE_BLOCK && container->type != NODE_HTML) { @@ -658,7 +660,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) blank = peek_at(&input, first_nonspace) == '\n'; if (indent >= CODE_INDENT) { - if (cur->type != NODE_PARAGRAPH && !blank) { + if (!maybe_lazy && !blank) { offset += CODE_INDENT; container = add_child(parser, container, NODE_CODE_BLOCK, offset + 1); container->as.code.fenced = false; @@ -773,6 +775,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) // 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 @@ -808,20 +811,20 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) cont = cont->parent; } - if (cur != last_matched_container && + if (parser->current != last_matched_container && container == last_matched_container && !blank && - cur->type == NODE_PARAGRAPH && - cmark_strbuf_len(&cur->string_content) > 0) { + parser->current->type == NODE_PARAGRAPH && + cmark_strbuf_len(&parser->current->string_content) > 0) { - add_line(cur, &input, offset); + add_line(parser->current, &input, offset); } else { // not a lazy continuation // finalize any blocks that were not matched and set cur to container: - while (cur != last_matched_container) { - cur = finalize(parser, cur); - assert(cur != NULL); + while (parser->current != last_matched_container) { + parser->current = finalize(parser, parser->current); + assert(parser->current != NULL); } if (container->type == NODE_CODE_BLOCK || @@ -868,7 +871,13 @@ cmark_node *cmark_parser_finish(cmark_parser *parser) } 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(); diff --git a/cmark.c b/cmark.c index 2ec9be9..d6e9278 100644 --- a/cmark.c +++ b/cmark.c @@ -14,7 +14,7 @@ char *cmark_markdown_to_html(const char *text, int len) cmark_node *doc; char *result; - doc = cmark_parse_document(text, len); + doc = cmark_parse_document(text, len, CMARK_OPT_DEFAULT); result = cmark_render_html(doc, CMARK_OPT_DEFAULT); cmark_node_free(doc); diff --git a/cmark.h b/cmark.h index 64d8d47..69c2eaa 100644 --- a/cmark.h +++ b/cmark.h @@ -452,13 +452,13 @@ cmark_node *cmark_parser_finish(cmark_parser *parser); * Returns a pointer to a tree of nodes. */ CMARK_EXPORT -cmark_node *cmark_parse_document(const char *buffer, size_t len); +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); +cmark_node *cmark_parse_file(FILE *f, int options); /** * ## Rendering @@ -467,18 +467,18 @@ cmark_node *cmark_parse_file(FILE *f); /** Render a 'node' tree as XML. */ CMARK_EXPORT -char *cmark_render_xml(cmark_node *root, long options); +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, long options); +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, long options); +char *cmark_render_man(cmark_node *root, int options); /** Default writer options. */ @@ -496,6 +496,10 @@ char *cmark_render_man(cmark_node *root, long options); */ #define CMARK_OPT_NORMALIZE 4 +/** Convert straight quotes to curly, --- to em dashes, -- to en dashes. + */ +#define CMARK_OPT_SMART 8 + /** * ## Version information */ diff --git a/cmark_export.h b/cmark_export.h index 1102c36..3f437dc 100644 --- a/cmark_export.h +++ b/cmark_export.h @@ -23,8 +23,14 @@ #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 + +#ifndef CMARK_DEPRECATED_EXPORT +# define CMARK_DEPRECATED_EXPORT CMARK_EXPORT CMARK_DEPRECATED +#endif + +#ifndef CMARK_DEPRECATED_NO_EXPORT +# define CMARK_DEPRECATED_NO_EXPORT CMARK_NO_EXPORT CMARK_DEPRECATED #endif #define DEFINE_NO_DEPRECATED 0 diff --git a/cmark_version.h b/cmark_version.h index f86b6aa..09b1b82 100644 --- a/cmark_version.h +++ b/cmark_version.h @@ -1,7 +1,7 @@ #ifndef CMARK_VERSION_H #define CMARK_VERSION_H -#define CMARK_VERSION ((0 << 16) | (17 << 8) | 0) -#define CMARK_VERSION_STRING "0.17.0" +#define CMARK_VERSION ((0 << 16) | (18 << 8) | 0) +#define CMARK_VERSION_STRING "0.18.0" #endif diff --git a/commonmark.go b/commonmark.go index 987b39a..afba48b 100644 --- a/commonmark.go +++ b/commonmark.go @@ -75,7 +75,7 @@ func (cmp *CMarkParser) Free() { } // Generates a document directly from a string -func ParseDocument(buffer string) *CMarkNode { +func ParseDocument(buffer string, options int) *CMarkNode { if !strings.HasSuffix(buffer, "\n") { buffer += "\n" } @@ -83,7 +83,7 @@ func ParseDocument(buffer string) *CMarkNode { Clen := C.size_t(len(buffer)) defer C.free(unsafe.Pointer(Cstr)) n := &CMarkNode{ - node: C.cmark_parse_document(Cstr, Clen), + node: C.cmark_parse_document(Cstr, Clen, C.int(options)), } runtime.SetFinalizer(n, (*CMarkNode).Free) return n @@ -91,7 +91,7 @@ func ParseDocument(buffer string) *CMarkNode { // Parses a file and returns a CMarkNode // Returns an error if the file can't be opened -func ParseFile(filename string) (*CMarkNode, error) { +func ParseFile(filename string, options int) (*CMarkNode, error) { fname := C.CString(filename) access := C.CString("r") defer C.free(unsafe.Pointer(fname)) @@ -102,8 +102,13 @@ func ParseFile(filename string) (*CMarkNode, error) { } defer C.fclose(file) n := &CMarkNode{ - node: C.cmark_parse_file(file), + node: C.cmark_parse_file(file, C.int(options)), } runtime.SetFinalizer(n, (*CMarkNode).Free) return n, nil } + +//Version information +func CMarkVersion() int { + return int(C.cmark_version) +} diff --git a/commonmark_test.go b/commonmark_test.go index 985e81d..d590420 100644 --- a/commonmark_test.go +++ b/commonmark_test.go @@ -14,6 +14,11 @@ func TestMd2Html(t *testing.T) { t.Logf("Html Text: %v", htmlText) } +func TestCMarkVersion(t *testing.T) { + version := commonmark.CMarkVersion() + t.Logf("\nVersion: %v", version) +} + func TestCMarkParser(t *testing.T) { parser := commonmark.NewCmarkParser() if parser == nil { @@ -36,7 +41,7 @@ func TestCMarkParser(t *testing.T) { document.RenderXML(commonmark.CMARK_OPT_DEFAULT) document.Free() - document2 := commonmark.ParseDocument("Foobar\n------") + document2 := commonmark.ParseDocument("Foobar\n------", 0) htmlText = document2.RenderHtml(commonmark.CMARK_OPT_DEFAULT) document2.RenderXML(commonmark.CMARK_OPT_DEFAULT) if htmlText != "

Foobar

\n" { @@ -48,7 +53,7 @@ func TestCMarkParser(t *testing.T) { } func TestParseFile(t *testing.T) { - node, err := commonmark.ParseFile("test_data/test_file.md") + node, err := commonmark.ParseFile("test_data/test_file.md", 0) if err != nil { t.Error(err) } @@ -62,7 +67,7 @@ func TestParseFile(t *testing.T) { t.Logf("Html Text: %v", htmlText) node.Free() //try to parse a non-existent file - eNode, err := commonmark.ParseFile("notafile.md") + eNode, err := commonmark.ParseFile("notafile.md", 0) if err == nil { t.Errorf("Should have been an error!") } diff --git a/html.c b/html.c index 8ccb495..f1b88fa 100644 --- a/html.c +++ b/html.c @@ -39,7 +39,7 @@ struct render_state { }; static void -S_render_sourcepos(cmark_node *node, cmark_strbuf *html, long options) +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\"", @@ -52,7 +52,7 @@ S_render_sourcepos(cmark_node *node, cmark_strbuf *html, long options) static int S_render_node(cmark_node *node, cmark_event_type ev_type, - struct render_state *state, long options) + struct render_state *state, int options) { cmark_node *parent; cmark_node *grandparent; @@ -217,8 +217,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, break; case CMARK_NODE_TEXT: - escape_html(html, node->as.literal.data, - node->as.literal.len); + escape_html(html, node->as.literal.data, node->as.literal.len); break; case CMARK_NODE_LINEBREAK: @@ -303,7 +302,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, return 1; } -char *cmark_render_html(cmark_node *root, long options) +char *cmark_render_html(cmark_node *root, int options) { char *result; cmark_strbuf html = GH_BUF_INIT; diff --git a/inlines.c b/inlines.c index 2c12408..e2641a7 100644 --- a/inlines.c +++ b/inlines.c @@ -14,6 +14,15 @@ #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) @@ -27,8 +36,8 @@ typedef struct delimiter { struct delimiter *previous; struct delimiter *next; cmark_node *inl_text; - unsigned char delim_char; int position; + unsigned char delim_char; bool can_open; bool can_close; bool active; @@ -44,11 +53,11 @@ typedef struct { static delimiter* S_insert_emph(subject *subj, delimiter *opener, delimiter *closer); -static int parse_inline(subject* subj, cmark_node * parent); +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); +static int subject_find_special_char(subject *subj, int options); static unsigned char *cmark_clean_autolink(cmark_chunk *url, int is_email) { @@ -268,9 +277,14 @@ scan_delims(subject* subj, unsigned char c, bool * can_open, bool * can_close) } } - while (peek_char(subj) == c) { + if (c == '\'' || c == '"') { numdelims++; - advance(subj); + 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, @@ -279,16 +293,19 @@ scan_delims(subject* subj, unsigned char c, bool * can_open, bool * can_close) 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)); + !(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)); + !(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; @@ -349,25 +366,68 @@ static void push_delimiter(subject *subj, unsigned char c, bool can_open, subj->last_delim = delim; } -// Parse strong/emph or a fallback. -// Assumes the subject has '_' or '*' at the current position. -static cmark_node* handle_strong_emph(subject* subj, unsigned char c) +// 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); - inl_text = make_str(cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims)); + 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) { + 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; @@ -381,7 +441,8 @@ static void process_emphasis(subject *subj, delimiter *start_delim) // 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 == '_' || + closer->delim_char == '"' || closer->delim_char == '\'')) { // Now look backwards for first matching opener: opener = closer->previous; while (opener != NULL && opener != start_delim) { @@ -391,9 +452,31 @@ static void process_emphasis(subject *subj, delimiter *start_delim) } opener = opener->previous; } - if (opener != NULL && opener != start_delim) { - closer = S_insert_emph(subj, opener, closer); - } else { + 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 { @@ -843,7 +926,7 @@ static cmark_node* handle_newline(subject *subj) } } -static int subject_find_special_char(subject *subj) +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++; } @@ -878,7 +984,7 @@ static int subject_find_special_char(subject *subj) // 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) +static int parse_inline(subject* subj, cmark_node * parent, int options) { cmark_node* new_inl = NULL; cmark_chunk contents; @@ -906,7 +1012,15 @@ static int parse_inline(subject* subj, cmark_node * parent) break; case '*': case '_': - new_inl = handle_strong_emph(subj, c); + 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); @@ -927,7 +1041,7 @@ static int parse_inline(subject* subj, cmark_node * parent) } break; default: - endpos = subject_find_special_char(subj); + endpos = subject_find_special_char(subj, options); contents = cmark_chunk_dup(&subj->input, subj->pos, endpos - subj->pos); subj->pos = endpos; @@ -946,12 +1060,12 @@ static int parse_inline(subject* subj, cmark_node * parent) } // Parse inlines from parent's string_content, adding as children of parent. -extern void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap) +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)) ; + while (!is_eof(&subj) && parse_inline(&subj, parent, options)) ; process_emphasis(&subj, NULL); } diff --git a/inlines.h b/inlines.h index d2ccfb4..9e56790 100644 --- a/inlines.h +++ b/inlines.h @@ -8,7 +8,7 @@ extern "C" { 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); +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); diff --git a/iterator.c b/iterator.c index eb7b49c..c6faf99 100644 --- a/iterator.c +++ b/iterator.c @@ -132,7 +132,7 @@ void cmark_consolidate_text_nodes(cmark_node *root) cmark_strbuf_puts(&buf, cmark_node_get_literal(cur)); tmp = cur->next; while (tmp && tmp->type == CMARK_NODE_TEXT) { - cmark_iter_get_node(iter); // advance pointer + cmark_iter_next(iter); // advance pointer cmark_strbuf_puts(&buf, cmark_node_get_literal(tmp)); next = tmp->next; cmark_node_free(tmp); diff --git a/man.c b/man.c index f57eb75..27cd2e4 100644 --- a/man.c +++ b/man.c @@ -7,29 +7,63 @@ #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) { - int i; - unsigned char c; + int32_t c; + int i = 0; + int len; bool beginLine = true; - for (i = 0; i < length; i++) { - c = source[i]; - if (c == '.' && beginLine) { - cmark_strbuf_puts(dest, "\\&."); - } else if (c == '\'' && beginLine) { - cmark_strbuf_puts(dest, "\\&'"); - } else if (c == '-') { + 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, "\\-"); - } else if (c == '\\') { + break; + case 92: cmark_strbuf_puts(dest, "\\e"); - } else { - cmark_strbuf_putc(dest, source[i]); + 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 == '\n'); + beginLine = (c == 10); + i += len; } } @@ -228,7 +262,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, return 1; } -char *cmark_render_man(cmark_node *root, long options) +char *cmark_render_man(cmark_node *root, int options) { char *result; cmark_strbuf man = GH_BUF_INIT; diff --git a/node.c b/node.c index fe3dac3..466b0a1 100644 --- a/node.c +++ b/node.c @@ -263,7 +263,8 @@ cmark_node_last_child(cmark_node *node) } void* -cmark_node_get_user_data(cmark_node *node) { +cmark_node_get_user_data(cmark_node *node) +{ if (node == NULL) { return NULL; } else { @@ -272,7 +273,8 @@ cmark_node_get_user_data(cmark_node *node) { } int -cmark_node_set_user_data(cmark_node *node, void *user_data) { +cmark_node_set_user_data(cmark_node *node, void *user_data) +{ if (node == NULL) { return 0; } diff --git a/node.go b/node.go index 8183af8..190a498 100644 --- a/node.go +++ b/node.go @@ -67,6 +67,7 @@ const CMARK_OPT_DEFAULT = 0 const CMARK_OPT_SOURCEPOS = 1 const CMARK_OPT_HARDBREAKS = 2 const CMARK_OPT_NORMALIZE = 4 +const CMARK_OPT_SMART = 8 //converts C int return codes to True/False :) func success(code C.int) bool { @@ -94,7 +95,7 @@ func NewCMarkNode(nt NodeType) *CMarkNode { // print structure as XML func (node *CMarkNode) RenderXML(options int) string { - result := C.cmark_render_xml(node.node, C.long(options)) + result := C.cmark_render_xml(node.node, C.int(options)) defer C.free(unsafe.Pointer(result)) return C.GoString(result) } @@ -102,7 +103,7 @@ func (node *CMarkNode) RenderXML(options int) string { // Renders the document as HTML. // Returns an HTML string. func (node *CMarkNode) RenderHtml(options int) string { - result := C.cmark_render_html(node.node, C.long(options)) + result := C.cmark_render_html(node.node, C.int(options)) defer C.free(unsafe.Pointer(result)) return C.GoString(result) } @@ -110,7 +111,7 @@ func (node *CMarkNode) RenderHtml(options int) string { // Renders the document as a groff man page, // without the header func (node *CMarkNode) RenderMan(options int) string { - result := C.cmark_render_man(node.node, C.long(options)) + result := C.cmark_render_man(node.node, C.int(options)) defer C.free(unsafe.Pointer(result)) return C.GoString(result) } diff --git a/node.h b/node.h index 74eddd4..7a45d42 100644 --- a/node.h +++ b/node.h @@ -6,6 +6,7 @@ extern "C" { #endif #include +#include #include "cmark.h" #include "buffer.h" @@ -22,12 +23,13 @@ typedef struct { } cmark_list; typedef struct { - bool fenced; - int fence_length; - int fence_offset; - unsigned char fence_char; 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 { @@ -41,8 +43,6 @@ typedef struct { } cmark_link; struct cmark_node { - cmark_node_type type; - struct cmark_node *next; struct cmark_node *prev; struct cmark_node *parent; @@ -55,6 +55,9 @@ struct cmark_node { int start_column; int end_line; int end_column; + + cmark_node_type type; + bool open; bool last_line_blank; diff --git a/parser.h b/parser.h index 3c8def9..cbccae3 100644 --- a/parser.h +++ b/parser.h @@ -19,6 +19,7 @@ struct cmark_parser { cmark_strbuf *curline; int last_line_length; cmark_strbuf *linebuf; + int options; }; #ifdef __cplusplus diff --git a/scanners.c b/scanners.c index 440cf83..4f619e7 100644 --- a/scanners.c +++ b/scanners.c @@ -7914,7 +7914,7 @@ int _scan_html_tag(const unsigned char *p) static const unsigned char yybm[] = { /* table 1 .. 8: 0 */ 0, 230, 230, 230, 230, 230, 230, 230, - 230, 199, 199, 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, @@ -8006,7 +8006,7 @@ int _scan_html_tag(const unsigned char *p) if (yych <= '9') { if (yych <= 0x1F) { if (yych <= 0x08) goto yy748; - if (yych <= '\n') goto yy790; + if (yych <= '\r') goto yy790; goto yy748; } else { if (yych <= ' ') goto yy790; @@ -8174,7 +8174,7 @@ int _scan_html_tag(const unsigned char *p) } if (yych <= 0x1F) { if (yych <= 0x08) goto yy756; - if (yych >= '\v') goto yy756; + if (yych >= 0x0E) goto yy756; } else { if (yych <= ' ') goto yy786; if (yych == '>') goto yy758; @@ -8185,7 +8185,7 @@ int _scan_html_tag(const unsigned char *p) yych = *p; if (yych <= 0x1F) { if (yych <= 0x08) goto yy756; - if (yych <= '\n') goto yy786; + if (yych <= '\r') goto yy786; goto yy756; } else { if (yych <= ' ') goto yy786; @@ -8198,7 +8198,7 @@ int _scan_html_tag(const unsigned char *p) if (yych <= '9') { if (yych <= 0x1F) { if (yych <= 0x08) goto yy756; - if (yych >= '\v') goto yy756; + if (yych >= 0x0E) goto yy756; } else { if (yych <= ' ') goto yy790; if (yych <= '.') goto yy756; @@ -8222,7 +8222,7 @@ int _scan_html_tag(const unsigned char *p) if (yych <= ':') { if (yych <= ' ') { if (yych <= 0x08) goto yy756; - if (yych <= '\n') goto yy790; + if (yych <= '\r') goto yy790; if (yych <= 0x1F) goto yy756; goto yy790; } else { @@ -8257,7 +8257,7 @@ int _scan_html_tag(const unsigned char *p) goto yy793; } if (yych <= '.') { - if (yych <= '\n') { + if (yych <= '\r') { if (yych <= 0x08) goto yy756; } else { if (yych != ' ') goto yy756; @@ -8278,7 +8278,7 @@ int _scan_html_tag(const unsigned char *p) if (yych <= '<') { if (yych <= ' ') { if (yych <= 0x08) goto yy756; - if (yych <= '\n') goto yy795; + if (yych <= '\r') goto yy795; if (yych <= 0x1F) goto yy756; goto yy795; } else { @@ -8363,7 +8363,7 @@ int _scan_html_tag(const unsigned char *p) yych = *p; if (yych <= ' ') { if (yych <= 0x08) goto yy756; - if (yych <= '\n') goto yy790; + if (yych <= '\r') goto yy790; if (yych <= 0x1F) goto yy756; goto yy790; } else { @@ -8384,7 +8384,7 @@ int _scan_html_tag(const unsigned char *p) if (yych <= 0x00) goto yy756; goto yy799; } else { - if (yych <= '\n') goto yy806; + if (yych <= '\r') goto yy806; if (yych <= 0x1F) goto yy799; goto yy806; } @@ -8421,7 +8421,7 @@ int _scan_html_tag(const unsigned char *p) yych = *p; if (yych <= '/') { if (yych <= '!') { - if (yych <= '\n') { + if (yych <= '\r') { if (yych <= 0x00) goto yy756; if (yych <= 0x08) goto yy799; } else { @@ -8470,7 +8470,7 @@ int _scan_html_tag(const unsigned char *p) if (yych <= 0x00) goto yy756; goto yy799; } else { - if (yych <= '\n') goto yy810; + if (yych <= '\r') goto yy810; if (yych <= 0x1F) goto yy799; goto yy810; } @@ -8515,7 +8515,7 @@ int _scan_html_tag(const unsigned char *p) if (yych <= 0x00) goto yy756; goto yy799; } else { - if (yych <= '\n') goto yy812; + if (yych <= '\r') goto yy812; if (yych <= 0x1F) goto yy799; goto yy812; } @@ -8620,7 +8620,7 @@ int _scan_html_block_tag(const unsigned char *p) if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) goto yy822; - if (yych <= '\n') goto yy982; + if (yych <= '\r') goto yy982; } else { if (yych <= ' ') goto yy982; if (yych >= '/') goto yy982; @@ -8880,7 +8880,7 @@ int _scan_html_block_tag(const unsigned char *p) yy839: yych = *++p; if (yych <= '=') { - if (yych <= '\n') { + if (yych <= '\r') { if (yych <= 0x08) goto yy822; goto yy859; } else { @@ -9116,7 +9116,7 @@ int _scan_html_block_tag(const unsigned char *p) yych = *++p; if (yych <= 0x1F) { if (yych <= 0x08) goto yy822; - if (yych >= '\v') goto yy822; + if (yych >= 0x0E) goto yy822; } else { if (yych <= ' ') goto yy859; if (yych != '>') goto yy822; @@ -9257,7 +9257,7 @@ int _scan_html_block_tag(const unsigned char *p) yy884: yych = *++p; if (yych <= '=') { - if (yych <= '\n') { + if (yych <= '\r') { if (yych <= 0x08) goto yy822; goto yy859; } else { @@ -9461,7 +9461,7 @@ int _scan_html_block_tag(const unsigned char *p) yy924: yych = *++p; if (yych <= '=') { - if (yych <= '\n') { + if (yych <= '\r') { if (yych <= 0x08) goto yy822; goto yy859; } else { @@ -9729,7 +9729,7 @@ int _scan_html_block_tag(const unsigned char *p) yych = *++p; if (yych <= ' ') { if (yych <= 0x08) goto yy822; - if (yych <= '\n') goto yy982; + if (yych <= '\r') goto yy982; if (yych <= 0x1F) goto yy822; } else { if (yych <= '/') { @@ -9876,7 +9876,7 @@ int _scan_html_block_tag(const unsigned char *p) if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) goto yy822; - if (yych <= '\n') goto yy982; + if (yych <= '\r') goto yy982; goto yy822; } else { if (yych <= ' ') goto yy982; @@ -10082,7 +10082,7 @@ int _scan_html_block_tag(const unsigned char *p) if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) goto yy822; - if (yych <= '\n') goto yy982; + if (yych <= '\r') goto yy982; goto yy822; } else { if (yych <= ' ') goto yy982; @@ -10992,7 +10992,7 @@ int _scan_spacechars(const unsigned char *p) unsigned char yych; static const unsigned char yybm[] = { 0, 0, 0, 0, 0, 0, 0, 0, - 0, 128, 128, 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, @@ -11030,6 +11030,7 @@ int _scan_spacechars(const unsigned char *p) if (yych <= '\t') goto yy1171; goto yy1172; } else { + if (yych <= '\r') goto yy1171; if (yych == ' ') goto yy1171; goto yy1174; } diff --git a/xml.c b/xml.c index f169241..845e553 100644 --- a/xml.c +++ b/xml.c @@ -36,7 +36,7 @@ static inline void indent(struct render_state *state) static int S_render_node(cmark_node *node, cmark_event_type ev_type, - struct render_state *state, long options) + struct render_state *state, int options) { cmark_strbuf *xml = state->xml; bool literal = false; @@ -145,7 +145,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, return 1; } -char *cmark_render_xml(cmark_node *root, long options) +char *cmark_render_xml(cmark_node *root, int options) { char *result; cmark_strbuf xml = GH_BUF_INIT; @@ -153,10 +153,6 @@ char *cmark_render_xml(cmark_node *root, long options) cmark_node *cur; struct render_state state = { &xml, 0 }; - if (options & CMARK_OPT_NORMALIZE) { - cmark_consolidate_text_nodes(root); - } - cmark_iter *iter = cmark_iter_new(root); cmark_strbuf_puts(state.xml, From ea8db0275f379e9f7627f1bb71d5c4c8ec32ee46 Mon Sep 17 00:00:00 2001 From: James Adam Date: Sat, 14 Mar 2015 16:54:01 -0400 Subject: [PATCH 07/26] updated to cmark 0.18.1 --- cmark.h | 6 +++--- commonmark.go | 4 ++-- commonmark_test.go | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/cmark.h b/cmark.h index 69c2eaa..e29f28a 100644 --- a/cmark.h +++ b/cmark.h @@ -2,8 +2,8 @@ #define CMARK_H #include -#include "cmark_export.h" -#include "cmark_version.h" +#include +#include #ifdef __cplusplus extern "C" { @@ -431,7 +431,7 @@ cmark_consolidate_text_nodes(cmark_node *root); /** Creates a new parser object. */ CMARK_EXPORT -cmark_parser *cmark_parser_new(); +cmark_parser *cmark_parser_new(int options); /** Frees memory allocated for a parser object. */ diff --git a/commonmark.go b/commonmark.go index afba48b..d7a26bb 100644 --- a/commonmark.go +++ b/commonmark.go @@ -39,9 +39,9 @@ type CMarkParser struct { // Retruns a new CMark Parser. // You must call Free() on this thing when you're done with it! // Please. -func NewCmarkParser() *CMarkParser { +func NewCmarkParser(options int) *CMarkParser { p := &CMarkParser{ - parser: C.cmark_parser_new(), + parser: C.cmark_parser_new(C.int(options)), } runtime.SetFinalizer(p, (*CMarkParser).Free) return p diff --git a/commonmark_test.go b/commonmark_test.go index d590420..3c3b332 100644 --- a/commonmark_test.go +++ b/commonmark_test.go @@ -20,7 +20,7 @@ func TestCMarkVersion(t *testing.T) { } func TestCMarkParser(t *testing.T) { - parser := commonmark.NewCmarkParser() + parser := commonmark.NewCmarkParser(commonmark.CMARK_OPT_DEFAULT) if parser == nil { t.Error("Parser is nil!") } From 9e1b63f9bd9a42a59acd36a66267cab3eb2baf99 Mon Sep 17 00:00:00 2001 From: James Adam Date: Sat, 14 Mar 2015 16:57:53 -0400 Subject: [PATCH 08/26] forgot something --- cmark.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cmark.h b/cmark.h index e29f28a..6b34848 100644 --- a/cmark.h +++ b/cmark.h @@ -2,8 +2,8 @@ #define CMARK_H #include -#include -#include +#include "cmark_export.h" +#include "cmark_version.h" #ifdef __cplusplus extern "C" { From db0a7750f433f5e7f3f166260780989669681a0b Mon Sep 17 00:00:00 2001 From: James Adam Date: Tue, 31 Mar 2015 20:16:32 -0400 Subject: [PATCH 09/26] Update to cmark 0.18.2 --- blocks.c | 2 +- buffer.c | 2 +- cmark.c | 6 +- cmark.h | 13 +- commonmark.c | 601 ++ commonmark.go | 4 +- commonmark_test.go | 4 +- node.go | 7 + scanners.c | 16417 +++++++++++++++++++++++++------------------ scanners.h | 2 + scanners.re | 15 +- 11 files changed, 10300 insertions(+), 6773 deletions(-) create mode 100644 commonmark.c diff --git a/blocks.c b/blocks.c index fc9cbb4..a15f819 100644 --- a/blocks.c +++ b/blocks.c @@ -348,7 +348,7 @@ static int parse_list_marker(cmark_chunk *input, int pos, cmark_list **dataptr) startpos = pos; c = peek_at(input, pos); - if ((c == '*' || c == '-' || c == '+') && !scan_hrule(input, pos)) { + if (c == '*' || c == '-' || c == '+') { pos++; if (!cmark_isspace(peek_at(input, pos))) { return 0; diff --git a/buffer.c b/buffer.c index 0df6561..5ec8b49 100644 --- a/buffer.c +++ b/buffer.c @@ -372,7 +372,7 @@ extern void cmark_strbuf_unescape(cmark_strbuf *buf) for (r = 0, w = 0; r < buf->size; ++r) { if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1])) - continue; + r++; buf->ptr[w++] = buf->ptr[r]; } diff --git a/cmark.c b/cmark.c index d6e9278..79ceabf 100644 --- a/cmark.c +++ b/cmark.c @@ -9,14 +9,14 @@ const int cmark_version = CMARK_VERSION; const char cmark_version_string[] = CMARK_VERSION_STRING; -char *cmark_markdown_to_html(const char *text, int len) +char *cmark_markdown_to_html(const char *text, int len, int options) { cmark_node *doc; char *result; - doc = cmark_parse_document(text, len, CMARK_OPT_DEFAULT); + doc = cmark_parse_document(text, len, options); - result = cmark_render_html(doc, CMARK_OPT_DEFAULT); + result = cmark_render_html(doc, options); cmark_node_free(doc); return result; diff --git a/cmark.h b/cmark.h index 6b34848..e41d995 100644 --- a/cmark.h +++ b/cmark.h @@ -24,7 +24,7 @@ extern "C" { * UTF-8-encoded string. */ CMARK_EXPORT -char *cmark_markdown_to_html(const char *text, int len); +char *cmark_markdown_to_html(const char *text, int len, int options); /** ## Node Structure */ @@ -412,11 +412,12 @@ cmark_consolidate_text_nodes(cmark_node *root); * * Simple interface: * - * cmark_node *document = cmark_parse_document("Hello *world*", 12); + * cmark_node *document = cmark_parse_document("Hello *world*", 12, + * CMARK_OPT_DEFAULT); * * Streaming interface: * - * cmark_parser *parser = cmark_parser_new(); + * 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); @@ -480,6 +481,11 @@ char *cmark_render_html(cmark_node *root, int options); CMARK_EXPORT char *cmark_render_man(cmark_node *root, int options); +/** Render a 'node' tree as a commonmark document. + */ +CMARK_EXPORT +char *cmark_render_commonmark(cmark_node *root, int options, int width); + /** Default writer options. */ #define CMARK_OPT_DEFAULT 0 @@ -546,7 +552,6 @@ extern const char cmark_version_string[]; #define NODE_STRONG CMARK_NODE_STRONG #define NODE_LINK CMARK_NODE_LINK #define NODE_IMAGE CMARK_NODE_IMAGE -#define NODE_LINK_LABEL CMARK_NODE_LINK_LABEL #define BULLET_LIST CMARK_BULLET_LIST #define ORDERED_LIST CMARK_ORDERED_LIST #define PERIOD_DELIM CMARK_PERIOD_DELIM diff --git a/commonmark.c b/commonmark.c new file mode 100644 index 0000000..23faa7c --- /dev/null +++ b/commonmark.c @@ -0,0 +1,601 @@ +#include +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "utf8.h" +#include "scanners.h" + +// Functions to convert cmark_nodes to commonmark strings. + +struct render_state { + int options; + cmark_strbuf* buffer; + cmark_strbuf* prefix; + int column; + int width; + int need_cr; + int last_breakable; + bool begin_line; + bool no_wrap; + bool in_tight_list_item; +}; + +static inline void cr(struct render_state *state) +{ + if (state->need_cr < 1) { + state->need_cr = 1; + } +} + +static inline void blankline(struct render_state *state) +{ + if (state->need_cr < 2) { + state->need_cr = 2; + } +} + +typedef enum { + LITERAL, + NORMAL, + TITLE, + URL +} escaping; + +static inline bool +needs_escaping(escaping escape, + int32_t c, + unsigned char next_c, + struct render_state *state) +{ + if (escape == NORMAL) { + return (c == '*' || c == '_' || c == '[' || c == ']' || + c == '<' || c == '>' || c == '\\' || c == '`' || + (c == '&' && isalpha(next_c)) || + (c == '!' && next_c == '[') || + (state->begin_line && + (c == '-' || c == '+' || c == '#' || c == '=')) || + (c == '#' && (isspace(next_c) || next_c == '\0')) || + ((c == '.' || c == ')') && + isdigit(state->buffer->ptr[state->buffer->size - 1]))); + } else if (escape == TITLE) { + return (c == '`' || c == '<' || c == '>' || c == '"' || + c == '\\'); + } else if (escape == URL) { + return (c == '`' || c == '<' || c == '>' || isspace(c) || + c == '\\' || c == ')' || c == '('); + } else { + return false; + } +} + +static inline void out(struct render_state *state, + cmark_chunk str, + bool wrap, + escaping escape) +{ + unsigned char* source = str.data; + int length = str.len; + unsigned char nextc; + int32_t c; + int i = 0; + int len; + cmark_chunk remainder = cmark_chunk_literal(""); + int k = state->buffer->size - 1; + + wrap = wrap && !state->no_wrap; + + if (state->in_tight_list_item && state->need_cr > 1) { + state->need_cr = 1; + } + while (state->need_cr) { + if (k < 0 || state->buffer->ptr[k] == '\n') { + k -= 1; + } else { + cmark_strbuf_putc(state->buffer, '\n'); + if (state->need_cr > 1) { + cmark_strbuf_put(state->buffer, state->prefix->ptr, + state->prefix->size); + } + } + state->column = 0; + state->begin_line = true; + state->need_cr -= 1; + } + + while (i < length) { + if (state->begin_line) { + cmark_strbuf_put(state->buffer, state->prefix->ptr, + state->prefix->size); + // note: this assumes prefix is ascii: + state->column = state->prefix->size; + } + + len = utf8proc_iterate(source + i, length - i, &c); + nextc = source[i + len]; + if (c == 32 && wrap) { + if (!state->begin_line) { + cmark_strbuf_putc(state->buffer, ' '); + state->column += 1; + state->begin_line = false; + state->last_breakable = state->buffer->size - + 1; + // skip following spaces + while (source[i + 1] == ' ') { + i++; + } + } + + } else if (c == 10) { + cmark_strbuf_putc(state->buffer, '\n'); + state->column = 0; + state->begin_line = true; + state->last_breakable = 0; + } else if (needs_escaping(escape, c, nextc, state)) { + if (isspace(c)) { + // use percent encoding for spaces + cmark_strbuf_printf(state->buffer, "%%%2x", c); + state->column += 3; + } else { + cmark_strbuf_putc(state->buffer, '\\'); + utf8proc_encode_char(c, state->buffer); + state->column += 2; + } + state->begin_line = false; + } else { + utf8proc_encode_char(c, state->buffer); + state->column += 1; + state->begin_line = false; + } + + // If adding the character went beyond width, look for an + // earlier place where the line could be broken: + if (state->width > 0 && + state->column > state->width && + !state->begin_line && + state->last_breakable > 0) { + + // copy from last_breakable to remainder + cmark_chunk_set_cstr(&remainder, (char *) state->buffer->ptr + state->last_breakable + 1); + // truncate at last_breakable + cmark_strbuf_truncate(state->buffer, state->last_breakable); + // add newline, prefix, and remainder + cmark_strbuf_putc(state->buffer, '\n'); + cmark_strbuf_put(state->buffer, state->prefix->ptr, + state->prefix->size); + cmark_strbuf_put(state->buffer, remainder.data, remainder.len); + state->column = state->prefix->size + remainder.len; + cmark_chunk_free(&remainder); + state->last_breakable = 0; + state->begin_line = false; + } + + i += len; + } +} + +static void lit(struct render_state *state, char *s, bool wrap) +{ + cmark_chunk str = cmark_chunk_literal(s); + out(state, str, wrap, LITERAL); +} + +static int +longest_backtick_sequence(cmark_chunk *code) +{ + int longest = 0; + int current = 0; + int i = 0; + while (i <= code->len) { + if (code->data[i] == '`') { + current++; + } else { + if (current > longest) { + longest = current; + } + current = 0; + } + i++; + } + return longest; +} + +static int +shortest_unused_backtick_sequence(cmark_chunk *code) +{ + int32_t used = 1; + int current = 0; + int i = 0; + while (i <= code->len) { + if (code->data[i] == '`') { + current++; + } else { + if (current) { + used |= (1 << current); + } + current = 0; + } + i++; + } + // return number of first bit that is 0: + i = 0; + while (used & 1) { + used = used >> 1; + i++; + } + return i; +} + +static bool +is_autolink(cmark_node *node) +{ + const char *title; + const char *url; + + if (node->type != CMARK_NODE_LINK) { + return false; + } + + url = cmark_node_get_url(node); + if (url == NULL || + _scan_scheme((unsigned char *)url) == 0) { + return false; + } + + title = cmark_node_get_title(node); + // if it has a title, we can't treat it as an autolink: + if (title != NULL && strlen(title) > 0) { + return false; + } + cmark_consolidate_text_nodes(node); + return (strncmp(url, + (char*)node->as.literal.data, + node->as.literal.len) == 0); +} + +// if node is a block node, returns node. +// otherwise returns first block-level node that is an ancestor of node. +static cmark_node* +get_containing_block(cmark_node *node) +{ + while (node && + (node->type < CMARK_NODE_FIRST_BLOCK || + node->type > CMARK_NODE_LAST_BLOCK)) { + node = node->parent; + } + return node; +} + +static int +S_render_node(cmark_node *node, cmark_event_type ev_type, + struct render_state *state) +{ + cmark_node *tmp; + cmark_chunk *code; + int list_number; + cmark_delim_type list_delim; + int numticks; + int i; + bool entering = (ev_type == CMARK_EVENT_ENTER); + const char *info; + const char *title; + char listmarker[64]; + char *emph_delim; + int marker_width; + + // Don't adjust tight list status til we've started the list. + // Otherwise we loose the blank line between a paragraph and + // a following list. + if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && + entering)) { + tmp = get_containing_block(node); + state->in_tight_list_item = + (tmp->type == CMARK_NODE_ITEM && + cmark_node_get_list_tight(tmp->parent)) || + (tmp && + tmp->parent && + tmp->parent->type == CMARK_NODE_ITEM && + cmark_node_get_list_tight(tmp->parent->parent)); + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + if (!entering) { + cmark_strbuf_putc(state->buffer, '\n'); + } + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + lit(state, "> ", false); + cmark_strbuf_puts(state->prefix, "> "); + } else { + cmark_strbuf_truncate(state->prefix, + state->prefix->size - 2); + blankline(state); + } + break; + + case CMARK_NODE_LIST: + if (!entering && node->next && + (node->next->type == CMARK_NODE_CODE_BLOCK || + node->next->type == CMARK_NODE_LIST)) { + // this ensures 2 blank lines after list, + // if before code block or list: + lit(state, "\n", false); + state->need_cr = 0; + } + break; + + case CMARK_NODE_ITEM: + if (cmark_node_get_list_type(node->parent) == + CMARK_BULLET_LIST) { + marker_width = 2; + } else { + list_number = cmark_node_get_list_start(node->parent); + list_delim = cmark_node_get_list_delim(node->parent); + tmp = node; + while (tmp->prev) { + tmp = tmp->prev; + list_number += 1; + } + // we ensure a width of at least 4 so + // we get nice transition from single digits + // to double + snprintf(listmarker, 63, "%d%s%s", list_number, + list_delim == CMARK_PAREN_DELIM ? + ")" : ".", + list_number < 10 ? " " : " "); + marker_width = strlen(listmarker); + } + if (entering) { + if (cmark_node_get_list_type(node->parent) == + CMARK_BULLET_LIST) { + lit(state, "* ", false); + cmark_strbuf_puts(state->prefix, " "); + } else { + lit(state, listmarker, false); + for (i=marker_width; i--;) { + cmark_strbuf_putc(state->prefix, ' '); + } + } + } else { + cmark_strbuf_truncate(state->prefix, + state->prefix->size - + marker_width); + cr(state); + } + break; + + case CMARK_NODE_HEADER: + if (entering) { + for (int i = cmark_node_get_header_level(node); i > 0; i--) { + lit(state, "#", false); + } + lit(state, " ", false); + state->no_wrap = true; + } else { + state->no_wrap = false; + blankline(state); + } + break; + + case CMARK_NODE_CODE_BLOCK: + blankline(state); + info = cmark_node_get_fence_info(node); + code = &node->as.code.literal; + // use indented form if no info, and code doesn't + // begin or end with a blank line, and code isn't + // first thing in a list item + if ((info == NULL || strlen(info) == 0) && + (code->len > 2 && + !isspace(code->data[0]) && + !(isspace(code->data[code->len - 1]) && + isspace(code->data[code->len - 2]))) && + !(node->prev == NULL && node->parent && + node->parent->type == CMARK_NODE_ITEM)) { + lit(state, " ", false); + cmark_strbuf_puts(state->prefix, " "); + out(state, node->as.code.literal, false, LITERAL); + cmark_strbuf_truncate(state->prefix, + state->prefix->size - 4); + } else { + numticks = longest_backtick_sequence(code) + 1; + if (numticks < 3) { + numticks = 3; + } + for (i = 0; i < numticks; i++) { + lit(state, "`", false); + } + lit(state, " ", false); + out(state, cmark_chunk_literal(info), false, LITERAL); + cr(state); + out(state, node->as.code.literal, false, LITERAL); + cr(state); + for (i = 0; i < numticks; i++) { + lit(state, "`", false); + } + } + blankline(state); + break; + + case CMARK_NODE_HTML: + blankline(state); + out(state, node->as.literal, false, LITERAL); + blankline(state); + break; + + case CMARK_NODE_HRULE: + blankline(state); + lit(state, "-----", false); + blankline(state); + break; + + case CMARK_NODE_PARAGRAPH: + if (!entering) { + blankline(state); + } + break; + + case CMARK_NODE_TEXT: + out(state, node->as.literal, true, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + if (!(CMARK_OPT_HARDBREAKS & state->options)) { + lit(state, "\\", false); + } + cr(state); + break; + + case CMARK_NODE_SOFTBREAK: + if (state->width == 0) { + cr(state); + } else { + lit(state, " ", true); + } + break; + + case CMARK_NODE_CODE: + code = &node->as.literal; + numticks = shortest_unused_backtick_sequence(code); + for (i = 0; i < numticks; i++) { + lit(state, "`", false); + } + if (code->len == 0 || code->data[0] == '`') { + lit(state, " ", false); + } + out(state, node->as.literal, true, LITERAL); + if (code->len == 0 || code->data[code->len - 1] == '`') { + lit(state, " ", false); + } + for (i = 0; i < numticks; i++) { + lit(state, "`", false); + } + break; + + case CMARK_NODE_INLINE_HTML: + out(state, node->as.literal, false, LITERAL); + break; + + case CMARK_NODE_STRONG: + if (entering) { + lit(state, "**", false); + } else { + lit(state, "**", false); + } + break; + + case CMARK_NODE_EMPH: + // If we have EMPH(EMPH(x)), we need to use *_x_* + // because **x** is STRONG(x): + if (node->parent && node->parent->type == CMARK_NODE_EMPH && + node->next == NULL && node->prev == NULL) { + emph_delim = "_"; + } else { + emph_delim = "*"; + } + if (entering) { + lit(state, emph_delim, false); + } else { + lit(state, emph_delim, false); + } + break; + + case CMARK_NODE_LINK: + if (is_autolink(node)) { + if (entering) { + lit(state, "<", false); + if (strncmp(cmark_node_get_url(node), + "mailto:", 7) == 0) { + lit(state, + (char *)cmark_node_get_url(node) + 7, + false); + } else { + lit(state, + (char *)cmark_node_get_url(node), + false); + } + lit(state, ">", false); + // return signal to skip contents of node... + return 0; + } + } else { + if (entering) { + lit(state, "[", false); + } else { + lit(state, "](", false); + out(state, + cmark_chunk_literal(cmark_node_get_url(node)), + false, URL); + title = cmark_node_get_title(node); + if (title && strlen(title) > 0) { + lit(state, " \"", true); + out(state, cmark_chunk_literal(title), + false, TITLE); + lit(state, "\"", false); + } + lit(state, ")", false); + } + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + lit(state, "![", false); + } else { + lit(state, "](", false); + out(state, cmark_chunk_literal(cmark_node_get_url(node)), false, URL); + title = cmark_node_get_title(node); + if (title && strlen(title) > 0) { + lit(state, " \"", true); + out(state, cmark_chunk_literal(title), false, TITLE); + lit(state, "\"", false); + } + lit(state, ")", false); + } + break; + + default: + assert(false); + break; + } + + return 1; +} + +char *cmark_render_commonmark(cmark_node *root, int options, int width) +{ + char *result; + cmark_strbuf commonmark = GH_BUF_INIT; + cmark_strbuf prefix = GH_BUF_INIT; + if (CMARK_OPT_HARDBREAKS & options) { + width = 0; + } + struct render_state state = + { options, &commonmark, &prefix, 0, width, + 0, 0, true, false, false}; + cmark_node *cur; + cmark_event_type ev_type; + cmark_iter *iter = cmark_iter_new(root); + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + if (!S_render_node(cur, ev_type, &state)) { + // a false value causes us to skip processing + // the node's contents. this is used for + // autolinks. + cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT); + } + } + result = (char *)cmark_strbuf_detach(&commonmark); + + cmark_strbuf_free(&prefix); + cmark_iter_free(iter); + return result; +} diff --git a/commonmark.go b/commonmark.go index d7a26bb..df479ed 100644 --- a/commonmark.go +++ b/commonmark.go @@ -18,7 +18,7 @@ import ( // Converts Markdo--, er, CommonMark text to Html. // Parameter mdtext contains CommonMark text. // The return value is the HTML string -func Md2Html(mdtext string) string { +func Md2Html(mdtext string, options int) string { //The call to cmark will barf if the input string doesn't end with a newline if !strings.HasSuffix(mdtext, "\n") { mdtext += "\n" @@ -26,7 +26,7 @@ func Md2Html(mdtext string) string { mdCstr := C.CString(mdtext) strLen := C.int(len(mdtext)) defer C.free(unsafe.Pointer(mdCstr)) - htmlString := C.cmark_markdown_to_html(mdCstr, strLen) + htmlString := C.cmark_markdown_to_html(mdCstr, strLen, C.int(options)) defer C.free(unsafe.Pointer(htmlString)) return C.GoString(htmlString) } diff --git a/commonmark_test.go b/commonmark_test.go index 3c3b332..de7189d 100644 --- a/commonmark_test.go +++ b/commonmark_test.go @@ -7,7 +7,7 @@ import ( ) func TestMd2Html(t *testing.T) { - htmlText := commonmark.Md2Html("Boo\n===") + htmlText := commonmark.Md2Html("Boo\n===", 0) if htmlText != "

Boo

\n" { t.Errorf("Html text is not as expected :(") } @@ -137,6 +137,8 @@ func TestCMarkNodeOps(t *testing.T) { } manStr := root.RenderMan(commonmark.CMARK_OPT_DEFAULT) t.Logf("\nMAN: %v", manStr) + cmStr := root.RenderCMark(commonmark.CMARK_OPT_DEFAULT, 0) + t.Logf("\nCMARK: %v", cmStr) root.ConsolidateTextNodes() t.Logf("\nXML: %v", root.RenderXML(commonmark.CMARK_OPT_DEFAULT)) root.SetNodeUserData("STRING!") diff --git a/node.go b/node.go index 190a498..6453a6b 100644 --- a/node.go +++ b/node.go @@ -116,6 +116,13 @@ func (node *CMarkNode) RenderMan(options int) string { return C.GoString(result) } +// Renders node tree as commonmark text. +func (node *CMarkNode) RenderCMark(options int, width int) string { + result := C.cmark_render_commonmark(node.node, C.int(options), C.int(width)) + defer C.free(unsafe.Pointer(result)) + return C.GoString(result) +} + // Cleanup a node, including any children. // Unlinks a node from the tree and frees it. func (node *CMarkNode) Free() { diff --git a/scanners.c b/scanners.c index 4f619e7..42b9275 100644 --- a/scanners.c +++ b/scanners.c @@ -18,48 +18,14 @@ int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset) -// Try to match URI autolink after first <, returning number of chars matched. -int _scan_autolink_uri(const unsigned char *p) +// Try to match a scheme including colon. +int _scan_scheme(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) { @@ -124,50 +90,50 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy442; + case 'a': goto yy440; case 'H': - case 'h': goto yy441; + case 'h': goto yy439; case 'I': - case 'i': goto yy444; + case 'i': goto yy442; case 'O': - case 'o': goto yy440; + case 'o': goto yy438; case 'R': - case 'r': goto yy443; + case 'r': goto yy441; case 'V': - case 'v': goto yy439; + case 'v': goto yy437; default: goto yy2; } yy4: yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy415; + case 'a': goto yy413; case 'I': - case 'i': goto yy414; + case 'i': goto yy412; case 'L': - case 'l': goto yy412; + case 'l': goto yy410; case 'N': - case 'n': goto yy413; + case 'n': goto yy411; case 'O': - case 'o': goto yy416; + case 'o': goto yy414; case 'T': - case 't': goto yy411; + case 't': goto yy409; case 'V': - case 'v': goto yy410; + case 'v': goto yy408; default: goto yy2; } yy5: yych = *(marker = ++p); if (yych <= 'M') { - if (yych == 'A') goto yy402; + if (yych == 'A') goto yy400; if (yych <= 'L') goto yy2; - goto yy401; + goto yy399; } else { if (yych <= 'a') { if (yych <= '`') goto yy2; - goto yy402; + goto yy400; } else { - if (yych == 'm') goto yy401; + if (yych == 'm') goto yy399; goto yy2; } } @@ -175,21 +141,21 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy383; + case 'a': goto yy381; case 'B': - case 'b': goto yy382; + case 'b': goto yy380; case 'C': - case 'c': goto yy381; + case 'c': goto yy379; case 'D': - case 'd': goto yy380; + case 'd': goto yy378; case 'F': - case 'f': goto yy379; + case 'f': goto yy377; case 'I': - case 'i': goto yy378; + case 'i': goto yy376; case 'P': - case 'p': goto yy377; + case 'p': goto yy375; case 'T': - case 't': goto yy376; + case 't': goto yy374; case 'W': case 'w': goto yy34; default: goto yy2; @@ -198,25 +164,25 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); if (yych <= 'T') { if (yych <= 'E') { - if (yych == 'A') goto yy363; + if (yych == 'A') goto yy361; if (yych <= 'D') goto yy2; - goto yy362; + goto yy360; } else { - if (yych == 'I') goto yy361; + if (yych == 'I') goto yy359; if (yych <= 'S') goto yy2; - goto yy364; + goto yy362; } } else { if (yych <= 'e') { - if (yych == 'a') goto yy363; + if (yych == 'a') goto yy361; if (yych <= 'd') goto yy2; - goto yy362; + goto yy360; } else { if (yych <= 'i') { if (yych <= 'h') goto yy2; - goto yy361; + goto yy359; } else { - if (yych == 't') goto yy364; + if (yych == 't') goto yy362; goto yy2; } } @@ -225,15 +191,15 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'E': - case 'e': goto yy346; + case 'e': goto yy344; case 'G': case 'g': goto yy34; case 'I': - case 'i': goto yy344; + case 'i': goto yy342; case 'O': - case 'o': goto yy345; + case 'o': goto yy343; case 'T': - case 't': goto yy343; + case 't': goto yy341; default: goto yy2; } yy9: @@ -241,18 +207,18 @@ int _scan_autolink_uri(const unsigned char *p) if (yych <= 'S') { if (yych <= '3') { if (yych <= '2') goto yy2; - goto yy339; + goto yy337; } else { - if (yych == 'C') goto yy337; + if (yych == 'C') goto yy335; goto yy2; } } else { if (yych <= 'c') { - if (yych <= 'T') goto yy338; + if (yych <= 'T') goto yy336; if (yych <= 'b') goto yy2; - goto yy337; + goto yy335; } else { - if (yych == 't') goto yy338; + if (yych == 't') goto yy336; goto yy2; } } @@ -260,33 +226,33 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy319; + case 'a': goto yy317; case 'C': - case 'c': goto yy316; + case 'c': goto yy314; case 'M': - case 'm': goto yy318; + case 'm': goto yy316; case 'N': - case 'n': goto yy317; + case 'n': goto yy315; case 'P': - case 'p': goto yy315; + case 'p': goto yy313; case 'R': - case 'r': goto yy314; + case 'r': goto yy312; case 'T': - case 't': goto yy313; + case 't': goto yy311; default: goto yy2; } yy11: yych = *(marker = ++p); if (yych <= 'D') { - if (yych == 'A') goto yy307; + if (yych == 'A') goto yy305; if (yych <= 'C') goto yy2; - goto yy306; + goto yy304; } else { if (yych <= 'a') { if (yych <= '`') goto yy2; - goto yy307; + goto yy305; } else { - if (yych == 'd') goto yy306; + if (yych == 'd') goto yy304; goto yy2; } } @@ -294,50 +260,50 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy273; + case 'a': goto yy271; case 'E': - case 'e': goto yy272; + case 'e': goto yy270; case 'I': - case 'i': goto yy275; + case 'i': goto yy273; case 'M': - case 'm': goto yy271; + case 'm': goto yy269; case 'S': - case 's': goto yy270; + case 's': goto yy268; case 'T': - case 't': goto yy274; + case 't': goto yy272; case 'U': - case 'u': goto yy269; + case 'u': goto yy267; case 'V': - case 'v': goto yy268; + case 'v': goto yy266; default: goto yy2; } yy13: yych = *(marker = ++p); switch (yych) { case 'E': - case 'e': goto yy263; + case 'e': goto yy261; case 'F': - case 'f': goto yy262; + case 'f': goto yy260; case 'I': - case 'i': goto yy261; + case 'i': goto yy259; case 'N': - case 'n': goto yy260; + case 'n': goto yy258; case 'O': - case 'o': goto yy259; + case 'o': goto yy257; default: goto yy2; } yy14: yych = *(marker = ++p); if (yych <= 'P') { - if (yych == 'I') goto yy245; + if (yych == 'I') goto yy243; if (yych <= 'O') goto yy2; - goto yy246; + goto yy244; } else { if (yych <= 'i') { if (yych <= 'h') goto yy2; - goto yy245; + goto yy243; } else { - if (yych == 'p') goto yy246; + if (yych == 'p') goto yy244; goto yy2; } } @@ -345,35 +311,35 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); if (yych <= 'S') { if (yych <= 'L') { - if (yych == 'A') goto yy227; + if (yych == 'A') goto yy225; if (yych <= 'K') goto yy2; - goto yy226; + goto yy224; } else { if (yych <= 'O') { if (yych <= 'N') goto yy2; - goto yy228; + goto yy226; } else { if (yych <= 'Q') goto yy2; - if (yych <= 'R') goto yy225; - goto yy224; + if (yych <= 'R') goto yy223; + goto yy222; } } } else { if (yych <= 'n') { if (yych <= 'a') { if (yych <= '`') goto yy2; - goto yy227; + goto yy225; } else { - if (yych == 'l') goto yy226; + if (yych == 'l') goto yy224; goto yy2; } } else { if (yych <= 'q') { - if (yych <= 'o') goto yy228; + if (yych <= 'o') goto yy226; goto yy2; } else { - if (yych <= 'r') goto yy225; - if (yych <= 's') goto yy224; + if (yych <= 'r') goto yy223; + if (yych <= 's') goto yy222; goto yy2; } } @@ -382,23 +348,23 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); if (yych <= 'T') { if (yych <= 'L') { - if (yych == 'E') goto yy214; + if (yych == 'E') goto yy212; goto yy2; } else { - if (yych <= 'M') goto yy213; + if (yych <= 'M') goto yy211; if (yych <= 'R') goto yy2; - if (yych <= 'S') goto yy212; - goto yy211; + if (yych <= 'S') goto yy210; + goto yy209; } } else { if (yych <= 'm') { - if (yych == 'e') goto yy214; + if (yych == 'e') goto yy212; if (yych <= 'l') goto yy2; - goto yy213; + goto yy211; } else { if (yych <= 'r') goto yy2; - if (yych <= 's') goto yy212; - if (yych <= 't') goto yy211; + if (yych <= 's') goto yy210; + if (yych <= 't') goto yy209; goto yy2; } } @@ -406,48 +372,48 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'E': - case 'e': goto yy167; + case 'e': goto yy165; case 'F': - case 'f': goto yy166; + case 'f': goto yy164; case 'G': - case 'g': goto yy165; + case 'g': goto yy163; case 'H': - case 'h': goto yy170; + case 'h': goto yy168; case 'I': - case 'i': goto yy169; + case 'i': goto yy167; case 'K': - case 'k': goto yy164; + case 'k': goto yy162; case 'M': - case 'm': goto yy163; + case 'm': goto yy161; case 'N': - case 'n': goto yy168; + case 'n': goto yy166; case 'O': - case 'o': goto yy162; + case 'o': goto yy160; case 'P': - case 'p': goto yy161; + case 'p': goto yy159; case 'S': - case 's': goto yy160; + case 's': goto yy158; case 'T': - case 't': goto yy159; + case 't': goto yy157; case 'V': - case 'v': goto yy158; + case 'v': goto yy156; default: goto yy2; } yy18: yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy134; + case 'a': goto yy132; case 'E': - case 'e': goto yy130; + case 'e': goto yy128; case 'F': - case 'f': goto yy133; + case 'f': goto yy131; case 'H': - case 'h': goto yy129; + case 'h': goto yy127; case 'I': - case 'i': goto yy131; + case 'i': goto yy129; case 'N': - case 'n': goto yy132; + case 'n': goto yy130; case 'V': case 'v': goto yy34; default: goto yy2; @@ -456,25 +422,25 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); if (yych <= 'T') { if (yych <= 'N') { - if (yych == 'D') goto yy121; + if (yych == 'D') goto yy119; if (yych <= 'M') goto yy2; - goto yy120; + goto yy118; } else { - if (yych == 'R') goto yy122; + if (yych == 'R') goto yy120; if (yych <= 'S') goto yy2; - goto yy119; + goto yy117; } } else { if (yych <= 'n') { - if (yych == 'd') goto yy121; + if (yych == 'd') goto yy119; if (yych <= 'm') goto yy2; - goto yy120; + goto yy118; } else { if (yych <= 'r') { if (yych <= 'q') goto yy2; - goto yy122; + goto yy120; } else { - if (yych == 't') goto yy119; + if (yych == 't') goto yy117; goto yy2; } } @@ -482,15 +448,15 @@ int _scan_autolink_uri(const unsigned char *p) yy20: yych = *(marker = ++p); if (yych <= 'I') { - if (yych == 'E') goto yy103; + if (yych == 'E') goto yy101; if (yych <= 'H') goto yy2; - goto yy102; + goto yy100; } else { if (yych <= 'e') { if (yych <= 'd') goto yy2; - goto yy103; + goto yy101; } else { - if (yych == 'i') goto yy102; + if (yych == 'i') goto yy100; goto yy2; } } @@ -498,22 +464,22 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); if (yych <= 'Y') { if (yych <= 'R') { - if (yych == 'E') goto yy92; + if (yych == 'E') goto yy90; goto yy2; } else { - if (yych <= 'S') goto yy93; - if (yych <= 'T') goto yy91; + if (yych <= 'S') goto yy91; + if (yych <= 'T') goto yy89; if (yych <= 'X') goto yy2; - goto yy90; + goto yy88; } } else { if (yych <= 's') { - if (yych == 'e') goto yy92; + if (yych == 'e') goto yy90; if (yych <= 'r') goto yy2; - goto yy93; + goto yy91; } else { - if (yych <= 't') goto yy91; - if (yych == 'y') goto yy90; + if (yych <= 't') goto yy89; + if (yych == 'y') goto yy88; goto yy2; } } @@ -521,68 +487,68 @@ int _scan_autolink_uri(const unsigned char *p) yych = *(marker = ++p); if (yych <= 'R') { if (yych <= 'F') { - if (yych == 'C') goto yy69; + if (yych == 'C') goto yy67; if (yych <= 'E') goto yy2; - goto yy67; + goto yy65; } else { - if (yych == 'M') goto yy68; + if (yych == 'M') goto yy66; if (yych <= 'Q') goto yy2; - goto yy66; + goto yy64; } } else { if (yych <= 'f') { - if (yych == 'c') goto yy69; + if (yych == 'c') goto yy67; if (yych <= 'e') goto yy2; - goto yy67; + goto yy65; } else { if (yych <= 'm') { if (yych <= 'l') goto yy2; - goto yy68; + goto yy66; } else { - if (yych == 'r') goto yy66; + if (yych == 'r') goto yy64; goto yy2; } } } yy23: yych = *(marker = ++p); - if (yych == '3') goto yy61; + if (yych == '3') goto yy59; goto yy2; yy24: yych = *(marker = ++p); if (yych <= 'O') { if (yych <= 'H') { - if (yych == 'E') goto yy51; + if (yych == 'E') goto yy49; goto yy2; } else { - if (yych <= 'I') goto yy50; + if (yych <= 'I') goto yy48; if (yych <= 'N') goto yy2; - goto yy49; + goto yy47; } } else { if (yych <= 'h') { - if (yych == 'e') goto yy51; + if (yych == 'e') goto yy49; goto yy2; } else { - if (yych <= 'i') goto yy50; - if (yych == 'o') goto yy49; + if (yych <= 'i') goto yy48; + if (yych == 'o') goto yy47; goto yy2; } } yy25: yych = *(marker = ++p); - if (yych == 'D') goto yy47; - if (yych == 'd') goto yy47; + if (yych == 'D') goto yy45; + if (yych == 'd') goto yy45; goto yy2; yy26: yych = *(marker = ++p); - if (yych == 'E') goto yy42; - if (yych == 'e') goto yy42; + if (yych == 'E') goto yy40; + if (yych == 'e') goto yy40; goto yy2; yy27: yych = *(marker = ++p); - if (yych == 'U') goto yy39; - if (yych == 'u') goto yy39; + if (yych == 'U') goto yy37; + if (yych == 'u') goto yy37; goto yy2; yy28: yych = *(marker = ++p); @@ -611,109 +577,103 @@ int _scan_autolink_uri(const unsigned char *p) 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: +yy37: yych = *++p; - if (yych == 'E') goto yy40; + if (yych == 'E') goto yy38; if (yych != 'e') goto yy31; -yy40: +yy38: yych = *++p; - if (yych == 'R') goto yy41; + if (yych == 'R') goto yy39; if (yych != 'r') goto yy31; -yy41: +yy39: yych = *++p; if (yych == 'Y') goto yy34; if (yych == 'y') goto yy34; goto yy31; -yy42: +yy40: yych = *++p; - if (yych == 'Y') goto yy43; + if (yych == 'Y') goto yy41; if (yych != 'y') goto yy31; -yy43: +yy41: yych = *++p; - if (yych == 'P') goto yy44; + if (yych == 'P') goto yy42; if (yych != 'p') goto yy31; -yy44: +yy42: yych = *++p; - if (yych == 'A') goto yy45; + if (yych == 'A') goto yy43; if (yych != 'a') goto yy31; -yy45: +yy43: yych = *++p; - if (yych == 'R') goto yy46; + if (yych == 'R') goto yy44; if (yych != 'r') goto yy31; -yy46: +yy44: yych = *++p; if (yych == 'C') goto yy34; if (yych == 'c') goto yy34; goto yy31; -yy47: +yy45: yych = *++p; if (yych != '2') goto yy31; yych = *++p; if (yych == 'K') goto yy34; if (yych == 'k') goto yy34; goto yy31; -yy49: +yy47: yych = *++p; - if (yych == 'L') goto yy60; - if (yych == 'l') goto yy60; + if (yych == 'L') goto yy58; + if (yych == 'l') goto yy58; goto yy31; -yy50: +yy48: yych = *++p; - if (yych == 'T') goto yy56; - if (yych == 't') goto yy56; + if (yych == 'T') goto yy54; + if (yych == 't') goto yy54; goto yy31; -yy51: +yy49: yych = *++p; - if (yych == 'S') goto yy52; + if (yych == 'S') goto yy50; if (yych != 's') goto yy31; -yy52: +yy50: yych = *++p; - if (yych == 'H') goto yy53; + if (yych == 'H') goto yy51; if (yych != 'h') goto yy31; -yy53: +yy51: yych = *++p; - if (yych == 'A') goto yy54; + if (yych == 'A') goto yy52; if (yych != 'a') goto yy31; -yy54: +yy52: yych = *++p; - if (yych == 'R') goto yy55; + if (yych == 'R') goto yy53; if (yych != 'r') goto yy31; -yy55: +yy53: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy56: +yy54: yych = *++p; - if (yych == 'C') goto yy57; + if (yych == 'C') goto yy55; if (yych != 'c') goto yy31; -yy57: +yy55: yych = *++p; - if (yych == 'O') goto yy58; + if (yych == 'O') goto yy56; if (yych != 'o') goto yy31; -yy58: +yy56: yych = *++p; - if (yych == 'I') goto yy59; + if (yych == 'I') goto yy57; if (yych != 'i') goto yy31; -yy59: +yy57: yych = *++p; if (yych == 'N') goto yy34; if (yych == 'n') goto yy34; goto yy31; -yy60: +yy58: yych = *++p; if (yych == 'O') goto yy34; if (yych == 'o') goto yy34; goto yy31; -yy61: +yy59: yych = *++p; if (yych != '9') goto yy31; yych = *++p; @@ -728,106 +688,106 @@ int _scan_autolink_uri(const unsigned char *p) if (yych <= 'q') goto yy31; if (yych <= 's') goto yy34; goto yy31; -yy66: +yy64: yych = *++p; if (yych == 'I') goto yy34; if (yych == 'i') goto yy34; goto yy31; -yy67: +yy65: yych = *++p; - if (yych == 'I') goto yy88; - if (yych == 'i') goto yy88; + if (yych == 'I') goto yy86; + if (yych == 'i') goto yy86; goto yy31; -yy68: +yy66: yych = *++p; if (yych <= 'P') { - if (yych == 'L') goto yy78; + if (yych == 'L') goto yy76; if (yych <= 'O') goto yy31; - goto yy79; + goto yy77; } else { if (yych <= 'l') { if (yych <= 'k') goto yy31; - goto yy78; + goto yy76; } else { - if (yych == 'p') goto yy79; + if (yych == 'p') goto yy77; goto yy31; } } -yy69: +yy67: yych = *++p; - if (yych == 'O') goto yy70; + if (yych == 'O') goto yy68; if (yych != 'o') goto yy31; -yy70: +yy68: yych = *++p; - if (yych == 'N') goto yy71; + if (yych == 'N') goto yy69; if (yych != 'n') goto yy31; -yy71: +yy69: yych = *++p; - if (yych == '-') goto yy72; + if (yych == '-') goto yy70; if (yych == ':') goto yy35; goto yy31; -yy72: +yy70: yych = *++p; - if (yych == 'U') goto yy73; + if (yych == 'U') goto yy71; if (yych != 'u') goto yy31; -yy73: +yy71: yych = *++p; - if (yych == 'S') goto yy74; + if (yych == 'S') goto yy72; if (yych != 's') goto yy31; -yy74: +yy72: yych = *++p; - if (yych == 'E') goto yy75; + if (yych == 'E') goto yy73; if (yych != 'e') goto yy31; -yy75: +yy73: yych = *++p; - if (yych == 'R') goto yy76; + if (yych == 'R') goto yy74; if (yych != 'r') goto yy31; -yy76: +yy74: yych = *++p; - if (yych == 'I') goto yy77; + if (yych == 'I') goto yy75; if (yych != 'i') goto yy31; -yy77: +yy75: yych = *++p; if (yych == 'D') goto yy34; if (yych == 'd') goto yy34; goto yy31; -yy78: +yy76: yych = *++p; - if (yych == 'R') goto yy80; - if (yych == 'r') goto yy80; + if (yych == 'R') goto yy78; + if (yych == 'r') goto yy78; goto yy31; -yy79: +yy77: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy80: +yy78: yych = *++p; - if (yych == 'P') goto yy81; + if (yych == 'P') goto yy79; if (yych != 'p') goto yy31; -yy81: +yy79: yych = *++p; - if (yych == 'C') goto yy82; + if (yych == 'C') goto yy80; if (yych != 'c') goto yy31; -yy82: +yy80: yych = *++p; if (yych != '.') goto yy31; yych = *++p; - if (yych == 'B') goto yy84; + if (yych == 'B') goto yy82; if (yych != 'b') goto yy31; -yy84: +yy82: yych = *++p; - if (yych == 'E') goto yy85; + if (yych == 'E') goto yy83; if (yych != 'e') goto yy31; -yy85: +yy83: yych = *++p; - if (yych == 'E') goto yy86; + if (yych == 'E') goto yy84; if (yych != 'e') goto yy31; -yy86: +yy84: yych = *++p; - if (yych == 'P') goto yy87; + if (yych == 'P') goto yy85; if (yych != 'p') goto yy31; -yy87: +yy85: yych = *++p; if (yych <= 'R') { if (yych == ':') goto yy35; @@ -837,31 +797,31 @@ int _scan_autolink_uri(const unsigned char *p) if (yych == 's') goto yy34; goto yy31; } -yy88: +yy86: yych = *++p; - if (yych == 'R') goto yy89; + if (yych == 'R') goto yy87; if (yych != 'r') goto yy31; -yy89: +yy87: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy90: +yy88: yych = *++p; - if (yych == 'C') goto yy98; - if (yych == 'c') goto yy98; + if (yych == 'C') goto yy96; + if (yych == 'c') goto yy96; goto yy31; -yy91: +yy89: yych = *++p; - if (yych == 'A') goto yy97; - if (yych == 'a') goto yy97; + if (yych == 'A') goto yy95; + if (yych == 'a') goto yy95; goto yy31; -yy92: +yy90: yych = *++p; - if (yych == 'B') goto yy94; - if (yych == 'b') goto yy94; + if (yych == 'B') goto yy92; + if (yych == 'b') goto yy92; goto yy31; -yy93: +yy91: yych = *++p; if (yych <= 'R') { if (yych == ':') goto yy35; @@ -871,152 +831,152 @@ int _scan_autolink_uri(const unsigned char *p) if (yych == 's') goto yy34; goto yy31; } -yy94: +yy92: yych = *++p; - if (yych == 'C') goto yy95; + if (yych == 'C') goto yy93; if (yych != 'c') goto yy31; -yy95: +yy93: yych = *++p; - if (yych == 'A') goto yy96; + if (yych == 'A') goto yy94; if (yych != 'a') goto yy31; -yy96: +yy94: yych = *++p; if (yych == 'L') goto yy34; if (yych == 'l') goto yy34; goto yy31; -yy97: +yy95: yych = *++p; if (yych == 'I') goto yy34; if (yych == 'i') goto yy34; goto yy31; -yy98: +yy96: yych = *++p; - if (yych == 'I') goto yy99; + if (yych == 'I') goto yy97; if (yych != 'i') goto yy31; -yy99: +yy97: yych = *++p; - if (yych == 'W') goto yy100; + if (yych == 'W') goto yy98; if (yych != 'w') goto yy31; -yy100: +yy98: yych = *++p; - if (yych == 'Y') goto yy101; + if (yych == 'Y') goto yy99; if (yych != 'y') goto yy31; -yy101: +yy99: yych = *++p; if (yych == 'G') goto yy34; if (yych == 'g') goto yy34; goto yy31; -yy102: +yy100: yych = *++p; - if (yych == 'E') goto yy111; - if (yych == 'e') goto yy111; + if (yych == 'E') goto yy109; + if (yych == 'e') goto yy109; goto yy31; -yy103: +yy101: yych = *++p; if (yych <= 'N') { if (yych <= 'L') goto yy31; - if (yych >= 'N') goto yy105; + if (yych >= 'N') goto yy103; } else { if (yych <= 'l') goto yy31; - if (yych <= 'm') goto yy104; - if (yych <= 'n') goto yy105; + if (yych <= 'm') goto yy102; + if (yych <= 'n') goto yy103; goto yy31; } -yy104: +yy102: yych = *++p; - if (yych == 'M') goto yy110; - if (yych == 'm') goto yy110; + if (yych == 'M') goto yy108; + if (yych == 'm') goto yy108; goto yy31; -yy105: +yy103: yych = *++p; - if (yych == 'T') goto yy106; + if (yych == 'T') goto yy104; if (yych != 't') goto yy31; -yy106: +yy104: yych = *++p; - if (yych == 'R') goto yy107; + if (yych == 'R') goto yy105; if (yych != 'r') goto yy31; -yy107: +yy105: yych = *++p; - if (yych == 'I') goto yy108; + if (yych == 'I') goto yy106; if (yych != 'i') goto yy31; -yy108: +yy106: yych = *++p; - if (yych == 'L') goto yy109; + if (yych == 'L') goto yy107; if (yych != 'l') goto yy31; -yy109: +yy107: yych = *++p; if (yych == 'O') goto yy34; if (yych == 'o') goto yy34; goto yy31; -yy110: +yy108: yych = *++p; if (yych == 'I') goto yy34; if (yych == 'i') goto yy34; goto yy31; -yy111: +yy109: yych = *++p; - if (yych == 'W') goto yy112; + if (yych == 'W') goto yy110; if (yych != 'w') goto yy31; -yy112: +yy110: yych = *++p; if (yych != '-') goto yy31; yych = *++p; - if (yych == 'S') goto yy114; + if (yych == 'S') goto yy112; if (yych != 's') goto yy31; -yy114: +yy112: yych = *++p; - if (yych == 'O') goto yy115; + if (yych == 'O') goto yy113; if (yych != 'o') goto yy31; -yy115: +yy113: yych = *++p; - if (yych == 'U') goto yy116; + if (yych == 'U') goto yy114; if (yych != 'u') goto yy31; -yy116: +yy114: yych = *++p; - if (yych == 'R') goto yy117; + if (yych == 'R') goto yy115; if (yych != 'r') goto yy31; -yy117: +yy115: yych = *++p; - if (yych == 'C') goto yy118; + if (yych == 'C') goto yy116; if (yych != 'c') goto yy31; -yy118: +yy116: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy119: +yy117: yych = *++p; - if (yych == '2') goto yy126; + if (yych == '2') goto yy124; goto yy31; -yy120: +yy118: yych = *++p; - if (yych == 'R') goto yy123; - if (yych == 'r') goto yy123; + if (yych == 'R') goto yy121; + if (yych == 'r') goto yy121; goto yy31; -yy121: +yy119: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy122: +yy120: yych = *++p; if (yych == 'N') goto yy34; if (yych == 'n') goto yy34; goto yy31; -yy123: +yy121: yych = *++p; - if (yych == 'E') goto yy124; + if (yych == 'E') goto yy122; if (yych != 'e') goto yy31; -yy124: +yy122: yych = *++p; - if (yych == 'A') goto yy125; + if (yych == 'A') goto yy123; if (yych != 'a') goto yy31; -yy125: +yy123: yych = *++p; if (yych == 'L') goto yy34; if (yych == 'l') goto yy34; goto yy31; -yy126: +yy124: yych = *++p; if (yych != '0') goto yy31; yych = *++p; @@ -1024,51 +984,51 @@ int _scan_autolink_uri(const unsigned char *p) yych = *++p; if (yych == '4') goto yy34; goto yy31; -yy129: +yy127: yych = *++p; - if (yych == 'I') goto yy148; - if (yych == 'i') goto yy148; + if (yych == 'I') goto yy146; + if (yych == 'i') goto yy146; goto yy31; -yy130: +yy128: yych = *++p; if (yych <= 'L') { - if (yych == 'A') goto yy140; + if (yych == 'A') goto yy138; if (yych <= 'K') goto yy31; - goto yy139; + goto yy137; } else { if (yych <= 'a') { if (yych <= '`') goto yy31; - goto yy140; + goto yy138; } else { - if (yych == 'l') goto yy139; + if (yych == 'l') goto yy137; goto yy31; } } -yy131: +yy129: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy132: +yy130: yych = *++p; - if (yych == '3') goto yy136; + if (yych == '3') goto yy134; goto yy31; -yy133: +yy131: yych = *++p; - if (yych == 'T') goto yy135; - if (yych == 't') goto yy135; + if (yych == 'T') goto yy133; + if (yych == 't') goto yy133; goto yy31; -yy134: +yy132: yych = *++p; if (yych == 'G') goto yy34; if (yych == 'g') goto yy34; goto yy31; -yy135: +yy133: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy136: +yy134: yych = *++p; if (yych != '2') goto yy31; yych = *++p; @@ -1076,139 +1036,139 @@ int _scan_autolink_uri(const unsigned char *p) yych = *++p; if (yych == '0') goto yy34; goto yy31; -yy139: +yy137: yych = *++p; if (yych <= 'M') { if (yych == ':') goto yy35; goto yy31; } else { - if (yych <= 'N') goto yy146; - if (yych == 'n') goto yy146; + if (yych <= 'N') goto yy144; + if (yych == 'n') goto yy144; goto yy31; } -yy140: +yy138: yych = *++p; - if (yych == 'M') goto yy141; + if (yych == 'M') goto yy139; if (yych != 'm') goto yy31; -yy141: +yy139: yych = *++p; - if (yych == 'S') goto yy142; + if (yych == 'S') goto yy140; if (yych != 's') goto yy31; -yy142: +yy140: yych = *++p; - if (yych == 'P') goto yy143; + if (yych == 'P') goto yy141; if (yych != 'p') goto yy31; -yy143: +yy141: yych = *++p; - if (yych == 'E') goto yy144; + if (yych == 'E') goto yy142; if (yych != 'e') goto yy31; -yy144: +yy142: yych = *++p; - if (yych == 'A') goto yy145; + if (yych == 'A') goto yy143; if (yych != 'a') goto yy31; -yy145: +yy143: yych = *++p; if (yych == 'K') goto yy34; if (yych == 'k') goto yy34; goto yy31; -yy146: +yy144: yych = *++p; - if (yych == 'E') goto yy147; + if (yych == 'E') goto yy145; if (yych != 'e') goto yy31; -yy147: +yy145: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy148: +yy146: yych = *++p; if (yych <= 'S') { - if (yych == 'N') goto yy149; + if (yych == 'N') goto yy147; if (yych <= 'R') goto yy31; - goto yy150; + goto yy148; } else { if (yych <= 'n') { if (yych <= 'm') goto yy31; } else { - if (yych == 's') goto yy150; + if (yych == 's') goto yy148; goto yy31; } } -yy149: +yy147: yych = *++p; - if (yych == 'G') goto yy157; - if (yych == 'g') goto yy157; + if (yych == 'G') goto yy155; + if (yych == 'g') goto yy155; goto yy31; -yy150: +yy148: yych = *++p; - if (yych == 'M') goto yy151; + if (yych == 'M') goto yy149; if (yych != 'm') goto yy31; -yy151: +yy149: yych = *++p; - if (yych == 'E') goto yy152; + if (yych == 'E') goto yy150; if (yych != 'e') goto yy31; -yy152: +yy150: yych = *++p; - if (yych == 'S') goto yy153; + if (yych == 'S') goto yy151; if (yych != 's') goto yy31; -yy153: +yy151: yych = *++p; - if (yych == 'S') goto yy154; + if (yych == 'S') goto yy152; if (yych != 's') goto yy31; -yy154: +yy152: yych = *++p; - if (yych == 'A') goto yy155; + if (yych == 'A') goto yy153; if (yych != 'a') goto yy31; -yy155: +yy153: yych = *++p; - if (yych == 'G') goto yy156; + if (yych == 'G') goto yy154; if (yych != 'g') goto yy31; -yy156: +yy154: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy157: +yy155: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy158: +yy156: yych = *++p; if (yych == 'N') goto yy34; if (yych == 'n') goto yy34; goto yy31; -yy159: +yy157: yych = *++p; - if (yych == 'E') goto yy209; - if (yych == 'e') goto yy209; + if (yych == 'E') goto yy207; + if (yych == 'e') goto yy207; goto yy31; -yy160: +yy158: yych = *++p; if (yych == 'H') goto yy34; if (yych == 'h') goto yy34; goto yy31; -yy161: +yy159: yych = *++p; - if (yych == 'O') goto yy205; - if (yych == 'o') goto yy205; + if (yych == 'O') goto yy203; + if (yych == 'o') goto yy203; goto yy31; -yy162: +yy160: yych = *++p; if (yych <= 'L') { - if (yych == 'A') goto yy195; + if (yych == 'A') goto yy193; if (yych <= 'K') goto yy31; - goto yy196; + goto yy194; } else { if (yych <= 'a') { if (yych <= '`') goto yy31; - goto yy195; + goto yy193; } else { - if (yych == 'l') goto yy196; + if (yych == 'l') goto yy194; goto yy31; } } -yy163: +yy161: yych = *++p; if (yych <= 'S') { if (yych == 'B') goto yy34; @@ -1223,81 +1183,81 @@ int _scan_autolink_uri(const unsigned char *p) goto yy31; } } -yy164: +yy162: yych = *++p; - if (yych == 'Y') goto yy193; - if (yych == 'y') goto yy193; + if (yych == 'Y') goto yy191; + if (yych == 'y') goto yy191; goto yy31; -yy165: +yy163: yych = *++p; if (yych == 'N') goto yy34; if (yych == 'n') goto yy34; goto yy31; -yy166: +yy164: yych = *++p; - if (yych == 'T') goto yy192; - if (yych == 't') goto yy192; + if (yych == 'T') goto yy190; + if (yych == 't') goto yy190; goto yy31; -yy167: +yy165: yych = *++p; if (yych <= 'S') { if (yych <= 'C') { if (yych <= 'B') goto yy31; - goto yy179; + goto yy177; } else { if (yych <= 'Q') goto yy31; - if (yych <= 'R') goto yy177; - goto yy178; + if (yych <= 'R') goto yy175; + goto yy176; } } else { if (yych <= 'q') { - if (yych == 'c') goto yy179; + if (yych == 'c') goto yy177; goto yy31; } else { - if (yych <= 'r') goto yy177; - if (yych <= 's') goto yy178; + if (yych <= 'r') goto yy175; + if (yych <= 's') goto yy176; goto yy31; } } -yy168: +yy166: yych = *++p; - if (yych == 'M') goto yy176; - if (yych == 'm') goto yy176; + if (yych == 'M') goto yy174; + if (yych == 'm') goto yy174; goto yy31; -yy169: +yy167: yych = *++p; if (yych <= 'P') { - if (yych == 'E') goto yy173; + if (yych == 'E') goto yy171; if (yych <= 'O') goto yy31; - goto yy174; + goto yy172; } else { if (yych <= 'e') { if (yych <= 'd') goto yy31; - goto yy173; + goto yy171; } else { - if (yych == 'p') goto yy174; + if (yych == 'p') goto yy172; goto yy31; } } -yy170: +yy168: yych = *++p; - if (yych == 'T') goto yy171; + if (yych == 'T') goto yy169; if (yych != 't') goto yy31; -yy171: +yy169: yych = *++p; - if (yych == 'T') goto yy172; + if (yych == 'T') goto yy170; if (yych != 't') goto yy31; -yy172: +yy170: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy173: +yy171: yych = *++p; - if (yych == 'V') goto yy175; - if (yych == 'v') goto yy175; + if (yych == 'V') goto yy173; + if (yych == 'v') goto yy173; goto yy31; -yy174: +yy172: yych = *++p; if (yych <= 'R') { if (yych == ':') goto yy35; @@ -1307,132 +1267,132 @@ int _scan_autolink_uri(const unsigned char *p) if (yych == 's') goto yy34; goto yy31; } -yy175: +yy173: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy176: +yy174: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy177: +yy175: yych = *++p; - if (yych == 'V') goto yy189; - if (yych == 'v') goto yy189; + if (yych == 'V') goto yy187; + if (yych == 'v') goto yy187; goto yy31; -yy178: +yy176: yych = *++p; - if (yych == 'S') goto yy186; - if (yych == 's') goto yy186; + if (yych == 'S') goto yy184; + if (yych == 's') goto yy184; goto yy31; -yy179: +yy177: yych = *++p; - if (yych == 'O') goto yy180; + if (yych == 'O') goto yy178; if (yych != 'o') goto yy31; -yy180: +yy178: yych = *++p; - if (yych == 'N') goto yy181; + if (yych == 'N') goto yy179; if (yych != 'n') goto yy31; -yy181: +yy179: yych = *++p; - if (yych == 'D') goto yy182; + if (yych == 'D') goto yy180; if (yych != 'd') goto yy31; -yy182: +yy180: yych = *++p; - if (yych == 'L') goto yy183; + if (yych == 'L') goto yy181; if (yych != 'l') goto yy31; -yy183: +yy181: yych = *++p; - if (yych == 'I') goto yy184; + if (yych == 'I') goto yy182; if (yych != 'i') goto yy31; -yy184: +yy182: yych = *++p; - if (yych == 'F') goto yy185; + if (yych == 'F') goto yy183; if (yych != 'f') goto yy31; -yy185: +yy183: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy186: +yy184: yych = *++p; - if (yych == 'I') goto yy187; + if (yych == 'I') goto yy185; if (yych != 'i') goto yy31; -yy187: +yy185: yych = *++p; - if (yych == 'O') goto yy188; + if (yych == 'O') goto yy186; if (yych != 'o') goto yy31; -yy188: +yy186: yych = *++p; if (yych == 'N') goto yy34; if (yych == 'n') goto yy34; goto yy31; -yy189: +yy187: yych = *++p; - if (yych == 'I') goto yy190; + if (yych == 'I') goto yy188; if (yych != 'i') goto yy31; -yy190: +yy188: yych = *++p; - if (yych == 'C') goto yy191; + if (yych == 'C') goto yy189; if (yych != 'c') goto yy31; -yy191: +yy189: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy192: +yy190: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy193: +yy191: yych = *++p; - if (yych == 'P') goto yy194; + if (yych == 'P') goto yy192; if (yych != 'p') goto yy31; -yy194: +yy192: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy195: +yy193: yych = *++p; - if (yych == 'P') goto yy199; - if (yych == 'p') goto yy199; + if (yych == 'P') goto yy197; + if (yych == 'p') goto yy197; goto yy31; -yy196: +yy194: yych = *++p; - if (yych == 'D') goto yy197; + if (yych == 'D') goto yy195; if (yych != 'd') goto yy31; -yy197: +yy195: yych = *++p; - if (yych == 'A') goto yy198; + if (yych == 'A') goto yy196; if (yych != 'a') goto yy31; -yy198: +yy196: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy199: +yy197: yych = *++p; if (yych != '.') goto yy31; yych = *++p; - if (yych == 'B') goto yy201; + if (yych == 'B') goto yy199; if (yych != 'b') goto yy31; -yy201: +yy199: yych = *++p; - if (yych == 'E') goto yy202; + if (yych == 'E') goto yy200; if (yych != 'e') goto yy31; -yy202: +yy200: yych = *++p; - if (yych == 'E') goto yy203; + if (yych == 'E') goto yy201; if (yych != 'e') goto yy31; -yy203: +yy201: yych = *++p; - if (yych == 'P') goto yy204; + if (yych == 'P') goto yy202; if (yych != 'p') goto yy31; -yy204: +yy202: yych = *++p; if (yych <= 'R') { if (yych == ':') goto yy35; @@ -1442,290 +1402,290 @@ int _scan_autolink_uri(const unsigned char *p) if (yych == 's') goto yy34; goto yy31; } -yy205: +yy203: yych = *++p; - if (yych == 'T') goto yy206; + if (yych == 'T') goto yy204; if (yych != 't') goto yy31; -yy206: +yy204: yych = *++p; - if (yych == 'I') goto yy207; + if (yych == 'I') goto yy205; if (yych != 'i') goto yy31; -yy207: +yy205: yych = *++p; - if (yych == 'F') goto yy208; + if (yych == 'F') goto yy206; if (yych != 'f') goto yy31; -yy208: +yy206: yych = *++p; if (yych == 'Y') goto yy34; if (yych == 'y') goto yy34; goto yy31; -yy209: +yy207: yych = *++p; - if (yych == 'A') goto yy210; + if (yych == 'A') goto yy208; if (yych != 'a') goto yy31; -yy210: +yy208: yych = *++p; if (yych == 'M') goto yy34; if (yych == 'm') goto yy34; goto yy31; -yy211: +yy209: yych = *++p; if (yych <= 'S') { - if (yych == 'M') goto yy223; + if (yych == 'M') goto yy221; if (yych <= 'R') goto yy31; - goto yy222; + goto yy220; } else { if (yych <= 'm') { if (yych <= 'l') goto yy31; - goto yy223; + goto yy221; } else { - if (yych == 's') goto yy222; + if (yych == 's') goto yy220; goto yy31; } } -yy212: +yy210: yych = *++p; - if (yych == 'Y') goto yy220; - if (yych == 'y') goto yy220; + if (yych == 'Y') goto yy218; + if (yych == 'y') goto yy218; goto yy31; -yy213: +yy211: yych = *++p; if (yych == 'I') goto yy34; if (yych == 'i') goto yy34; goto yy31; -yy214: +yy212: yych = *++p; - if (yych == 'S') goto yy215; + if (yych == 'S') goto yy213; if (yych != 's') goto yy31; -yy215: +yy213: yych = *++p; if (yych <= 'N') { if (yych == ':') goto yy35; goto yy31; } else { - if (yych <= 'O') goto yy216; + if (yych <= 'O') goto yy214; if (yych != 'o') goto yy31; } -yy216: +yy214: yych = *++p; - if (yych == 'U') goto yy217; + if (yych == 'U') goto yy215; if (yych != 'u') goto yy31; -yy217: +yy215: yych = *++p; - if (yych == 'R') goto yy218; + if (yych == 'R') goto yy216; if (yych != 'r') goto yy31; -yy218: +yy216: yych = *++p; - if (yych == 'C') goto yy219; + if (yych == 'C') goto yy217; if (yych != 'c') goto yy31; -yy219: +yy217: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy220: +yy218: yych = *++p; - if (yych == 'N') goto yy221; + if (yych == 'N') goto yy219; if (yych != 'n') goto yy31; -yy221: +yy219: yych = *++p; if (yych == 'C') goto yy34; if (yych == 'c') goto yy34; goto yy31; -yy222: +yy220: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy223: +yy221: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy224: +yy222: yych = *++p; - if (yych == 'Y') goto yy244; - if (yych == 'y') goto yy244; + if (yych == 'Y') goto yy242; + if (yych == 'y') goto yy242; goto yy31; -yy225: +yy223: yych = *++p; if (yych <= 'O') { - if (yych == 'E') goto yy241; + if (yych == 'E') goto yy239; if (yych <= 'N') goto yy31; - goto yy242; + goto yy240; } else { if (yych <= 'e') { if (yych <= 'd') goto yy31; - goto yy241; + goto yy239; } else { - if (yych == 'o') goto yy242; + if (yych == 'o') goto yy240; goto yy31; } } -yy226: +yy224: yych = *++p; - if (yych == 'A') goto yy236; - if (yych == 'a') goto yy236; + if (yych == 'A') goto yy234; + if (yych == 'a') goto yy234; goto yy31; -yy227: +yy225: yych = *++p; if (yych <= 'P') { - if (yych == 'L') goto yy229; + if (yych == 'L') goto yy227; if (yych <= 'O') goto yy31; - goto yy230; + goto yy228; } else { if (yych <= 'l') { if (yych <= 'k') goto yy31; - goto yy229; + goto yy227; } else { - if (yych == 'p') goto yy230; + if (yych == 'p') goto yy228; goto yy31; } } -yy228: +yy226: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy229: +yy227: yych = *++p; if (yych == 'M') goto yy34; if (yych == 'm') goto yy34; goto yy31; -yy230: +yy228: yych = *++p; - if (yych == 'A') goto yy231; + if (yych == 'A') goto yy229; if (yych != 'a') goto yy31; -yy231: +yy229: yych = *++p; - if (yych == 'R') goto yy232; + if (yych == 'R') goto yy230; if (yych != 'r') goto yy31; -yy232: +yy230: yych = *++p; - if (yych == 'A') goto yy233; + if (yych == 'A') goto yy231; if (yych != 'a') goto yy31; -yy233: +yy231: yych = *++p; - if (yych == 'Z') goto yy234; + if (yych == 'Z') goto yy232; if (yych != 'z') goto yy31; -yy234: +yy232: yych = *++p; - if (yych == 'Z') goto yy235; + if (yych == 'Z') goto yy233; if (yych != 'z') goto yy31; -yy235: +yy233: yych = *++p; if (yych == 'I') goto yy34; if (yych == 'i') goto yy34; goto yy31; -yy236: +yy234: yych = *++p; - if (yych == 'T') goto yy237; + if (yych == 'T') goto yy235; if (yych != 't') goto yy31; -yy237: +yy235: yych = *++p; - if (yych == 'F') goto yy238; + if (yych == 'F') goto yy236; if (yych != 'f') goto yy31; -yy238: +yy236: yych = *++p; - if (yych == 'O') goto yy239; + if (yych == 'O') goto yy237; if (yych != 'o') goto yy31; -yy239: +yy237: yych = *++p; - if (yych == 'R') goto yy240; + if (yych == 'R') goto yy238; if (yych != 'r') goto yy31; -yy240: +yy238: yych = *++p; if (yych == 'M') goto yy34; if (yych == 'm') goto yy34; goto yy31; -yy241: +yy239: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy242: +yy240: yych = *++p; - if (yych == 'X') goto yy243; + if (yych == 'X') goto yy241; if (yych != 'x') goto yy31; -yy243: +yy241: yych = *++p; if (yych == 'Y') goto yy34; if (yych == 'y') goto yy34; goto yy31; -yy244: +yy242: yych = *++p; if (yych == 'C') goto yy34; if (yych == 'c') goto yy34; goto yy31; -yy245: +yy243: yych = *++p; if (yych == 'D') goto yy34; if (yych == 'd') goto yy34; goto yy31; -yy246: +yy244: yych = *++p; - if (yych == 'A') goto yy247; + if (yych == 'A') goto yy245; if (yych != 'a') goto yy31; -yy247: +yy245: yych = *++p; - if (yych == 'Q') goto yy248; + if (yych == 'Q') goto yy246; if (yych != 'q') goto yy31; -yy248: +yy246: yych = *++p; - if (yych == 'U') goto yy249; + if (yych == 'U') goto yy247; if (yych != 'u') goto yy31; -yy249: +yy247: yych = *++p; - if (yych == 'E') goto yy250; + if (yych == 'E') goto yy248; if (yych != 'e') goto yy31; -yy250: +yy248: yych = *++p; - if (yych == 'L') goto yy251; + if (yych == 'L') goto yy249; if (yych != 'l') goto yy31; -yy251: +yy249: yych = *++p; - if (yych == 'O') goto yy252; + if (yych == 'O') goto yy250; if (yych != 'o') goto yy31; -yy252: +yy250: yych = *++p; - if (yych == 'C') goto yy253; + if (yych == 'C') goto yy251; if (yych != 'c') goto yy31; -yy253: +yy251: yych = *++p; - if (yych == 'K') goto yy254; + if (yych == 'K') goto yy252; if (yych != 'k') goto yy31; -yy254: +yy252: yych = *++p; - if (yych == 'T') goto yy255; + if (yych == 'T') goto yy253; if (yych != 't') goto yy31; -yy255: +yy253: yych = *++p; - if (yych == 'O') goto yy256; + if (yych == 'O') goto yy254; if (yych != 'o') goto yy31; -yy256: +yy254: yych = *++p; - if (yych == 'K') goto yy257; + if (yych == 'K') goto yy255; if (yych != 'k') goto yy31; -yy257: +yy255: yych = *++p; - if (yych == 'E') goto yy258; + if (yych == 'E') goto yy256; if (yych != 'e') goto yy31; -yy258: +yy256: yych = *++p; if (yych == 'N') goto yy34; if (yych == 'n') goto yy34; goto yy31; -yy259: +yy257: yych = *++p; - if (yych == 'T') goto yy266; - if (yych == 't') goto yy266; + if (yych == 'T') goto yy264; + if (yych == 't') goto yy264; goto yy31; -yy260: +yy258: yych = *++p; - if (yych == 'T') goto yy265; - if (yych == 't') goto yy265; + if (yych == 'T') goto yy263; + if (yych == 't') goto yy263; goto yy31; -yy261: +yy259: yych = *++p; if (yych <= 'G') { if (yych == ':') goto yy35; @@ -1735,208 +1695,208 @@ int _scan_autolink_uri(const unsigned char *p) if (yych == 'h') goto yy34; goto yy31; } -yy262: +yy260: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy263: +yy261: yych = *++p; - if (yych == 'W') goto yy264; + if (yych == 'W') goto yy262; if (yych != 'w') goto yy31; -yy264: +yy262: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy265: +yy263: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy266: +yy264: yych = *++p; - if (yych == 'E') goto yy267; + if (yych == 'E') goto yy265; if (yych != 'e') goto yy31; -yy267: +yy265: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy268: +yy266: yych = *++p; if (yych == 'N') goto yy34; if (yych == 'n') goto yy34; goto yy31; -yy269: +yy267: yych = *++p; if (yych <= 'P') { - if (yych == 'M') goto yy300; + if (yych == 'M') goto yy298; if (yych <= 'O') goto yy31; - goto yy299; + goto yy297; } else { if (yych <= 'm') { if (yych <= 'l') goto yy31; - goto yy300; + goto yy298; } else { - if (yych == 'p') goto yy299; + if (yych == 'p') goto yy297; goto yy31; } } -yy270: +yy268: yych = *++p; if (yych <= 'Q') { if (yych <= '-') { if (yych <= ',') goto yy31; - goto yy292; + goto yy290; } else { - if (yych == 'N') goto yy293; + if (yych == 'N') goto yy291; goto yy31; } } else { if (yych <= 'n') { - if (yych <= 'R') goto yy291; + if (yych <= 'R') goto yy289; if (yych <= 'm') goto yy31; - goto yy293; + goto yy291; } else { - if (yych == 'r') goto yy291; + if (yych == 'r') goto yy289; goto yy31; } } -yy271: +yy269: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy272: +yy270: yych = *++p; - if (yych == 'S') goto yy287; - if (yych == 's') goto yy287; + if (yych == 'S') goto yy285; + if (yych == 's') goto yy285; goto yy31; -yy273: +yy271: yych = *++p; switch (yych) { case 'G': - case 'g': goto yy278; + case 'g': goto yy276; case 'I': - case 'i': goto yy277; + case 'i': goto yy275; case 'P': - case 'p': goto yy279; + case 'p': goto yy277; case 'R': - case 'r': goto yy280; + case 'r': goto yy278; default: goto yy31; } -yy274: +yy272: yych = *++p; - if (yych == 'Q') goto yy276; - if (yych == 'q') goto yy276; + if (yych == 'Q') goto yy274; + if (yych == 'q') goto yy274; goto yy31; -yy275: +yy273: yych = *++p; if (yych == 'D') goto yy34; if (yych == 'd') goto yy34; goto yy31; -yy276: +yy274: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy277: +yy275: yych = *++p; - if (yych == 'L') goto yy285; - if (yych == 'l') goto yy285; + if (yych == 'L') goto yy283; + if (yych == 'l') goto yy283; goto yy31; -yy278: +yy276: yych = *++p; - if (yych == 'N') goto yy283; - if (yych == 'n') goto yy283; + if (yych == 'N') goto yy281; + if (yych == 'n') goto yy281; goto yy31; -yy279: +yy277: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy280: +yy278: yych = *++p; - if (yych == 'K') goto yy281; + if (yych == 'K') goto yy279; if (yych != 'k') goto yy31; -yy281: +yy279: yych = *++p; - if (yych == 'E') goto yy282; + if (yych == 'E') goto yy280; if (yych != 'e') goto yy31; -yy282: +yy280: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy283: +yy281: yych = *++p; - if (yych == 'E') goto yy284; + if (yych == 'E') goto yy282; if (yych != 'e') goto yy31; -yy284: +yy282: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy285: +yy283: yych = *++p; - if (yych == 'T') goto yy286; + if (yych == 'T') goto yy284; if (yych != 't') goto yy31; -yy286: +yy284: yych = *++p; if (yych == 'O') goto yy34; if (yych == 'o') goto yy34; goto yy31; -yy287: +yy285: yych = *++p; - if (yych == 'S') goto yy288; + if (yych == 'S') goto yy286; if (yych != 's') goto yy31; -yy288: +yy286: yych = *++p; - if (yych == 'A') goto yy289; + if (yych == 'A') goto yy287; if (yych != 'a') goto yy31; -yy289: +yy287: yych = *++p; - if (yych == 'G') goto yy290; + if (yych == 'G') goto yy288; if (yych != 'g') goto yy31; -yy290: +yy288: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy291: +yy289: yych = *++p; - if (yych == 'P') goto yy298; - if (yych == 'p') goto yy298; + if (yych == 'P') goto yy296; + if (yych == 'p') goto yy296; goto yy31; -yy292: +yy290: yych = *++p; - if (yych == 'H') goto yy295; - if (yych == 'h') goto yy295; + if (yych == 'H') goto yy293; + if (yych == 'h') goto yy293; goto yy31; -yy293: +yy291: yych = *++p; - if (yych == 'I') goto yy294; + if (yych == 'I') goto yy292; if (yych != 'i') goto yy31; -yy294: +yy292: yych = *++p; if (yych == 'M') goto yy34; if (yych == 'm') goto yy34; goto yy31; -yy295: +yy293: yych = *++p; - if (yych == 'E') goto yy296; + if (yych == 'E') goto yy294; if (yych != 'e') goto yy31; -yy296: +yy294: yych = *++p; - if (yych == 'L') goto yy297; + if (yych == 'L') goto yy295; if (yych != 'l') goto yy31; -yy297: +yy295: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy298: +yy296: yych = *++p; if (yych <= 'R') { if (yych == ':') goto yy35; @@ -1946,64 +1906,64 @@ int _scan_autolink_uri(const unsigned char *p) if (yych == 's') goto yy34; goto yy31; } -yy299: +yy297: yych = *++p; - if (yych == 'D') goto yy303; - if (yych == 'd') goto yy303; + if (yych == 'D') goto yy301; + if (yych == 'd') goto yy301; goto yy31; -yy300: +yy298: yych = *++p; - if (yych == 'B') goto yy301; + if (yych == 'B') goto yy299; if (yych != 'b') goto yy31; -yy301: +yy299: yych = *++p; - if (yych == 'L') goto yy302; + if (yych == 'L') goto yy300; if (yych != 'l') goto yy31; -yy302: +yy300: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy303: +yy301: yych = *++p; - if (yych == 'A') goto yy304; + if (yych == 'A') goto yy302; if (yych != 'a') goto yy31; -yy304: +yy302: yych = *++p; - if (yych == 'T') goto yy305; + if (yych == 'T') goto yy303; if (yych != 't') goto yy31; -yy305: +yy303: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy306: +yy304: yych = *++p; - if (yych == 'A') goto yy311; - if (yych == 'a') goto yy311; + if (yych == 'A') goto yy309; + if (yych == 'a') goto yy309; goto yy31; -yy307: +yy305: yych = *++p; - if (yych == 'S') goto yy308; + if (yych == 'S') goto yy306; if (yych != 's') goto yy31; -yy308: +yy306: yych = *++p; - if (yych == 'T') goto yy309; + if (yych == 'T') goto yy307; if (yych != 't') goto yy31; -yy309: +yy307: yych = *++p; - if (yych == 'F') goto yy310; + if (yych == 'F') goto yy308; if (yych != 'f') goto yy31; -yy310: +yy308: yych = *++p; if (yych == 'M') goto yy34; if (yych == 'm') goto yy34; goto yy31; -yy311: +yy309: yych = *++p; - if (yych == 'P') goto yy312; + if (yych == 'P') goto yy310; if (yych != 'p') goto yy31; -yy312: +yy310: yych = *++p; if (yych <= 'R') { if (yych == ':') goto yy35; @@ -2013,27 +1973,27 @@ int _scan_autolink_uri(const unsigned char *p) if (yych == 's') goto yy34; goto yy31; } -yy313: +yy311: yych = *++p; - if (yych == 'M') goto yy336; - if (yych == 'm') goto yy336; + if (yych == 'M') goto yy334; + if (yych == 'm') goto yy334; goto yy31; -yy314: +yy312: yych = *++p; if (yych <= 'I') { - if (yych == 'C') goto yy325; + if (yych == 'C') goto yy323; if (yych <= 'H') goto yy31; - goto yy324; + goto yy322; } else { if (yych <= 'c') { if (yych <= 'b') goto yy31; - goto yy325; + goto yy323; } else { - if (yych == 'i') goto yy324; + if (yych == 'i') goto yy322; goto yy31; } } -yy315: +yy313: yych = *++p; if (yych <= 'P') { if (yych == 'N') goto yy34; @@ -2048,67 +2008,67 @@ int _scan_autolink_uri(const unsigned char *p) goto yy31; } } -yy316: +yy314: yych = *++p; if (yych <= 'O') { - if (yych == 'A') goto yy322; + if (yych == 'A') goto yy320; if (yych <= 'N') goto yy31; - goto yy323; + goto yy321; } else { if (yych <= 'a') { if (yych <= '`') goto yy31; - goto yy322; + goto yy320; } else { - if (yych == 'o') goto yy323; + if (yych == 'o') goto yy321; goto yy31; } } -yy317: +yy315: yych = *++p; - if (yych == 'F') goto yy321; - if (yych == 'f') goto yy321; + if (yych == 'F') goto yy319; + if (yych == 'f') goto yy319; goto yy31; -yy318: +yy316: yych = *++p; if (yych <= '@') { if (yych == ':') goto yy35; goto yy31; } else { - if (yych <= 'A') goto yy320; - if (yych == 'a') goto yy320; + if (yych <= 'A') goto yy318; + if (yych == 'a') goto yy318; goto yy31; } -yy319: +yy317: yych = *++p; if (yych == 'X') goto yy34; if (yych == 'x') goto yy34; goto yy31; -yy320: +yy318: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy321: +yy319: yych = *++p; if (yych == 'O') goto yy34; if (yych == 'o') goto yy34; goto yy31; -yy322: +yy320: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy323: +yy321: yych = *++p; if (yych == 'N') goto yy34; if (yych == 'n') goto yy34; goto yy31; -yy324: +yy322: yych = *++p; - if (yych == 'S') goto yy326; - if (yych == 's') goto yy326; + if (yych == 'S') goto yy324; + if (yych == 's') goto yy324; goto yy31; -yy325: +yy323: yych = *++p; if (yych <= ':') { if (yych == '6') goto yy34; @@ -2123,60 +2083,60 @@ int _scan_autolink_uri(const unsigned char *p) goto yy31; } } -yy326: +yy324: yych = *++p; - if (yych == '.') goto yy327; + if (yych == '.') goto yy325; if (yych == ':') goto yy35; goto yy31; -yy327: +yy325: yych = *++p; if (yych <= 'X') { if (yych <= 'K') { - if (yych == 'B') goto yy330; + if (yych == 'B') goto yy328; goto yy31; } else { - if (yych <= 'L') goto yy328; + if (yych <= 'L') goto yy326; if (yych <= 'W') goto yy31; - goto yy329; + goto yy327; } } else { if (yych <= 'k') { - if (yych == 'b') goto yy330; + if (yych == 'b') goto yy328; goto yy31; } else { - if (yych <= 'l') goto yy328; - if (yych == 'x') goto yy329; + if (yych <= 'l') goto yy326; + if (yych == 'x') goto yy327; goto yy31; } } -yy328: +yy326: yych = *++p; - if (yych == 'W') goto yy335; - if (yych == 'w') goto yy335; + if (yych == 'W') goto yy333; + if (yych == 'w') goto yy333; goto yy31; -yy329: +yy327: yych = *++p; - if (yych == 'P') goto yy333; - if (yych == 'p') goto yy333; + if (yych == 'P') goto yy331; + if (yych == 'p') goto yy331; goto yy31; -yy330: +yy328: yych = *++p; - if (yych == 'E') goto yy331; + if (yych == 'E') goto yy329; if (yych != 'e') goto yy31; -yy331: +yy329: yych = *++p; - if (yych == 'E') goto yy332; + if (yych == 'E') goto yy330; if (yych != 'e') goto yy31; -yy332: +yy330: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy333: +yy331: yych = *++p; - if (yych == 'C') goto yy334; + if (yych == 'C') goto yy332; if (yych != 'c') goto yy31; -yy334: +yy332: yych = *++p; if (yych <= 'R') { if (yych == ':') goto yy35; @@ -2186,37 +2146,37 @@ int _scan_autolink_uri(const unsigned char *p) if (yych == 's') goto yy34; goto yy31; } -yy335: +yy333: yych = *++p; if (yych == 'Z') goto yy34; if (yych == 'z') goto yy34; goto yy31; -yy336: +yy334: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy337: +yy335: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy338: +yy336: yych = *++p; - if (yych == 'T') goto yy341; - if (yych == 't') goto yy341; + if (yych == 'T') goto yy339; + if (yych == 't') goto yy339; goto yy31; -yy339: +yy337: yych = *++p; if (yych != '2') goto yy31; yych = *++p; if (yych == '3') goto yy34; goto yy31; -yy341: +yy339: yych = *++p; - if (yych == 'P') goto yy342; + if (yych == 'P') goto yy340; if (yych != 'p') goto yy31; -yy342: +yy340: yych = *++p; if (yych <= 'R') { if (yych == ':') goto yy35; @@ -2226,202 +2186,202 @@ int _scan_autolink_uri(const unsigned char *p) if (yych == 's') goto yy34; goto yy31; } -yy343: +yy341: yych = *++p; - if (yych == 'A') goto yy359; - if (yych == 'a') goto yy359; + if (yych == 'A') goto yy357; + if (yych == 'a') goto yy357; goto yy31; -yy344: +yy342: yych = *++p; if (yych <= 'Z') { if (yych == 'T') goto yy34; if (yych <= 'Y') goto yy31; - goto yy350; + goto yy348; } else { if (yych <= 't') { if (yych <= 's') goto yy31; goto yy34; } else { - if (yych == 'z') goto yy350; + if (yych == 'z') goto yy348; goto yy31; } } -yy345: +yy343: yych = *++p; if (yych <= 'O') { if (yych == ':') goto yy35; goto yy31; } else { - if (yych <= 'P') goto yy347; - if (yych == 'p') goto yy347; + if (yych <= 'P') goto yy345; + if (yych == 'p') goto yy345; goto yy31; } -yy346: +yy344: yych = *++p; if (yych == 'O') goto yy34; if (yych == 'o') goto yy34; goto yy31; -yy347: +yy345: yych = *++p; - if (yych == 'H') goto yy348; + if (yych == 'H') goto yy346; if (yych != 'h') goto yy31; -yy348: +yy346: yych = *++p; - if (yych == 'E') goto yy349; + if (yych == 'E') goto yy347; if (yych != 'e') goto yy31; -yy349: +yy347: yych = *++p; if (yych == 'R') goto yy34; if (yych == 'r') goto yy34; goto yy31; -yy350: +yy348: yych = *++p; - if (yych == 'M') goto yy351; + if (yych == 'M') goto yy349; if (yych != 'm') goto yy31; -yy351: +yy349: yych = *++p; - if (yych == 'O') goto yy352; + if (yych == 'O') goto yy350; if (yych != 'o') goto yy31; -yy352: +yy350: yych = *++p; - if (yych == 'P') goto yy353; + if (yych == 'P') goto yy351; if (yych != 'p') goto yy31; -yy353: +yy351: yych = *++p; - if (yych == 'R') goto yy354; + if (yych == 'R') goto yy352; if (yych != 'r') goto yy31; -yy354: +yy352: yych = *++p; - if (yych == 'O') goto yy355; + if (yych == 'O') goto yy353; if (yych != 'o') goto yy31; -yy355: +yy353: yych = *++p; - if (yych == 'J') goto yy356; + if (yych == 'J') goto yy354; if (yych != 'j') goto yy31; -yy356: +yy354: yych = *++p; - if (yych == 'E') goto yy357; + if (yych == 'E') goto yy355; if (yych != 'e') goto yy31; -yy357: +yy355: yych = *++p; - if (yych == 'C') goto yy358; + if (yych == 'C') goto yy356; if (yych != 'c') goto yy31; -yy358: +yy356: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy359: +yy357: yych = *++p; - if (yych == 'L') goto yy360; + if (yych == 'L') goto yy358; if (yych != 'l') goto yy31; -yy360: +yy358: yych = *++p; if (yych == 'K') goto yy34; if (yych == 'k') goto yy34; goto yy31; -yy361: +yy359: yych = *++p; if (yych <= 'S') { if (yych <= 'M') { - if (yych == 'L') goto yy371; + if (yych == 'L') goto yy369; goto yy31; } else { - if (yych <= 'N') goto yy372; + if (yych <= 'N') goto yy370; if (yych <= 'R') goto yy31; - goto yy373; + goto yy371; } } else { if (yych <= 'm') { - if (yych == 'l') goto yy371; + if (yych == 'l') goto yy369; goto yy31; } else { - if (yych <= 'n') goto yy372; - if (yych == 's') goto yy373; + if (yych <= 'n') goto yy370; + if (yych == 's') goto yy371; goto yy31; } } -yy362: +yy360: yych = *++p; - if (yych == 'E') goto yy370; - if (yych == 'e') goto yy370; + if (yych == 'E') goto yy368; + if (yych == 'e') goto yy368; goto yy31; -yy363: +yy361: yych = *++p; - if (yych == 'C') goto yy365; - if (yych == 'c') goto yy365; + if (yych == 'C') goto yy363; + if (yych == 'c') goto yy363; goto yy31; -yy364: +yy362: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy365: +yy363: yych = *++p; - if (yych == 'E') goto yy366; + if (yych == 'E') goto yy364; if (yych != 'e') goto yy31; -yy366: +yy364: yych = *++p; - if (yych == 'T') goto yy367; + if (yych == 'T') goto yy365; if (yych != 't') goto yy31; -yy367: +yy365: yych = *++p; - if (yych == 'I') goto yy368; + if (yych == 'I') goto yy366; if (yych != 'i') goto yy31; -yy368: +yy366: yych = *++p; - if (yych == 'M') goto yy369; + if (yych == 'M') goto yy367; if (yych != 'm') goto yy31; -yy369: +yy367: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy370: +yy368: yych = *++p; if (yych == 'D') goto yy34; if (yych == 'd') goto yy34; goto yy31; -yy371: +yy369: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy372: +yy370: yych = *++p; - if (yych == 'G') goto yy374; - if (yych == 'g') goto yy374; + if (yych == 'G') goto yy372; + if (yych == 'g') goto yy372; goto yy31; -yy373: +yy371: yych = *++p; if (yych == 'H') goto yy34; if (yych == 'h') goto yy34; goto yy31; -yy374: +yy372: yych = *++p; - if (yych == 'E') goto yy375; + if (yych == 'E') goto yy373; if (yych != 'e') goto yy31; -yy375: +yy373: yych = *++p; if (yych == 'R') goto yy34; if (yych == 'r') goto yy34; goto yy31; -yy376: +yy374: yych = *++p; - if (yych == 'T') goto yy394; - if (yych == 't') goto yy394; + if (yych == 'T') goto yy392; + if (yych == 't') goto yy392; goto yy31; -yy377: +yy375: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy378: +yy376: yych = *++p; if (yych == 'M') goto yy34; if (yych == 'm') goto yy34; goto yy31; -yy379: +yy377: yych = *++p; if (yych <= 'S') { if (yych == 'P') goto yy34; @@ -2436,26 +2396,26 @@ int _scan_autolink_uri(const unsigned char *p) goto yy31; } } -yy380: +yy378: yych = *++p; - if (yych == 'I') goto yy388; - if (yych == 'i') goto yy388; + if (yych == 'I') goto yy386; + if (yych == 'i') goto yy386; goto yy31; -yy381: +yy379: yych = *++p; - if (yych == 'A') goto yy387; - if (yych == 'a') goto yy387; + if (yych == 'A') goto yy385; + if (yych == 'a') goto yy385; goto yy31; -yy382: +yy380: yych = *++p; - if (yych == 'O') goto yy385; - if (yych == 'o') goto yy385; + if (yych == 'O') goto yy383; + if (yych == 'o') goto yy383; goto yy31; -yy383: +yy381: yych = *++p; - if (yych == 'A') goto yy384; + if (yych == 'A') goto yy382; if (yych != 'a') goto yy31; -yy384: +yy382: yych = *++p; if (yych <= 'R') { if (yych == ':') goto yy35; @@ -2465,80 +2425,80 @@ int _scan_autolink_uri(const unsigned char *p) if (yych == 's') goto yy34; goto yy31; } -yy385: +yy383: yych = *++p; - if (yych == 'U') goto yy386; + if (yych == 'U') goto yy384; if (yych != 'u') goto yy31; -yy386: +yy384: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy387: +yy385: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy388: +yy386: yych = *++p; - if (yych == 'U') goto yy389; + if (yych == 'U') goto yy387; if (yych != 'u') goto yy31; -yy389: +yy387: yych = *++p; - if (yych == 'M') goto yy390; + if (yych == 'M') goto yy388; if (yych != 'm') goto yy31; -yy390: +yy388: yych = *++p; - if (yych == 'X') goto yy391; + if (yych == 'X') goto yy389; if (yych != 'x') goto yy31; -yy391: +yy389: yych = *++p; - if (yych == 'T') goto yy392; + if (yych == 'T') goto yy390; if (yych != 't') goto yy31; -yy392: +yy390: yych = *++p; - if (yych == 'R') goto yy393; + if (yych == 'R') goto yy391; if (yych != 'r') goto yy31; -yy393: +yy391: yych = *++p; if (yych == 'A') goto yy34; if (yych == 'a') goto yy34; goto yy31; -yy394: +yy392: yych = *++p; - if (yych == 'A') goto yy395; + if (yych == 'A') goto yy393; if (yych != 'a') goto yy31; -yy395: +yy393: yych = *++p; - if (yych == 'C') goto yy396; + if (yych == 'C') goto yy394; if (yych != 'c') goto yy31; -yy396: +yy394: yych = *++p; - if (yych == 'H') goto yy397; + if (yych == 'H') goto yy395; if (yych != 'h') goto yy31; -yy397: +yy395: yych = *++p; - if (yych == 'M') goto yy398; + if (yych == 'M') goto yy396; if (yych != 'm') goto yy31; -yy398: +yy396: yych = *++p; - if (yych == 'E') goto yy399; + if (yych == 'E') goto yy397; if (yych != 'e') goto yy31; -yy399: +yy397: yych = *++p; - if (yych == 'N') goto yy400; + if (yych == 'N') goto yy398; if (yych != 'n') goto yy31; -yy400: +yy398: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy401: +yy399: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy402: +yy400: yych = *++p; if (yych <= 'V') { if (yych == 'R') goto yy34; @@ -2552,404 +2512,404 @@ int _scan_autolink_uri(const unsigned char *p) } } yych = *++p; - if (yych == 'A') goto yy404; + if (yych == 'A') goto yy402; if (yych != 'a') goto yy31; -yy404: +yy402: yych = *++p; - if (yych == 'S') goto yy405; + if (yych == 'S') goto yy403; if (yych != 's') goto yy31; -yy405: +yy403: yych = *++p; - if (yych == 'C') goto yy406; + if (yych == 'C') goto yy404; if (yych != 'c') goto yy31; -yy406: +yy404: yych = *++p; - if (yych == 'R') goto yy407; + if (yych == 'R') goto yy405; if (yych != 'r') goto yy31; -yy407: +yy405: yych = *++p; - if (yych == 'I') goto yy408; + if (yych == 'I') goto yy406; if (yych != 'i') goto yy31; -yy408: +yy406: yych = *++p; - if (yych == 'P') goto yy409; + if (yych == 'P') goto yy407; if (yych != 'p') goto yy31; -yy409: +yy407: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy410: +yy408: yych = *++p; if (yych == 'B') goto yy34; if (yych == 'b') goto yy34; goto yy31; -yy411: +yy409: yych = *++p; if (yych == 'N') goto yy34; if (yych == 'n') goto yy34; goto yy31; -yy412: +yy410: yych = *++p; - if (yych == 'N') goto yy419; - if (yych == 'n') goto yy419; + if (yych == 'N') goto yy417; + if (yych == 'n') goto yy417; goto yy31; -yy413: +yy411: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy414: +yy412: yych = *++p; - if (yych == 'C') goto yy418; - if (yych == 'c') goto yy418; + if (yych == 'C') goto yy416; + if (yych == 'c') goto yy416; goto yy31; -yy415: +yy413: yych = *++p; if (yych <= 'V') { - if (yych == 'T') goto yy417; + if (yych == 'T') goto yy415; if (yych <= 'U') goto yy31; goto yy34; } else { if (yych <= 't') { if (yych <= 's') goto yy31; - goto yy417; + goto yy415; } else { if (yych == 'v') goto yy34; goto yy31; } } -yy416: +yy414: yych = *++p; if (yych == 'I') goto yy34; if (yych == 'i') goto yy34; goto yy31; -yy417: +yy415: yych = *++p; if (yych == 'A') goto yy34; if (yych == 'a') goto yy34; goto yy31; -yy418: +yy416: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy419: +yy417: yych = *++p; - if (yych == 'A') goto yy420; + if (yych == 'A') goto yy418; if (yych != 'a') goto yy31; -yy420: +yy418: yych = *++p; if (yych != '-') goto yy31; yych = *++p; - if (yych == 'P') goto yy422; + if (yych == 'P') goto yy420; if (yych != 'p') goto yy31; -yy422: +yy420: yych = *++p; - if (yych == 'L') goto yy423; + if (yych == 'L') goto yy421; if (yych != 'l') goto yy31; -yy423: +yy421: yych = *++p; - if (yych == 'A') goto yy424; + if (yych == 'A') goto yy422; if (yych != 'a') goto yy31; -yy424: +yy422: yych = *++p; - if (yych == 'Y') goto yy425; + if (yych == 'Y') goto yy423; if (yych != 'y') goto yy31; -yy425: +yy423: yych = *++p; if (yych <= 'S') { - if (yych == 'C') goto yy426; + if (yych == 'C') goto yy424; if (yych <= 'R') goto yy31; - goto yy427; + goto yy425; } else { if (yych <= 'c') { if (yych <= 'b') goto yy31; } else { - if (yych == 's') goto yy427; + if (yych == 's') goto yy425; goto yy31; } } -yy426: +yy424: yych = *++p; - if (yych == 'O') goto yy432; - if (yych == 'o') goto yy432; + if (yych == 'O') goto yy430; + if (yych == 'o') goto yy430; goto yy31; -yy427: +yy425: yych = *++p; - if (yych == 'I') goto yy428; + if (yych == 'I') goto yy426; if (yych != 'i') goto yy31; -yy428: +yy426: yych = *++p; - if (yych == 'N') goto yy429; + if (yych == 'N') goto yy427; if (yych != 'n') goto yy31; -yy429: +yy427: yych = *++p; - if (yych == 'G') goto yy430; + if (yych == 'G') goto yy428; if (yych != 'g') goto yy31; -yy430: +yy428: yych = *++p; - if (yych == 'L') goto yy431; + if (yych == 'L') goto yy429; if (yych != 'l') goto yy31; -yy431: +yy429: yych = *++p; if (yych == 'E') goto yy34; if (yych == 'e') goto yy34; goto yy31; -yy432: +yy430: yych = *++p; - if (yych == 'N') goto yy433; + if (yych == 'N') goto yy431; if (yych != 'n') goto yy31; -yy433: +yy431: yych = *++p; - if (yych == 'T') goto yy434; + if (yych == 'T') goto yy432; if (yych != 't') goto yy31; -yy434: +yy432: yych = *++p; - if (yych == 'A') goto yy435; + if (yych == 'A') goto yy433; if (yych != 'a') goto yy31; -yy435: +yy433: yych = *++p; - if (yych == 'I') goto yy436; + if (yych == 'I') goto yy434; if (yych != 'i') goto yy31; -yy436: +yy434: yych = *++p; - if (yych == 'N') goto yy437; + if (yych == 'N') goto yy435; if (yych != 'n') goto yy31; -yy437: +yy435: yych = *++p; - if (yych == 'E') goto yy438; + if (yych == 'E') goto yy436; if (yych != 'e') goto yy31; -yy438: +yy436: yych = *++p; if (yych == 'R') goto yy34; if (yych == 'r') goto yy34; goto yy31; -yy439: +yy437: yych = *++p; if (yych == 'S') goto yy34; if (yych == 's') goto yy34; goto yy31; -yy440: +yy438: yych = *++p; if (yych <= 'N') { if (yych <= 'A') { if (yych <= '@') goto yy31; - goto yy462; + goto yy460; } else { if (yych <= 'L') goto yy31; - if (yych <= 'M') goto yy463; - goto yy464; + if (yych <= 'M') goto yy461; + goto yy462; } } else { if (yych <= 'l') { - if (yych == 'a') goto yy462; + if (yych == 'a') goto yy460; goto yy31; } else { - if (yych <= 'm') goto yy463; - if (yych <= 'n') goto yy464; + if (yych <= 'm') goto yy461; + if (yych <= 'n') goto yy462; goto yy31; } } -yy441: +yy439: yych = *++p; - if (yych == 'R') goto yy449; - if (yych == 'r') goto yy449; + if (yych == 'R') goto yy447; + if (yych == 'r') goto yy447; goto yy31; -yy442: +yy440: yych = *++p; if (yych <= 'P') { - if (yych == 'L') goto yy446; + if (yych == 'L') goto yy444; if (yych <= 'O') goto yy31; goto yy34; } else { if (yych <= 'l') { if (yych <= 'k') goto yy31; - goto yy446; + goto yy444; } else { if (yych == 'p') goto yy34; goto yy31; } } -yy443: +yy441: yych = *++p; - if (yych == 'I') goto yy445; - if (yych == 'i') goto yy445; + if (yych == 'I') goto yy443; + if (yych == 'i') goto yy443; goto yy31; -yy444: +yy442: yych = *++p; if (yych == 'D') goto yy34; if (yych == 'd') goto yy34; goto yy31; -yy445: +yy443: yych = *++p; if (yych == 'D') goto yy34; if (yych == 'd') goto yy34; goto yy31; -yy446: +yy444: yych = *++p; - if (yych == 'L') goto yy447; + if (yych == 'L') goto yy445; if (yych != 'l') goto yy31; -yy447: +yy445: yych = *++p; - if (yych == 'T') goto yy448; + if (yych == 'T') goto yy446; if (yych != 't') goto yy31; -yy448: +yy446: yych = *++p; if (yych == 'O') goto yy34; if (yych == 'o') goto yy34; goto yy31; -yy449: +yy447: yych = *++p; - if (yych == 'O') goto yy450; + if (yych == 'O') goto yy448; if (yych != 'o') goto yy31; -yy450: +yy448: yych = *++p; - if (yych == 'M') goto yy451; + if (yych == 'M') goto yy449; if (yych != 'm') goto yy31; -yy451: +yy449: yych = *++p; - if (yych == 'E') goto yy452; + if (yych == 'E') goto yy450; if (yych != 'e') goto yy31; -yy452: +yy450: yych = *++p; - if (yych == '-') goto yy453; + if (yych == '-') goto yy451; if (yych == ':') goto yy35; goto yy31; -yy453: +yy451: yych = *++p; - if (yych == 'E') goto yy454; + if (yych == 'E') goto yy452; if (yych != 'e') goto yy31; -yy454: +yy452: yych = *++p; - if (yych == 'X') goto yy455; + if (yych == 'X') goto yy453; if (yych != 'x') goto yy31; -yy455: +yy453: yych = *++p; - if (yych == 'T') goto yy456; + if (yych == 'T') goto yy454; if (yych != 't') goto yy31; -yy456: +yy454: yych = *++p; - if (yych == 'E') goto yy457; + if (yych == 'E') goto yy455; if (yych != 'e') goto yy31; -yy457: +yy455: yych = *++p; - if (yych == 'N') goto yy458; + if (yych == 'N') goto yy456; if (yych != 'n') goto yy31; -yy458: +yy456: yych = *++p; - if (yych == 'S') goto yy459; + if (yych == 'S') goto yy457; if (yych != 's') goto yy31; -yy459: +yy457: yych = *++p; - if (yych == 'I') goto yy460; + if (yych == 'I') goto yy458; if (yych != 'i') goto yy31; -yy460: +yy458: yych = *++p; - if (yych == 'O') goto yy461; + if (yych == 'O') goto yy459; if (yych != 'o') goto yy31; -yy461: +yy459: yych = *++p; if (yych == 'N') goto yy34; if (yych == 'n') goto yy34; goto yy31; -yy462: +yy460: yych = *++p; if (yych == 'P') goto yy34; if (yych == 'p') goto yy34; goto yy31; -yy463: +yy461: yych = *++p; - if (yych == '-') goto yy468; + if (yych == '-') goto yy466; goto yy31; -yy464: +yy462: yych = *++p; - if (yych == 'T') goto yy465; + if (yych == 'T') goto yy463; if (yych != 't') goto yy31; -yy465: +yy463: yych = *++p; - if (yych == 'E') goto yy466; + if (yych == 'E') goto yy464; if (yych != 'e') goto yy31; -yy466: +yy464: yych = *++p; - if (yych == 'N') goto yy467; + if (yych == 'N') goto yy465; if (yych != 'n') goto yy31; -yy467: +yy465: yych = *++p; if (yych == 'T') goto yy34; if (yych == 't') goto yy34; goto yy31; -yy468: +yy466: yych = *++p; - if (yych == 'E') goto yy469; + if (yych == 'E') goto yy467; if (yych != 'e') goto yy31; -yy469: +yy467: yych = *++p; - if (yych == 'V') goto yy470; + if (yych == 'V') goto yy468; if (yych != 'v') goto yy31; -yy470: +yy468: yych = *++p; - if (yych == 'E') goto yy471; + if (yych == 'E') goto yy469; if (yych != 'e') goto yy31; -yy471: +yy469: yych = *++p; - if (yych == 'N') goto yy472; + if (yych == 'N') goto yy470; if (yych != 'n') goto yy31; -yy472: +yy470: yych = *++p; - if (yych == 'T') goto yy473; + if (yych == 'T') goto yy471; if (yych != 't') goto yy31; -yy473: +yy471: yych = *++p; - if (yych == 'B') goto yy474; + if (yych == 'B') goto yy472; if (yych != 'b') goto yy31; -yy474: +yy472: yych = *++p; - if (yych == 'R') goto yy475; + if (yych == 'R') goto yy473; if (yych != 'r') goto yy31; -yy475: +yy473: yych = *++p; - if (yych == 'I') goto yy476; + if (yych == 'I') goto yy474; if (yych != 'i') goto yy31; -yy476: +yy474: yych = *++p; - if (yych == 'T') goto yy477; + if (yych == 'T') goto yy475; if (yych != 't') goto yy31; -yy477: +yy475: yych = *++p; - if (yych == 'E') goto yy478; + if (yych == 'E') goto yy476; if (yych != 'e') goto yy31; -yy478: +yy476: yych = *++p; if (yych != '-') goto yy31; yych = *++p; - if (yych == 'A') goto yy480; + if (yych == 'A') goto yy478; if (yych != 'a') goto yy31; -yy480: +yy478: yych = *++p; - if (yych == 'T') goto yy481; + if (yych == 'T') goto yy479; if (yych != 't') goto yy31; -yy481: +yy479: yych = *++p; - if (yych == 'T') goto yy482; + if (yych == 'T') goto yy480; if (yych != 't') goto yy31; -yy482: +yy480: yych = *++p; - if (yych == 'E') goto yy483; + if (yych == 'E') goto yy481; if (yych != 'e') goto yy31; -yy483: +yy481: yych = *++p; - if (yych == 'N') goto yy484; + if (yych == 'N') goto yy482; if (yych != 'n') goto yy31; -yy484: +yy482: yych = *++p; - if (yych == 'D') goto yy485; + if (yych == 'D') goto yy483; if (yych != 'd') goto yy31; -yy485: +yy483: yych = *++p; - if (yych == 'E') goto yy486; + if (yych == 'E') goto yy484; if (yych != 'e') goto yy31; -yy486: +yy484: ++p; if ((yych = *p) == 'E') goto yy34; if (yych == 'e') goto yy34; @@ -2958,8 +2918,8 @@ int _scan_autolink_uri(const unsigned char *p) } -// Try to match email autolink after first <, returning num of chars matched. -int _scan_autolink_email(const unsigned char *p) +// 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; @@ -2971,4932 +2931,7871 @@ int _scan_autolink_email(const unsigned char *p) 0, 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, 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, - 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; - } - } + switch (yych) { + case '\n': goto yy487; + case 'A': + case 'a': goto yy491; + case 'B': + case 'b': goto yy509; + case 'C': + case 'c': goto yy488; + case 'D': + case 'd': goto yy489; + case 'E': + case 'e': goto yy510; + case 'F': + case 'f': goto yy492; + case 'G': + case 'g': goto yy493; + case 'H': + case 'h': goto yy494; + case 'I': + case 'i': goto yy495; + case 'J': + case 'j': goto yy490; + case 'K': + case 'k': goto yy511; + case 'L': + case 'l': goto yy496; + case 'M': + case 'm': goto yy497; + case 'N': + case 'n': goto yy498; + case 'O': + case 'o': goto yy499; + case 'P': + case 'p': goto yy500; + case 'Q': + case 'q': goto yy512; + case 'R': + case 'r': goto yy501; + case 'S': + case 's': goto yy502; + case 'T': + case 't': goto yy503; + case 'U': + case 'u': goto yy504; + case 'V': + case 'v': goto yy505; + case 'W': + case 'w': goto yy506; + case 'X': + case 'x': goto yy507; + case 'Y': + case 'y': goto yy513; + case 'Z': + case 'z': goto yy508; + default: goto yy514; } -yy489: +yy487: { return 0; } +yy488: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy927; + case 'H': + case 'h': goto yy926; + case 'I': + case 'i': goto yy929; + case 'O': + case 'o': goto yy925; + case 'R': + case 'r': goto yy928; + case 'V': + case 'v': goto yy924; + default: goto yy487; + } +yy489: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy900; + case 'I': + case 'i': goto yy899; + case 'L': + case 'l': goto yy897; + case 'N': + case 'n': goto yy898; + case 'O': + case 'o': goto yy901; + case 'T': + case 't': goto yy896; + case 'V': + case 'v': goto yy895; + default: goto yy487; + } 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; - } + if (yych <= 'M') { + if (yych == 'A') goto yy887; + if (yych <= 'L') goto yy487; + goto yy886; } else { - if (yych <= '>') { - if (yych <= '9') goto yy495; - if (yych == '=') goto yy495; - goto yy489; + if (yych <= 'a') { + if (yych <= '`') goto yy487; + goto yy887; } else { - if (yych <= 'Z') goto yy495; - if (yych <= ']') goto yy489; - if (yych <= '~') goto yy495; - goto yy489; + if (yych == 'm') goto yy886; + goto yy487; } } 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; + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy868; + case 'B': + case 'b': goto yy867; + case 'C': + case 'c': goto yy866; + case 'D': + case 'd': goto yy865; + case 'F': + case 'f': goto yy864; + case 'I': + case 'i': goto yy863; + case 'P': + case 'p': goto yy862; + case 'T': + case 't': goto yy861; + case 'W': + case 'w': goto yy519; + default: goto yy487; } - if (yych == '@') goto yy492; - goto yy493; -yy496: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; +yy492: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'E') { + if (yych == 'A') goto yy848; + if (yych <= 'D') goto yy487; + goto yy847; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy498; - goto yy493; + if (yych == 'I') goto yy846; + if (yych <= 'S') goto yy487; + goto yy849; } } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy498; + if (yych <= 'e') { + if (yych == 'a') goto yy848; + if (yych <= 'd') goto yy487; + goto yy847; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy498; - goto yy493; + if (yych <= 'i') { + if (yych <= 'h') goto yy487; + goto yy846; + } else { + if (yych == 't') goto yy849; + goto yy487; + } } } - 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; +yy493: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': goto yy831; + case 'G': + case 'g': goto yy519; + case 'I': + case 'i': goto yy829; + case 'O': + case 'o': goto yy830; + case 'T': + case 't': goto yy828; + default: goto yy487; + } +yy494: + yych = *(marker = ++p); + if (yych <= 'S') { + if (yych <= '3') { + if (yych <= '2') goto yy487; + goto yy824; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy627; - goto yy493; + if (yych == 'C') goto yy822; + goto yy487; } - } -yy498: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych <= '-') goto yy626; + } else { + if (yych <= 'c') { + if (yych <= 'T') goto yy823; + if (yych <= 'b') goto yy487; + goto yy822; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy627; - goto yy493; + if (yych == 't') goto yy823; + goto yy487; } + } +yy495: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy804; + case 'C': + case 'c': goto yy801; + case 'M': + case 'm': goto yy803; + case 'N': + case 'n': goto yy802; + case 'P': + case 'p': goto yy800; + case 'R': + case 'r': goto yy799; + case 'T': + case 't': goto yy798; + default: goto yy487; + } +yy496: + yych = *(marker = ++p); + if (yych <= 'D') { + if (yych == 'A') goto yy792; + if (yych <= 'C') goto yy487; + goto yy791; } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy627; + if (yych <= 'a') { + if (yych <= '`') goto yy487; + goto yy792; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy627; - goto yy493; + if (yych == 'd') goto yy791; + goto yy487; } } +yy497: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy758; + case 'E': + case 'e': goto yy757; + case 'I': + case 'i': goto yy760; + case 'M': + case 'm': goto yy756; + case 'S': + case 's': goto yy755; + case 'T': + case 't': goto yy759; + case 'U': + case 'u': goto yy754; + case 'V': + case 'v': goto yy753; + default: goto yy487; + } +yy498: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': goto yy748; + case 'F': + case 'f': goto yy747; + case 'I': + case 'i': goto yy746; + case 'N': + case 'n': goto yy745; + case 'O': + case 'o': goto yy744; + default: goto yy487; + } yy499: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy502; - goto yy493; + yych = *(marker = ++p); + if (yych <= 'P') { + if (yych == 'I') goto yy730; + if (yych <= 'O') goto yy487; + goto yy731; } else { - if (yych <= 'Z') goto yy502; - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy502; - goto yy493; + if (yych <= 'i') { + if (yych <= 'h') goto yy487; + goto yy730; + } else { + if (yych == 'p') goto yy731; + goto yy487; + } } yy500: - ++p; - { return (p - start); } -yy502: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + yych = *(marker = ++p); + if (yych <= 'S') { + if (yych <= 'L') { + if (yych == 'A') goto yy712; + if (yych <= 'K') goto yy487; + goto yy711; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy504; - goto yy493; + if (yych <= 'O') { + if (yych <= 'N') goto yy487; + goto yy713; + } else { + if (yych <= 'Q') goto yy487; + if (yych <= 'R') goto yy710; + goto yy709; + } } } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy504; + if (yych <= 'n') { + if (yych <= 'a') { + if (yych <= '`') goto yy487; + goto yy712; + } else { + if (yych == 'l') goto yy711; + goto yy487; + } } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy504; - goto yy493; + if (yych <= 'q') { + if (yych <= 'o') goto yy713; + goto yy487; + } else { + if (yych <= 'r') goto yy710; + if (yych <= 's') goto yy709; + goto yy487; + } } } - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy505; - if (yych <= '/') goto yy493; - goto yy506; +yy501: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'L') { + if (yych == 'E') goto yy699; + goto yy487; + } else { + if (yych <= 'M') goto yy698; + if (yych <= 'R') goto yy487; + if (yych <= 'S') goto yy697; + goto yy696; + } } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy506; + if (yych <= 'm') { + if (yych == 'e') goto yy699; + if (yych <= 'l') goto yy487; + goto yy698; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy506; - goto yy493; + if (yych <= 'r') goto yy487; + if (yych <= 's') goto yy697; + if (yych <= 't') goto yy696; + goto yy487; } } +yy502: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': goto yy652; + case 'F': + case 'f': goto yy651; + case 'G': + case 'g': goto yy650; + case 'H': + case 'h': goto yy655; + case 'I': + case 'i': goto yy654; + case 'K': + case 'k': goto yy649; + case 'M': + case 'm': goto yy648; + case 'N': + case 'n': goto yy653; + case 'O': + case 'o': goto yy647; + case 'P': + case 'p': goto yy646; + case 'S': + case 's': goto yy645; + case 'T': + case 't': goto yy644; + case 'V': + case 'v': goto yy643; + default: goto yy487; + } +yy503: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy619; + case 'E': + case 'e': goto yy615; + case 'F': + case 'f': goto yy618; + case 'H': + case 'h': goto yy614; + case 'I': + case 'i': goto yy616; + case 'N': + case 'n': goto yy617; + case 'V': + case 'v': goto yy519; + default: goto yy487; + } yy504: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'N') { + if (yych == 'D') goto yy606; + if (yych <= 'M') goto yy487; + goto yy605; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy506; - goto yy493; + if (yych == 'R') goto yy607; + if (yych <= 'S') goto yy487; + goto yy604; } } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy506; + if (yych <= 'n') { + if (yych == 'd') goto yy606; + if (yych <= 'm') goto yy487; + goto yy605; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy506; - goto yy493; + if (yych <= 'r') { + if (yych <= 'q') goto yy487; + goto yy607; + } else { + if (yych == 't') goto yy604; + goto yy487; + } } } yy505: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy507; - if (yych <= '/') goto yy493; - goto yy508; + yych = *(marker = ++p); + if (yych <= 'I') { + if (yych == 'E') goto yy588; + if (yych <= 'H') goto yy487; + goto yy587; } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy508; + if (yych <= 'e') { + if (yych <= 'd') goto yy487; + goto yy588; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy508; - goto yy493; + if (yych == 'i') goto yy587; + goto yy487; } } yy506: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + yych = *(marker = ++p); + if (yych <= 'Y') { + if (yych <= 'R') { + if (yych == 'E') goto yy577; + goto yy487; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy508; - goto yy493; + if (yych <= 'S') goto yy578; + if (yych <= 'T') goto yy576; + if (yych <= 'X') goto yy487; + goto yy575; } } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy508; + if (yych <= 's') { + if (yych == 'e') goto yy577; + if (yych <= 'r') goto yy487; + goto yy578; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy508; - goto yy493; + if (yych <= 't') goto yy576; + if (yych == 'y') goto yy575; + goto yy487; } } 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; + yych = *(marker = ++p); + if (yych <= 'R') { + if (yych <= 'F') { + if (yych == 'C') goto yy554; + if (yych <= 'E') goto yy487; + goto yy552; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy510; - goto yy493; + if (yych == 'M') goto yy553; + if (yych <= 'Q') goto yy487; + goto yy551; } } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy510; + if (yych <= 'f') { + if (yych == 'c') goto yy554; + if (yych <= 'e') goto yy487; + goto yy552; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy510; - goto yy493; + if (yych <= 'm') { + if (yych <= 'l') goto yy487; + goto yy553; + } else { + if (yych == 'r') goto yy551; + goto yy487; + } } } +yy508: + yych = *(marker = ++p); + if (yych == '3') goto yy546; + goto yy487; 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; + yych = *(marker = ++p); + if (yych <= 'O') { + if (yych <= 'H') { + if (yych == 'E') goto yy536; + goto yy487; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy512; - goto yy493; + if (yych <= 'I') goto yy535; + if (yych <= 'N') goto yy487; + goto yy534; } } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy512; + if (yych <= 'h') { + if (yych == 'e') goto yy536; + goto yy487; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy512; - goto yy493; + if (yych <= 'i') goto yy535; + if (yych == 'o') goto yy534; + goto yy487; } } +yy510: + yych = *(marker = ++p); + if (yych == 'D') goto yy532; + if (yych == 'd') goto yy532; + goto yy487; yy511: + yych = *(marker = ++p); + if (yych == 'E') goto yy527; + if (yych == 'e') goto yy527; + goto yy487; +yy512: + yych = *(marker = ++p); + if (yych == 'U') goto yy524; + if (yych == 'u') goto yy524; + goto yy487; +yy513: + yych = *(marker = ++p); + if (yych == 'M') goto yy515; + if (yych == 'm') goto yy515; + goto yy487; +yy514: + yych = *++p; + goto yy487; +yy515: + yych = *++p; + if (yych == 'S') goto yy517; + if (yych == 's') goto yy517; +yy516: + p = marker; + goto yy487; +yy517: + yych = *++p; + if (yych == 'G') goto yy518; + if (yych != 'g') goto yy516; +yy518: + yych = *++p; + if (yych == 'R') goto yy519; + if (yych != 'r') goto yy516; +yy519: + yych = *++p; + if (yych != ':') goto yy516; +yy520: ++p; yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy513; - if (yych <= '/') goto yy493; - goto yy514; + if (yybm[0+yych] & 128) { + goto yy520; + } + if (yych <= '=') goto yy516; + ++p; + { return (p - start); } +yy524: + yych = *++p; + if (yych == 'E') goto yy525; + if (yych != 'e') goto yy516; +yy525: + yych = *++p; + if (yych == 'R') goto yy526; + if (yych != 'r') goto yy516; +yy526: + yych = *++p; + if (yych == 'Y') goto yy519; + if (yych == 'y') goto yy519; + goto yy516; +yy527: + yych = *++p; + if (yych == 'Y') goto yy528; + if (yych != 'y') goto yy516; +yy528: + yych = *++p; + if (yych == 'P') goto yy529; + if (yych != 'p') goto yy516; +yy529: + yych = *++p; + if (yych == 'A') goto yy530; + if (yych != 'a') goto yy516; +yy530: + yych = *++p; + if (yych == 'R') goto yy531; + if (yych != 'r') goto yy516; +yy531: + yych = *++p; + if (yych == 'C') goto yy519; + if (yych == 'c') goto yy519; + goto yy516; +yy532: + yych = *++p; + if (yych != '2') goto yy516; + yych = *++p; + if (yych == 'K') goto yy519; + if (yych == 'k') goto yy519; + goto yy516; +yy534: + yych = *++p; + if (yych == 'L') goto yy545; + if (yych == 'l') goto yy545; + goto yy516; +yy535: + yych = *++p; + if (yych == 'T') goto yy541; + if (yych == 't') goto yy541; + goto yy516; +yy536: + yych = *++p; + if (yych == 'S') goto yy537; + if (yych != 's') goto yy516; +yy537: + yych = *++p; + if (yych == 'H') goto yy538; + if (yych != 'h') goto yy516; +yy538: + yych = *++p; + if (yych == 'A') goto yy539; + if (yych != 'a') goto yy516; +yy539: + yych = *++p; + if (yych == 'R') goto yy540; + if (yych != 'r') goto yy516; +yy540: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy541: + yych = *++p; + if (yych == 'C') goto yy542; + if (yych != 'c') goto yy516; +yy542: + yych = *++p; + if (yych == 'O') goto yy543; + if (yych != 'o') goto yy516; +yy543: + yych = *++p; + if (yych == 'I') goto yy544; + if (yych != 'i') goto yy516; +yy544: + yych = *++p; + if (yych == 'N') goto yy519; + if (yych == 'n') goto yy519; + goto yy516; +yy545: + yych = *++p; + if (yych == 'O') goto yy519; + if (yych == 'o') goto yy519; + goto yy516; +yy546: + yych = *++p; + if (yych != '9') goto yy516; + yych = *++p; + if (yych != '.') goto yy516; + yych = *++p; + if (yych != '5') goto yy516; + yych = *++p; + if (yych != '0') goto yy516; + yych = *++p; + if (yych <= 'Q') goto yy516; + if (yych <= 'S') goto yy519; + if (yych <= 'q') goto yy516; + if (yych <= 's') goto yy519; + goto yy516; +yy551: + yych = *++p; + if (yych == 'I') goto yy519; + if (yych == 'i') goto yy519; + goto yy516; +yy552: + yych = *++p; + if (yych == 'I') goto yy573; + if (yych == 'i') goto yy573; + goto yy516; +yy553: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') goto yy563; + if (yych <= 'O') goto yy516; + goto yy564; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy516; + goto yy563; + } else { + if (yych == 'p') goto yy564; + goto yy516; + } + } +yy554: + yych = *++p; + if (yych == 'O') goto yy555; + if (yych != 'o') goto yy516; +yy555: + yych = *++p; + if (yych == 'N') goto yy556; + if (yych != 'n') goto yy516; +yy556: + yych = *++p; + if (yych == '-') goto yy557; + if (yych == ':') goto yy520; + goto yy516; +yy557: + yych = *++p; + if (yych == 'U') goto yy558; + if (yych != 'u') goto yy516; +yy558: + yych = *++p; + if (yych == 'S') goto yy559; + if (yych != 's') goto yy516; +yy559: + yych = *++p; + if (yych == 'E') goto yy560; + if (yych != 'e') goto yy516; +yy560: + yych = *++p; + if (yych == 'R') goto yy561; + if (yych != 'r') goto yy516; +yy561: + yych = *++p; + if (yych == 'I') goto yy562; + if (yych != 'i') goto yy516; +yy562: + yych = *++p; + if (yych == 'D') goto yy519; + if (yych == 'd') goto yy519; + goto yy516; +yy563: + yych = *++p; + if (yych == 'R') goto yy565; + if (yych == 'r') goto yy565; + goto yy516; +yy564: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy565: + yych = *++p; + if (yych == 'P') goto yy566; + if (yych != 'p') goto yy516; +yy566: + yych = *++p; + if (yych == 'C') goto yy567; + if (yych != 'c') goto yy516; +yy567: + yych = *++p; + if (yych != '.') goto yy516; + yych = *++p; + if (yych == 'B') goto yy569; + if (yych != 'b') goto yy516; +yy569: + yych = *++p; + if (yych == 'E') goto yy570; + if (yych != 'e') goto yy516; +yy570: + yych = *++p; + if (yych == 'E') goto yy571; + if (yych != 'e') goto yy516; +yy571: + yych = *++p; + if (yych == 'P') goto yy572; + if (yych != 'p') goto yy516; +yy572: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; + } +yy573: + yych = *++p; + if (yych == 'R') goto yy574; + if (yych != 'r') goto yy516; +yy574: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy575: + yych = *++p; + if (yych == 'C') goto yy583; + if (yych == 'c') goto yy583; + goto yy516; +yy576: + yych = *++p; + if (yych == 'A') goto yy582; + if (yych == 'a') goto yy582; + goto yy516; +yy577: + yych = *++p; + if (yych == 'B') goto yy579; + if (yych == 'b') goto yy579; + goto yy516; +yy578: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; + } +yy579: + yych = *++p; + if (yych == 'C') goto yy580; + if (yych != 'c') goto yy516; +yy580: + yych = *++p; + if (yych == 'A') goto yy581; + if (yych != 'a') goto yy516; +yy581: + yych = *++p; + if (yych == 'L') goto yy519; + if (yych == 'l') goto yy519; + goto yy516; +yy582: + yych = *++p; + if (yych == 'I') goto yy519; + if (yych == 'i') goto yy519; + goto yy516; +yy583: + yych = *++p; + if (yych == 'I') goto yy584; + if (yych != 'i') goto yy516; +yy584: + yych = *++p; + if (yych == 'W') goto yy585; + if (yych != 'w') goto yy516; +yy585: + yych = *++p; + if (yych == 'Y') goto yy586; + if (yych != 'y') goto yy516; +yy586: + yych = *++p; + if (yych == 'G') goto yy519; + if (yych == 'g') goto yy519; + goto yy516; +yy587: + yych = *++p; + if (yych == 'E') goto yy596; + if (yych == 'e') goto yy596; + goto yy516; +yy588: + yych = *++p; + if (yych <= 'N') { + if (yych <= 'L') goto yy516; + if (yych >= 'N') goto yy590; + } else { + if (yych <= 'l') goto yy516; + if (yych <= 'm') goto yy589; + if (yych <= 'n') goto yy590; + goto yy516; + } +yy589: + yych = *++p; + if (yych == 'M') goto yy595; + if (yych == 'm') goto yy595; + goto yy516; +yy590: + yych = *++p; + if (yych == 'T') goto yy591; + if (yych != 't') goto yy516; +yy591: + yych = *++p; + if (yych == 'R') goto yy592; + if (yych != 'r') goto yy516; +yy592: + yych = *++p; + if (yych == 'I') goto yy593; + if (yych != 'i') goto yy516; +yy593: + yych = *++p; + if (yych == 'L') goto yy594; + if (yych != 'l') goto yy516; +yy594: + yych = *++p; + if (yych == 'O') goto yy519; + if (yych == 'o') goto yy519; + goto yy516; +yy595: + yych = *++p; + if (yych == 'I') goto yy519; + if (yych == 'i') goto yy519; + goto yy516; +yy596: + yych = *++p; + if (yych == 'W') goto yy597; + if (yych != 'w') goto yy516; +yy597: + yych = *++p; + if (yych != '-') goto yy516; + yych = *++p; + if (yych == 'S') goto yy599; + if (yych != 's') goto yy516; +yy599: + yych = *++p; + if (yych == 'O') goto yy600; + if (yych != 'o') goto yy516; +yy600: + yych = *++p; + if (yych == 'U') goto yy601; + if (yych != 'u') goto yy516; +yy601: + yych = *++p; + if (yych == 'R') goto yy602; + if (yych != 'r') goto yy516; +yy602: + yych = *++p; + if (yych == 'C') goto yy603; + if (yych != 'c') goto yy516; +yy603: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy604: + yych = *++p; + if (yych == '2') goto yy611; + goto yy516; +yy605: + yych = *++p; + if (yych == 'R') goto yy608; + if (yych == 'r') goto yy608; + goto yy516; +yy606: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy607: + yych = *++p; + if (yych == 'N') goto yy519; + if (yych == 'n') goto yy519; + goto yy516; +yy608: + yych = *++p; + if (yych == 'E') goto yy609; + if (yych != 'e') goto yy516; +yy609: + yych = *++p; + if (yych == 'A') goto yy610; + if (yych != 'a') goto yy516; +yy610: + yych = *++p; + if (yych == 'L') goto yy519; + if (yych == 'l') goto yy519; + goto yy516; +yy611: + yych = *++p; + if (yych != '0') goto yy516; + yych = *++p; + if (yych != '0') goto yy516; + yych = *++p; + if (yych == '4') goto yy519; + goto yy516; +yy614: + yych = *++p; + if (yych == 'I') goto yy633; + if (yych == 'i') goto yy633; + goto yy516; +yy615: + yych = *++p; + if (yych <= 'L') { + if (yych == 'A') goto yy625; + if (yych <= 'K') goto yy516; + goto yy624; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy516; + goto yy625; + } else { + if (yych == 'l') goto yy624; + goto yy516; + } + } +yy616: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy617: + yych = *++p; + if (yych == '3') goto yy621; + goto yy516; +yy618: + yych = *++p; + if (yych == 'T') goto yy620; + if (yych == 't') goto yy620; + goto yy516; +yy619: + yych = *++p; + if (yych == 'G') goto yy519; + if (yych == 'g') goto yy519; + goto yy516; +yy620: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy621: + yych = *++p; + if (yych != '2') goto yy516; + yych = *++p; + if (yych != '7') goto yy516; + yych = *++p; + if (yych == '0') goto yy519; + goto yy516; +yy624: + yych = *++p; + if (yych <= 'M') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'N') goto yy631; + if (yych == 'n') goto yy631; + goto yy516; + } +yy625: + yych = *++p; + if (yych == 'M') goto yy626; + if (yych != 'm') goto yy516; +yy626: + yych = *++p; + if (yych == 'S') goto yy627; + if (yych != 's') goto yy516; +yy627: + yych = *++p; + if (yych == 'P') goto yy628; + if (yych != 'p') goto yy516; +yy628: + yych = *++p; + if (yych == 'E') goto yy629; + if (yych != 'e') goto yy516; +yy629: + yych = *++p; + if (yych == 'A') goto yy630; + if (yych != 'a') goto yy516; +yy630: + yych = *++p; + if (yych == 'K') goto yy519; + if (yych == 'k') goto yy519; + goto yy516; +yy631: + yych = *++p; + if (yych == 'E') goto yy632; + if (yych != 'e') goto yy516; +yy632: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy633: + yych = *++p; + if (yych <= 'S') { + if (yych == 'N') goto yy634; + if (yych <= 'R') goto yy516; + goto yy635; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy516; + } else { + if (yych == 's') goto yy635; + goto yy516; + } + } +yy634: + yych = *++p; + if (yych == 'G') goto yy642; + if (yych == 'g') goto yy642; + goto yy516; +yy635: + yych = *++p; + if (yych == 'M') goto yy636; + if (yych != 'm') goto yy516; +yy636: + yych = *++p; + if (yych == 'E') goto yy637; + if (yych != 'e') goto yy516; +yy637: + yych = *++p; + if (yych == 'S') goto yy638; + if (yych != 's') goto yy516; +yy638: + yych = *++p; + if (yych == 'S') goto yy639; + if (yych != 's') goto yy516; +yy639: + yych = *++p; + if (yych == 'A') goto yy640; + if (yych != 'a') goto yy516; +yy640: + yych = *++p; + if (yych == 'G') goto yy641; + if (yych != 'g') goto yy516; +yy641: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy642: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy643: + yych = *++p; + if (yych == 'N') goto yy519; + if (yych == 'n') goto yy519; + goto yy516; +yy644: + yych = *++p; + if (yych == 'E') goto yy694; + if (yych == 'e') goto yy694; + goto yy516; +yy645: + yych = *++p; + if (yych == 'H') goto yy519; + if (yych == 'h') goto yy519; + goto yy516; +yy646: + yych = *++p; + if (yych == 'O') goto yy690; + if (yych == 'o') goto yy690; + goto yy516; +yy647: + yych = *++p; + if (yych <= 'L') { + if (yych == 'A') goto yy680; + if (yych <= 'K') goto yy516; + goto yy681; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy516; + goto yy680; + } else { + if (yych == 'l') goto yy681; + goto yy516; + } + } +yy648: + yych = *++p; + if (yych <= 'S') { + if (yych == 'B') goto yy519; + if (yych <= 'R') goto yy516; + goto yy519; + } else { + if (yych <= 'b') { + if (yych <= 'a') goto yy516; + goto yy519; + } else { + if (yych == 's') goto yy519; + goto yy516; + } + } +yy649: + yych = *++p; + if (yych == 'Y') goto yy678; + if (yych == 'y') goto yy678; + goto yy516; +yy650: + yych = *++p; + if (yych == 'N') goto yy519; + if (yych == 'n') goto yy519; + goto yy516; +yy651: + yych = *++p; + if (yych == 'T') goto yy677; + if (yych == 't') goto yy677; + goto yy516; +yy652: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'C') { + if (yych <= 'B') goto yy516; + goto yy664; + } else { + if (yych <= 'Q') goto yy516; + if (yych <= 'R') goto yy662; + goto yy663; + } + } else { + if (yych <= 'q') { + if (yych == 'c') goto yy664; + goto yy516; + } else { + if (yych <= 'r') goto yy662; + if (yych <= 's') goto yy663; + goto yy516; + } + } +yy653: + yych = *++p; + if (yych == 'M') goto yy661; + if (yych == 'm') goto yy661; + goto yy516; +yy654: + yych = *++p; + if (yych <= 'P') { + if (yych == 'E') goto yy658; + if (yych <= 'O') goto yy516; + goto yy659; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy516; + goto yy658; + } else { + if (yych == 'p') goto yy659; + goto yy516; + } + } +yy655: + yych = *++p; + if (yych == 'T') goto yy656; + if (yych != 't') goto yy516; +yy656: + yych = *++p; + if (yych == 'T') goto yy657; + if (yych != 't') goto yy516; +yy657: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy658: + yych = *++p; + if (yych == 'V') goto yy660; + if (yych == 'v') goto yy660; + goto yy516; +yy659: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; + } +yy660: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy661: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy662: + yych = *++p; + if (yych == 'V') goto yy674; + if (yych == 'v') goto yy674; + goto yy516; +yy663: + yych = *++p; + if (yych == 'S') goto yy671; + if (yych == 's') goto yy671; + goto yy516; +yy664: + yych = *++p; + if (yych == 'O') goto yy665; + if (yych != 'o') goto yy516; +yy665: + yych = *++p; + if (yych == 'N') goto yy666; + if (yych != 'n') goto yy516; +yy666: + yych = *++p; + if (yych == 'D') goto yy667; + if (yych != 'd') goto yy516; +yy667: + yych = *++p; + if (yych == 'L') goto yy668; + if (yych != 'l') goto yy516; +yy668: + yych = *++p; + if (yych == 'I') goto yy669; + if (yych != 'i') goto yy516; +yy669: + yych = *++p; + if (yych == 'F') goto yy670; + if (yych != 'f') goto yy516; +yy670: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy671: + yych = *++p; + if (yych == 'I') goto yy672; + if (yych != 'i') goto yy516; +yy672: + yych = *++p; + if (yych == 'O') goto yy673; + if (yych != 'o') goto yy516; +yy673: + yych = *++p; + if (yych == 'N') goto yy519; + if (yych == 'n') goto yy519; + goto yy516; +yy674: + yych = *++p; + if (yych == 'I') goto yy675; + if (yych != 'i') goto yy516; +yy675: + yych = *++p; + if (yych == 'C') goto yy676; + if (yych != 'c') goto yy516; +yy676: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy677: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy678: + yych = *++p; + if (yych == 'P') goto yy679; + if (yych != 'p') goto yy516; +yy679: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy680: + yych = *++p; + if (yych == 'P') goto yy684; + if (yych == 'p') goto yy684; + goto yy516; +yy681: + yych = *++p; + if (yych == 'D') goto yy682; + if (yych != 'd') goto yy516; +yy682: + yych = *++p; + if (yych == 'A') goto yy683; + if (yych != 'a') goto yy516; +yy683: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy684: + yych = *++p; + if (yych != '.') goto yy516; + yych = *++p; + if (yych == 'B') goto yy686; + if (yych != 'b') goto yy516; +yy686: + yych = *++p; + if (yych == 'E') goto yy687; + if (yych != 'e') goto yy516; +yy687: + yych = *++p; + if (yych == 'E') goto yy688; + if (yych != 'e') goto yy516; +yy688: + yych = *++p; + if (yych == 'P') goto yy689; + if (yych != 'p') goto yy516; +yy689: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; + } +yy690: + yych = *++p; + if (yych == 'T') goto yy691; + if (yych != 't') goto yy516; +yy691: + yych = *++p; + if (yych == 'I') goto yy692; + if (yych != 'i') goto yy516; +yy692: + yych = *++p; + if (yych == 'F') goto yy693; + if (yych != 'f') goto yy516; +yy693: + yych = *++p; + if (yych == 'Y') goto yy519; + if (yych == 'y') goto yy519; + goto yy516; +yy694: + yych = *++p; + if (yych == 'A') goto yy695; + if (yych != 'a') goto yy516; +yy695: + yych = *++p; + if (yych == 'M') goto yy519; + if (yych == 'm') goto yy519; + goto yy516; +yy696: + yych = *++p; + if (yych <= 'S') { + if (yych == 'M') goto yy708; + if (yych <= 'R') goto yy516; + goto yy707; + } else { + if (yych <= 'm') { + if (yych <= 'l') goto yy516; + goto yy708; + } else { + if (yych == 's') goto yy707; + goto yy516; + } + } +yy697: + yych = *++p; + if (yych == 'Y') goto yy705; + if (yych == 'y') goto yy705; + goto yy516; +yy698: + yych = *++p; + if (yych == 'I') goto yy519; + if (yych == 'i') goto yy519; + goto yy516; +yy699: + yych = *++p; + if (yych == 'S') goto yy700; + if (yych != 's') goto yy516; +yy700: + yych = *++p; + if (yych <= 'N') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'O') goto yy701; + if (yych != 'o') goto yy516; + } +yy701: + yych = *++p; + if (yych == 'U') goto yy702; + if (yych != 'u') goto yy516; +yy702: + yych = *++p; + if (yych == 'R') goto yy703; + if (yych != 'r') goto yy516; +yy703: + yych = *++p; + if (yych == 'C') goto yy704; + if (yych != 'c') goto yy516; +yy704: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy705: + yych = *++p; + if (yych == 'N') goto yy706; + if (yych != 'n') goto yy516; +yy706: + yych = *++p; + if (yych == 'C') goto yy519; + if (yych == 'c') goto yy519; + goto yy516; +yy707: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy708: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy709: + yych = *++p; + if (yych == 'Y') goto yy729; + if (yych == 'y') goto yy729; + goto yy516; +yy710: + yych = *++p; + if (yych <= 'O') { + if (yych == 'E') goto yy726; + if (yych <= 'N') goto yy516; + goto yy727; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy516; + goto yy726; + } else { + if (yych == 'o') goto yy727; + goto yy516; + } + } +yy711: + yych = *++p; + if (yych == 'A') goto yy721; + if (yych == 'a') goto yy721; + goto yy516; +yy712: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') goto yy714; + if (yych <= 'O') goto yy516; + goto yy715; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy516; + goto yy714; + } else { + if (yych == 'p') goto yy715; + goto yy516; + } + } +yy713: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy714: + yych = *++p; + if (yych == 'M') goto yy519; + if (yych == 'm') goto yy519; + goto yy516; +yy715: + yych = *++p; + if (yych == 'A') goto yy716; + if (yych != 'a') goto yy516; +yy716: + yych = *++p; + if (yych == 'R') goto yy717; + if (yych != 'r') goto yy516; +yy717: + yych = *++p; + if (yych == 'A') goto yy718; + if (yych != 'a') goto yy516; +yy718: + yych = *++p; + if (yych == 'Z') goto yy719; + if (yych != 'z') goto yy516; +yy719: + yych = *++p; + if (yych == 'Z') goto yy720; + if (yych != 'z') goto yy516; +yy720: + yych = *++p; + if (yych == 'I') goto yy519; + if (yych == 'i') goto yy519; + goto yy516; +yy721: + yych = *++p; + if (yych == 'T') goto yy722; + if (yych != 't') goto yy516; +yy722: + yych = *++p; + if (yych == 'F') goto yy723; + if (yych != 'f') goto yy516; +yy723: + yych = *++p; + if (yych == 'O') goto yy724; + if (yych != 'o') goto yy516; +yy724: + yych = *++p; + if (yych == 'R') goto yy725; + if (yych != 'r') goto yy516; +yy725: + yych = *++p; + if (yych == 'M') goto yy519; + if (yych == 'm') goto yy519; + goto yy516; +yy726: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy727: + yych = *++p; + if (yych == 'X') goto yy728; + if (yych != 'x') goto yy516; +yy728: + yych = *++p; + if (yych == 'Y') goto yy519; + if (yych == 'y') goto yy519; + goto yy516; +yy729: + yych = *++p; + if (yych == 'C') goto yy519; + if (yych == 'c') goto yy519; + goto yy516; +yy730: + yych = *++p; + if (yych == 'D') goto yy519; + if (yych == 'd') goto yy519; + goto yy516; +yy731: + yych = *++p; + if (yych == 'A') goto yy732; + if (yych != 'a') goto yy516; +yy732: + yych = *++p; + if (yych == 'Q') goto yy733; + if (yych != 'q') goto yy516; +yy733: + yych = *++p; + if (yych == 'U') goto yy734; + if (yych != 'u') goto yy516; +yy734: + yych = *++p; + if (yych == 'E') goto yy735; + if (yych != 'e') goto yy516; +yy735: + yych = *++p; + if (yych == 'L') goto yy736; + if (yych != 'l') goto yy516; +yy736: + yych = *++p; + if (yych == 'O') goto yy737; + if (yych != 'o') goto yy516; +yy737: + yych = *++p; + if (yych == 'C') goto yy738; + if (yych != 'c') goto yy516; +yy738: + yych = *++p; + if (yych == 'K') goto yy739; + if (yych != 'k') goto yy516; +yy739: + yych = *++p; + if (yych == 'T') goto yy740; + if (yych != 't') goto yy516; +yy740: + yych = *++p; + if (yych == 'O') goto yy741; + if (yych != 'o') goto yy516; +yy741: + yych = *++p; + if (yych == 'K') goto yy742; + if (yych != 'k') goto yy516; +yy742: + yych = *++p; + if (yych == 'E') goto yy743; + if (yych != 'e') goto yy516; +yy743: + yych = *++p; + if (yych == 'N') goto yy519; + if (yych == 'n') goto yy519; + goto yy516; +yy744: + yych = *++p; + if (yych == 'T') goto yy751; + if (yych == 't') goto yy751; + goto yy516; +yy745: + yych = *++p; + if (yych == 'T') goto yy750; + if (yych == 't') goto yy750; + goto yy516; +yy746: + yych = *++p; + if (yych <= 'G') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'H') goto yy519; + if (yych == 'h') goto yy519; + goto yy516; + } +yy747: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy748: + yych = *++p; + if (yych == 'W') goto yy749; + if (yych != 'w') goto yy516; +yy749: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy750: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy751: + yych = *++p; + if (yych == 'E') goto yy752; + if (yych != 'e') goto yy516; +yy752: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy753: + yych = *++p; + if (yych == 'N') goto yy519; + if (yych == 'n') goto yy519; + goto yy516; +yy754: + yych = *++p; + if (yych <= 'P') { + if (yych == 'M') goto yy785; + if (yych <= 'O') goto yy516; + goto yy784; + } else { + if (yych <= 'm') { + if (yych <= 'l') goto yy516; + goto yy785; + } else { + if (yych == 'p') goto yy784; + goto yy516; + } + } +yy755: + yych = *++p; + if (yych <= 'Q') { + if (yych <= '-') { + if (yych <= ',') goto yy516; + goto yy777; + } else { + if (yych == 'N') goto yy778; + goto yy516; + } + } else { + if (yych <= 'n') { + if (yych <= 'R') goto yy776; + if (yych <= 'm') goto yy516; + goto yy778; + } else { + if (yych == 'r') goto yy776; + goto yy516; + } + } +yy756: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy757: + yych = *++p; + if (yych == 'S') goto yy772; + if (yych == 's') goto yy772; + goto yy516; +yy758: + yych = *++p; + switch (yych) { + case 'G': + case 'g': goto yy763; + case 'I': + case 'i': goto yy762; + case 'P': + case 'p': goto yy764; + case 'R': + case 'r': goto yy765; + default: goto yy516; + } +yy759: + yych = *++p; + if (yych == 'Q') goto yy761; + if (yych == 'q') goto yy761; + goto yy516; +yy760: + yych = *++p; + if (yych == 'D') goto yy519; + if (yych == 'd') goto yy519; + goto yy516; +yy761: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy762: + yych = *++p; + if (yych == 'L') goto yy770; + if (yych == 'l') goto yy770; + goto yy516; +yy763: + yych = *++p; + if (yych == 'N') goto yy768; + if (yych == 'n') goto yy768; + goto yy516; +yy764: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy765: + yych = *++p; + if (yych == 'K') goto yy766; + if (yych != 'k') goto yy516; +yy766: + yych = *++p; + if (yych == 'E') goto yy767; + if (yych != 'e') goto yy516; +yy767: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy768: + yych = *++p; + if (yych == 'E') goto yy769; + if (yych != 'e') goto yy516; +yy769: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy770: + yych = *++p; + if (yych == 'T') goto yy771; + if (yych != 't') goto yy516; +yy771: + yych = *++p; + if (yych == 'O') goto yy519; + if (yych == 'o') goto yy519; + goto yy516; +yy772: + yych = *++p; + if (yych == 'S') goto yy773; + if (yych != 's') goto yy516; +yy773: + yych = *++p; + if (yych == 'A') goto yy774; + if (yych != 'a') goto yy516; +yy774: + yych = *++p; + if (yych == 'G') goto yy775; + if (yych != 'g') goto yy516; +yy775: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy776: + yych = *++p; + if (yych == 'P') goto yy783; + if (yych == 'p') goto yy783; + goto yy516; +yy777: + yych = *++p; + if (yych == 'H') goto yy780; + if (yych == 'h') goto yy780; + goto yy516; +yy778: + yych = *++p; + if (yych == 'I') goto yy779; + if (yych != 'i') goto yy516; +yy779: + yych = *++p; + if (yych == 'M') goto yy519; + if (yych == 'm') goto yy519; + goto yy516; +yy780: + yych = *++p; + if (yych == 'E') goto yy781; + if (yych != 'e') goto yy516; +yy781: + yych = *++p; + if (yych == 'L') goto yy782; + if (yych != 'l') goto yy516; +yy782: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy783: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; + } +yy784: + yych = *++p; + if (yych == 'D') goto yy788; + if (yych == 'd') goto yy788; + goto yy516; +yy785: + yych = *++p; + if (yych == 'B') goto yy786; + if (yych != 'b') goto yy516; +yy786: + yych = *++p; + if (yych == 'L') goto yy787; + if (yych != 'l') goto yy516; +yy787: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy788: + yych = *++p; + if (yych == 'A') goto yy789; + if (yych != 'a') goto yy516; +yy789: + yych = *++p; + if (yych == 'T') goto yy790; + if (yych != 't') goto yy516; +yy790: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy791: + yych = *++p; + if (yych == 'A') goto yy796; + if (yych == 'a') goto yy796; + goto yy516; +yy792: + yych = *++p; + if (yych == 'S') goto yy793; + if (yych != 's') goto yy516; +yy793: + yych = *++p; + if (yych == 'T') goto yy794; + if (yych != 't') goto yy516; +yy794: + yych = *++p; + if (yych == 'F') goto yy795; + if (yych != 'f') goto yy516; +yy795: + yych = *++p; + if (yych == 'M') goto yy519; + if (yych == 'm') goto yy519; + goto yy516; +yy796: + yych = *++p; + if (yych == 'P') goto yy797; + if (yych != 'p') goto yy516; +yy797: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; + } +yy798: + yych = *++p; + if (yych == 'M') goto yy821; + if (yych == 'm') goto yy821; + goto yy516; +yy799: + yych = *++p; + if (yych <= 'I') { + if (yych == 'C') goto yy810; + if (yych <= 'H') goto yy516; + goto yy809; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy516; + goto yy810; + } else { + if (yych == 'i') goto yy809; + goto yy516; + } + } +yy800: + yych = *++p; + if (yych <= 'P') { + if (yych == 'N') goto yy519; + if (yych <= 'O') goto yy516; + goto yy519; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy516; + goto yy519; + } else { + if (yych == 'p') goto yy519; + goto yy516; + } + } +yy801: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') goto yy807; + if (yych <= 'N') goto yy516; + goto yy808; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy516; + goto yy807; + } else { + if (yych == 'o') goto yy808; + goto yy516; + } + } +yy802: + yych = *++p; + if (yych == 'F') goto yy806; + if (yych == 'f') goto yy806; + goto yy516; +yy803: + yych = *++p; + if (yych <= '@') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'A') goto yy805; + if (yych == 'a') goto yy805; + goto yy516; + } +yy804: + yych = *++p; + if (yych == 'X') goto yy519; + if (yych == 'x') goto yy519; + goto yy516; +yy805: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy806: + yych = *++p; + if (yych == 'O') goto yy519; + if (yych == 'o') goto yy519; + goto yy516; +yy807: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy808: + yych = *++p; + if (yych == 'N') goto yy519; + if (yych == 'n') goto yy519; + goto yy516; +yy809: + yych = *++p; + if (yych == 'S') goto yy811; + if (yych == 's') goto yy811; + goto yy516; +yy810: + yych = *++p; + if (yych <= ':') { + if (yych == '6') goto yy519; + if (yych <= '9') goto yy516; + goto yy520; + } else { + if (yych <= 'S') { + if (yych <= 'R') goto yy516; + goto yy519; + } else { + if (yych == 's') goto yy519; + goto yy516; + } + } +yy811: + yych = *++p; + if (yych == '.') goto yy812; + if (yych == ':') goto yy520; + goto yy516; +yy812: + yych = *++p; + if (yych <= 'X') { + if (yych <= 'K') { + if (yych == 'B') goto yy815; + goto yy516; + } else { + if (yych <= 'L') goto yy813; + if (yych <= 'W') goto yy516; + goto yy814; + } + } else { + if (yych <= 'k') { + if (yych == 'b') goto yy815; + goto yy516; + } else { + if (yych <= 'l') goto yy813; + if (yych == 'x') goto yy814; + goto yy516; + } + } +yy813: + yych = *++p; + if (yych == 'W') goto yy820; + if (yych == 'w') goto yy820; + goto yy516; +yy814: + yych = *++p; + if (yych == 'P') goto yy818; + if (yych == 'p') goto yy818; + goto yy516; +yy815: + yych = *++p; + if (yych == 'E') goto yy816; + if (yych != 'e') goto yy516; +yy816: + yych = *++p; + if (yych == 'E') goto yy817; + if (yych != 'e') goto yy516; +yy817: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy818: + yych = *++p; + if (yych == 'C') goto yy819; + if (yych != 'c') goto yy516; +yy819: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; + } +yy820: + yych = *++p; + if (yych == 'Z') goto yy519; + if (yych == 'z') goto yy519; + goto yy516; +yy821: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy822: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy823: + yych = *++p; + if (yych == 'T') goto yy826; + if (yych == 't') goto yy826; + goto yy516; +yy824: + yych = *++p; + if (yych != '2') goto yy516; + yych = *++p; + if (yych == '3') goto yy519; + goto yy516; +yy826: + yych = *++p; + if (yych == 'P') goto yy827; + if (yych != 'p') goto yy516; +yy827: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; + } +yy828: + yych = *++p; + if (yych == 'A') goto yy844; + if (yych == 'a') goto yy844; + goto yy516; +yy829: + yych = *++p; + if (yych <= 'Z') { + if (yych == 'T') goto yy519; + if (yych <= 'Y') goto yy516; + goto yy835; + } else { + if (yych <= 't') { + if (yych <= 's') goto yy516; + goto yy519; + } else { + if (yych == 'z') goto yy835; + goto yy516; + } + } +yy830: + yych = *++p; + if (yych <= 'O') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'P') goto yy832; + if (yych == 'p') goto yy832; + goto yy516; + } +yy831: + yych = *++p; + if (yych == 'O') goto yy519; + if (yych == 'o') goto yy519; + goto yy516; +yy832: + yych = *++p; + if (yych == 'H') goto yy833; + if (yych != 'h') goto yy516; +yy833: + yych = *++p; + if (yych == 'E') goto yy834; + if (yych != 'e') goto yy516; +yy834: + yych = *++p; + if (yych == 'R') goto yy519; + if (yych == 'r') goto yy519; + goto yy516; +yy835: + yych = *++p; + if (yych == 'M') goto yy836; + if (yych != 'm') goto yy516; +yy836: + yych = *++p; + if (yych == 'O') goto yy837; + if (yych != 'o') goto yy516; +yy837: + yych = *++p; + if (yych == 'P') goto yy838; + if (yych != 'p') goto yy516; +yy838: + yych = *++p; + if (yych == 'R') goto yy839; + if (yych != 'r') goto yy516; +yy839: + yych = *++p; + if (yych == 'O') goto yy840; + if (yych != 'o') goto yy516; +yy840: + yych = *++p; + if (yych == 'J') goto yy841; + if (yych != 'j') goto yy516; +yy841: + yych = *++p; + if (yych == 'E') goto yy842; + if (yych != 'e') goto yy516; +yy842: + yych = *++p; + if (yych == 'C') goto yy843; + if (yych != 'c') goto yy516; +yy843: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy844: + yych = *++p; + if (yych == 'L') goto yy845; + if (yych != 'l') goto yy516; +yy845: + yych = *++p; + if (yych == 'K') goto yy519; + if (yych == 'k') goto yy519; + goto yy516; +yy846: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'M') { + if (yych == 'L') goto yy856; + goto yy516; + } else { + if (yych <= 'N') goto yy857; + if (yych <= 'R') goto yy516; + goto yy858; + } + } else { + if (yych <= 'm') { + if (yych == 'l') goto yy856; + goto yy516; + } else { + if (yych <= 'n') goto yy857; + if (yych == 's') goto yy858; + goto yy516; + } + } +yy847: + yych = *++p; + if (yych == 'E') goto yy855; + if (yych == 'e') goto yy855; + goto yy516; +yy848: + yych = *++p; + if (yych == 'C') goto yy850; + if (yych == 'c') goto yy850; + goto yy516; +yy849: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy850: + yych = *++p; + if (yych == 'E') goto yy851; + if (yych != 'e') goto yy516; +yy851: + yych = *++p; + if (yych == 'T') goto yy852; + if (yych != 't') goto yy516; +yy852: + yych = *++p; + if (yych == 'I') goto yy853; + if (yych != 'i') goto yy516; +yy853: + yych = *++p; + if (yych == 'M') goto yy854; + if (yych != 'm') goto yy516; +yy854: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy855: + yych = *++p; + if (yych == 'D') goto yy519; + if (yych == 'd') goto yy519; + goto yy516; +yy856: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy857: + yych = *++p; + if (yych == 'G') goto yy859; + if (yych == 'g') goto yy859; + goto yy516; +yy858: + yych = *++p; + if (yych == 'H') goto yy519; + if (yych == 'h') goto yy519; + goto yy516; +yy859: + yych = *++p; + if (yych == 'E') goto yy860; + if (yych != 'e') goto yy516; +yy860: + yych = *++p; + if (yych == 'R') goto yy519; + if (yych == 'r') goto yy519; + goto yy516; +yy861: + yych = *++p; + if (yych == 'T') goto yy879; + if (yych == 't') goto yy879; + goto yy516; +yy862: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy863: + yych = *++p; + if (yych == 'M') goto yy519; + if (yych == 'm') goto yy519; + goto yy516; +yy864: + yych = *++p; + if (yych <= 'S') { + if (yych == 'P') goto yy519; + if (yych <= 'R') goto yy516; + goto yy519; + } else { + if (yych <= 'p') { + if (yych <= 'o') goto yy516; + goto yy519; + } else { + if (yych == 's') goto yy519; + goto yy516; + } + } +yy865: + yych = *++p; + if (yych == 'I') goto yy873; + if (yych == 'i') goto yy873; + goto yy516; +yy866: + yych = *++p; + if (yych == 'A') goto yy872; + if (yych == 'a') goto yy872; + goto yy516; +yy867: + yych = *++p; + if (yych == 'O') goto yy870; + if (yych == 'o') goto yy870; + goto yy516; +yy868: + yych = *++p; + if (yych == 'A') goto yy869; + if (yych != 'a') goto yy516; +yy869: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy520; + goto yy516; + } else { + if (yych <= 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; + } +yy870: + yych = *++p; + if (yych == 'U') goto yy871; + if (yych != 'u') goto yy516; +yy871: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy872: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy873: + yych = *++p; + if (yych == 'U') goto yy874; + if (yych != 'u') goto yy516; +yy874: + yych = *++p; + if (yych == 'M') goto yy875; + if (yych != 'm') goto yy516; +yy875: + yych = *++p; + if (yych == 'X') goto yy876; + if (yych != 'x') goto yy516; +yy876: + yych = *++p; + if (yych == 'T') goto yy877; + if (yych != 't') goto yy516; +yy877: + yych = *++p; + if (yych == 'R') goto yy878; + if (yych != 'r') goto yy516; +yy878: + yych = *++p; + if (yych == 'A') goto yy519; + if (yych == 'a') goto yy519; + goto yy516; +yy879: + yych = *++p; + if (yych == 'A') goto yy880; + if (yych != 'a') goto yy516; +yy880: + yych = *++p; + if (yych == 'C') goto yy881; + if (yych != 'c') goto yy516; +yy881: + yych = *++p; + if (yych == 'H') goto yy882; + if (yych != 'h') goto yy516; +yy882: + yych = *++p; + if (yych == 'M') goto yy883; + if (yych != 'm') goto yy516; +yy883: + yych = *++p; + if (yych == 'E') goto yy884; + if (yych != 'e') goto yy516; +yy884: + yych = *++p; + if (yych == 'N') goto yy885; + if (yych != 'n') goto yy516; +yy885: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy886: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy887: + yych = *++p; + if (yych <= 'V') { + if (yych == 'R') goto yy519; + if (yych <= 'U') goto yy516; + } else { + if (yych <= 'r') { + if (yych <= 'q') goto yy516; + goto yy519; + } else { + if (yych != 'v') goto yy516; + } + } + yych = *++p; + if (yych == 'A') goto yy889; + if (yych != 'a') goto yy516; +yy889: + yych = *++p; + if (yych == 'S') goto yy890; + if (yych != 's') goto yy516; +yy890: + yych = *++p; + if (yych == 'C') goto yy891; + if (yych != 'c') goto yy516; +yy891: + yych = *++p; + if (yych == 'R') goto yy892; + if (yych != 'r') goto yy516; +yy892: + yych = *++p; + if (yych == 'I') goto yy893; + if (yych != 'i') goto yy516; +yy893: + yych = *++p; + if (yych == 'P') goto yy894; + if (yych != 'p') goto yy516; +yy894: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy895: + yych = *++p; + if (yych == 'B') goto yy519; + if (yych == 'b') goto yy519; + goto yy516; +yy896: + yych = *++p; + if (yych == 'N') goto yy519; + if (yych == 'n') goto yy519; + goto yy516; +yy897: + yych = *++p; + if (yych == 'N') goto yy904; + if (yych == 'n') goto yy904; + goto yy516; +yy898: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy899: + yych = *++p; + if (yych == 'C') goto yy903; + if (yych == 'c') goto yy903; + goto yy516; +yy900: + yych = *++p; + if (yych <= 'V') { + if (yych == 'T') goto yy902; + if (yych <= 'U') goto yy516; + goto yy519; + } else { + if (yych <= 't') { + if (yych <= 's') goto yy516; + goto yy902; + } else { + if (yych == 'v') goto yy519; + goto yy516; + } + } +yy901: + yych = *++p; + if (yych == 'I') goto yy519; + if (yych == 'i') goto yy519; + goto yy516; +yy902: + yych = *++p; + if (yych == 'A') goto yy519; + if (yych == 'a') goto yy519; + goto yy516; +yy903: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy904: + yych = *++p; + if (yych == 'A') goto yy905; + if (yych != 'a') goto yy516; +yy905: + yych = *++p; + if (yych != '-') goto yy516; + yych = *++p; + if (yych == 'P') goto yy907; + if (yych != 'p') goto yy516; +yy907: + yych = *++p; + if (yych == 'L') goto yy908; + if (yych != 'l') goto yy516; +yy908: + yych = *++p; + if (yych == 'A') goto yy909; + if (yych != 'a') goto yy516; +yy909: + yych = *++p; + if (yych == 'Y') goto yy910; + if (yych != 'y') goto yy516; +yy910: + yych = *++p; + if (yych <= 'S') { + if (yych == 'C') goto yy911; + if (yych <= 'R') goto yy516; + goto yy912; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy516; + } else { + if (yych == 's') goto yy912; + goto yy516; + } + } +yy911: + yych = *++p; + if (yych == 'O') goto yy917; + if (yych == 'o') goto yy917; + goto yy516; +yy912: + yych = *++p; + if (yych == 'I') goto yy913; + if (yych != 'i') goto yy516; +yy913: + yych = *++p; + if (yych == 'N') goto yy914; + if (yych != 'n') goto yy516; +yy914: + yych = *++p; + if (yych == 'G') goto yy915; + if (yych != 'g') goto yy516; +yy915: + yych = *++p; + if (yych == 'L') goto yy916; + if (yych != 'l') goto yy516; +yy916: + yych = *++p; + if (yych == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +yy917: + yych = *++p; + if (yych == 'N') goto yy918; + if (yych != 'n') goto yy516; +yy918: + yych = *++p; + if (yych == 'T') goto yy919; + if (yych != 't') goto yy516; +yy919: + yych = *++p; + if (yych == 'A') goto yy920; + if (yych != 'a') goto yy516; +yy920: + yych = *++p; + if (yych == 'I') goto yy921; + if (yych != 'i') goto yy516; +yy921: + yych = *++p; + if (yych == 'N') goto yy922; + if (yych != 'n') goto yy516; +yy922: + yych = *++p; + if (yych == 'E') goto yy923; + if (yych != 'e') goto yy516; +yy923: + yych = *++p; + if (yych == 'R') goto yy519; + if (yych == 'r') goto yy519; + goto yy516; +yy924: + yych = *++p; + if (yych == 'S') goto yy519; + if (yych == 's') goto yy519; + goto yy516; +yy925: + yych = *++p; + if (yych <= 'N') { + if (yych <= 'A') { + if (yych <= '@') goto yy516; + goto yy947; + } else { + if (yych <= 'L') goto yy516; + if (yych <= 'M') goto yy948; + goto yy949; + } + } else { + if (yych <= 'l') { + if (yych == 'a') goto yy947; + goto yy516; + } else { + if (yych <= 'm') goto yy948; + if (yych <= 'n') goto yy949; + goto yy516; + } + } +yy926: + yych = *++p; + if (yych == 'R') goto yy934; + if (yych == 'r') goto yy934; + goto yy516; +yy927: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') goto yy931; + if (yych <= 'O') goto yy516; + goto yy519; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy516; + goto yy931; + } else { + if (yych == 'p') goto yy519; + goto yy516; + } + } +yy928: + yych = *++p; + if (yych == 'I') goto yy930; + if (yych == 'i') goto yy930; + goto yy516; +yy929: + yych = *++p; + if (yych == 'D') goto yy519; + if (yych == 'd') goto yy519; + goto yy516; +yy930: + yych = *++p; + if (yych == 'D') goto yy519; + if (yych == 'd') goto yy519; + goto yy516; +yy931: + yych = *++p; + if (yych == 'L') goto yy932; + if (yych != 'l') goto yy516; +yy932: + yych = *++p; + if (yych == 'T') goto yy933; + if (yych != 't') goto yy516; +yy933: + yych = *++p; + if (yych == 'O') goto yy519; + if (yych == 'o') goto yy519; + goto yy516; +yy934: + yych = *++p; + if (yych == 'O') goto yy935; + if (yych != 'o') goto yy516; +yy935: + yych = *++p; + if (yych == 'M') goto yy936; + if (yych != 'm') goto yy516; +yy936: + yych = *++p; + if (yych == 'E') goto yy937; + if (yych != 'e') goto yy516; +yy937: + yych = *++p; + if (yych == '-') goto yy938; + if (yych == ':') goto yy520; + goto yy516; +yy938: + yych = *++p; + if (yych == 'E') goto yy939; + if (yych != 'e') goto yy516; +yy939: + yych = *++p; + if (yych == 'X') goto yy940; + if (yych != 'x') goto yy516; +yy940: + yych = *++p; + if (yych == 'T') goto yy941; + if (yych != 't') goto yy516; +yy941: + yych = *++p; + if (yych == 'E') goto yy942; + if (yych != 'e') goto yy516; +yy942: + yych = *++p; + if (yych == 'N') goto yy943; + if (yych != 'n') goto yy516; +yy943: + yych = *++p; + if (yych == 'S') goto yy944; + if (yych != 's') goto yy516; +yy944: + yych = *++p; + if (yych == 'I') goto yy945; + if (yych != 'i') goto yy516; +yy945: + yych = *++p; + if (yych == 'O') goto yy946; + if (yych != 'o') goto yy516; +yy946: + yych = *++p; + if (yych == 'N') goto yy519; + if (yych == 'n') goto yy519; + goto yy516; +yy947: + yych = *++p; + if (yych == 'P') goto yy519; + if (yych == 'p') goto yy519; + goto yy516; +yy948: + yych = *++p; + if (yych == '-') goto yy953; + goto yy516; +yy949: + yych = *++p; + if (yych == 'T') goto yy950; + if (yych != 't') goto yy516; +yy950: + yych = *++p; + if (yych == 'E') goto yy951; + if (yych != 'e') goto yy516; +yy951: + yych = *++p; + if (yych == 'N') goto yy952; + if (yych != 'n') goto yy516; +yy952: + yych = *++p; + if (yych == 'T') goto yy519; + if (yych == 't') goto yy519; + goto yy516; +yy953: + yych = *++p; + if (yych == 'E') goto yy954; + if (yych != 'e') goto yy516; +yy954: + yych = *++p; + if (yych == 'V') goto yy955; + if (yych != 'v') goto yy516; +yy955: + yych = *++p; + if (yych == 'E') goto yy956; + if (yych != 'e') goto yy516; +yy956: + yych = *++p; + if (yych == 'N') goto yy957; + if (yych != 'n') goto yy516; +yy957: + yych = *++p; + if (yych == 'T') goto yy958; + if (yych != 't') goto yy516; +yy958: + yych = *++p; + if (yych == 'B') goto yy959; + if (yych != 'b') goto yy516; +yy959: + yych = *++p; + if (yych == 'R') goto yy960; + if (yych != 'r') goto yy516; +yy960: + yych = *++p; + if (yych == 'I') goto yy961; + if (yych != 'i') goto yy516; +yy961: + yych = *++p; + if (yych == 'T') goto yy962; + if (yych != 't') goto yy516; +yy962: + yych = *++p; + if (yych == 'E') goto yy963; + if (yych != 'e') goto yy516; +yy963: + yych = *++p; + if (yych != '-') goto yy516; + yych = *++p; + if (yych == 'A') goto yy965; + if (yych != 'a') goto yy516; +yy965: + yych = *++p; + if (yych == 'T') goto yy966; + if (yych != 't') goto yy516; +yy966: + yych = *++p; + if (yych == 'T') goto yy967; + if (yych != 't') goto yy516; +yy967: + yych = *++p; + if (yych == 'E') goto yy968; + if (yych != 'e') goto yy516; +yy968: + yych = *++p; + if (yych == 'N') goto yy969; + if (yych != 'n') goto yy516; +yy969: + yych = *++p; + if (yych == 'D') goto yy970; + if (yych != 'd') goto yy516; +yy970: + yych = *++p; + if (yych == 'E') goto yy971; + if (yych != 'e') goto yy516; +yy971: + ++p; + if ((yych = *p) == 'E') goto yy519; + if (yych == 'e') goto yy519; + goto yy516; +} + +} + +// 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 yy974; + if (yych <= ' ') goto yy976; + goto yy975; + } else { + if (yych <= '\'') { + if (yych <= '"') goto yy976; + goto yy975; + } else { + if (yych <= ')') goto yy976; + if (yych <= '+') goto yy975; + goto yy976; + } + } + } else { + if (yych <= '?') { + if (yych <= '<') { + if (yych <= '9') goto yy975; + goto yy976; + } else { + if (yych == '>') goto yy976; + goto yy975; + } + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy976; + goto yy975; + } else { + if (yych <= ']') goto yy976; + if (yych <= '~') goto yy975; + goto yy976; + } + } + } +yy974: + { return 0; } +yy975: + yych = *(marker = ++p); + if (yych <= ',') { + if (yych <= '"') { + if (yych == '!') goto yy980; + goto yy974; + } else { + if (yych <= '\'') goto yy980; + if (yych <= ')') goto yy974; + if (yych <= '+') goto yy980; + goto yy974; + } + } else { + if (yych <= '>') { + if (yych <= '9') goto yy980; + if (yych == '=') goto yy980; + goto yy974; + } else { + if (yych <= 'Z') goto yy980; + if (yych <= ']') goto yy974; + if (yych <= '~') goto yy980; + goto yy974; + } + } +yy976: + yych = *++p; + goto yy974; +yy977: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy981; + } else { + if (yych <= 'Z') goto yy981; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy981; + } +yy978: + p = marker; + goto yy974; +yy979: + ++p; + yych = *p; +yy980: + if (yybm[0+yych] & 128) { + goto yy979; + } + if (yych == '@') goto yy977; + goto yy978; +yy981: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; + } else { + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy983; + goto yy978; + } } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy514; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy983; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy514; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy983; + goto yy978; } } -yy512: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy1111; + if (yych <= '/') goto yy978; + goto yy1112; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy978; + goto yy1112; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1112; + goto yy978; + } + } +yy983: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy978; + if (yych <= '-') goto yy1111; + } else { + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1112; + goto yy978; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1112; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1112; + goto yy978; + } + } +yy984: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy987; + goto yy978; + } else { + if (yych <= 'Z') goto yy987; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy987; + goto yy978; + } +yy985: + ++p; + { return (p - start); } +yy987: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy514; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy989; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy514; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy989; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy514; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy989; + goto yy978; } } -yy513: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy515; - if (yych <= '/') goto yy493; - goto yy516; + if (yych == '-') goto yy990; + if (yych <= '/') goto yy978; + goto yy991; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy516; + if (yych <= '@') goto yy978; + goto yy991; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy516; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy991; + goto yy978; } } -yy514: +yy989: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy516; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy991; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy516; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy991; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy516; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy991; + goto yy978; } } -yy515: +yy990: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy517; - if (yych <= '/') goto yy493; - goto yy518; + if (yych == '-') goto yy992; + if (yych <= '/') goto yy978; + goto yy993; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy518; + if (yych <= '@') goto yy978; + goto yy993; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy518; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy993; + goto yy978; } } -yy516: +yy991: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy518; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy993; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy518; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy993; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy518; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy993; + goto yy978; } } -yy517: +yy992: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy519; - if (yych <= '/') goto yy493; - goto yy520; + if (yych == '-') goto yy994; + if (yych <= '/') goto yy978; + goto yy995; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy520; + if (yych <= '@') goto yy978; + goto yy995; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy520; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy995; + goto yy978; } } -yy518: +yy993: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy520; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy995; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy520; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy995; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy520; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy995; + goto yy978; } } -yy519: +yy994: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy521; - if (yych <= '/') goto yy493; - goto yy522; + if (yych == '-') goto yy996; + if (yych <= '/') goto yy978; + goto yy997; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy522; + if (yych <= '@') goto yy978; + goto yy997; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy522; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy997; + goto yy978; } } -yy520: +yy995: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy522; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy997; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy522; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy997; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy522; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy997; + goto yy978; } } -yy521: +yy996: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy523; - if (yych <= '/') goto yy493; - goto yy524; + if (yych == '-') goto yy998; + if (yych <= '/') goto yy978; + goto yy999; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy524; + if (yych <= '@') goto yy978; + goto yy999; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy524; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy999; + goto yy978; } } -yy522: +yy997: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy524; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy999; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy524; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy999; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy524; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy999; + goto yy978; } } -yy523: +yy998: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy525; - if (yych <= '/') goto yy493; - goto yy526; + if (yych == '-') goto yy1000; + if (yych <= '/') goto yy978; + goto yy1001; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy526; + if (yych <= '@') goto yy978; + goto yy1001; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy526; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1001; + goto yy978; } } -yy524: +yy999: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy526; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1001; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy526; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1001; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy526; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1001; + goto yy978; } } -yy525: +yy1000: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy527; - if (yych <= '/') goto yy493; - goto yy528; + if (yych == '-') goto yy1002; + if (yych <= '/') goto yy978; + goto yy1003; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy528; + if (yych <= '@') goto yy978; + goto yy1003; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy528; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1003; + goto yy978; } } -yy526: +yy1001: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy528; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1003; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy528; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1003; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy528; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1003; + goto yy978; } } -yy527: +yy1002: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy529; - if (yych <= '/') goto yy493; - goto yy530; + if (yych == '-') goto yy1004; + if (yych <= '/') goto yy978; + goto yy1005; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy530; + if (yych <= '@') goto yy978; + goto yy1005; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy530; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1005; + goto yy978; } } -yy528: +yy1003: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy530; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1005; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy530; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1005; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy530; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1005; + goto yy978; } } -yy529: +yy1004: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy531; - if (yych <= '/') goto yy493; - goto yy532; + if (yych == '-') goto yy1006; + if (yych <= '/') goto yy978; + goto yy1007; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy532; + if (yych <= '@') goto yy978; + goto yy1007; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy532; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1007; + goto yy978; } } -yy530: +yy1005: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy532; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1007; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy532; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1007; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy532; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1007; + goto yy978; } } -yy531: +yy1006: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy533; - if (yych <= '/') goto yy493; - goto yy534; + if (yych == '-') goto yy1008; + if (yych <= '/') goto yy978; + goto yy1009; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy534; + if (yych <= '@') goto yy978; + goto yy1009; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy534; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1009; + goto yy978; } } -yy532: +yy1007: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy534; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1009; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy534; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1009; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy534; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1009; + goto yy978; } } -yy533: +yy1008: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy535; - if (yych <= '/') goto yy493; - goto yy536; + if (yych == '-') goto yy1010; + if (yych <= '/') goto yy978; + goto yy1011; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy536; + if (yych <= '@') goto yy978; + goto yy1011; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy536; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1011; + goto yy978; } } -yy534: +yy1009: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy536; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1011; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy536; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1011; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy536; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1011; + goto yy978; } } -yy535: +yy1010: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy537; - if (yych <= '/') goto yy493; - goto yy538; + if (yych == '-') goto yy1012; + if (yych <= '/') goto yy978; + goto yy1013; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy538; + if (yych <= '@') goto yy978; + goto yy1013; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy538; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1013; + goto yy978; } } -yy536: +yy1011: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy538; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1013; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy538; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1013; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy538; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1013; + goto yy978; } } -yy537: +yy1012: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy539; - if (yych <= '/') goto yy493; - goto yy540; + if (yych == '-') goto yy1014; + if (yych <= '/') goto yy978; + goto yy1015; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy540; + if (yych <= '@') goto yy978; + goto yy1015; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy540; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1015; + goto yy978; } } -yy538: +yy1013: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy540; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1015; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy540; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1015; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy540; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1015; + goto yy978; } } -yy539: +yy1014: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy541; - if (yych <= '/') goto yy493; - goto yy542; + if (yych == '-') goto yy1016; + if (yych <= '/') goto yy978; + goto yy1017; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy542; + if (yych <= '@') goto yy978; + goto yy1017; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy542; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1017; + goto yy978; } } -yy540: +yy1015: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy542; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1017; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy542; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1017; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy542; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1017; + goto yy978; } } -yy541: +yy1016: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy543; - if (yych <= '/') goto yy493; - goto yy544; + if (yych == '-') goto yy1018; + if (yych <= '/') goto yy978; + goto yy1019; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy544; + if (yych <= '@') goto yy978; + goto yy1019; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy544; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1019; + goto yy978; } } -yy542: +yy1017: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy544; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1019; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy544; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1019; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy544; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1019; + goto yy978; } } -yy543: +yy1018: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy545; - if (yych <= '/') goto yy493; - goto yy546; + if (yych == '-') goto yy1020; + if (yych <= '/') goto yy978; + goto yy1021; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy546; + if (yych <= '@') goto yy978; + goto yy1021; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy546; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1021; + goto yy978; } } -yy544: +yy1019: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy546; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1021; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy546; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1021; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy546; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1021; + goto yy978; } } -yy545: +yy1020: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy547; - if (yych <= '/') goto yy493; - goto yy548; + if (yych == '-') goto yy1022; + if (yych <= '/') goto yy978; + goto yy1023; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy548; + if (yych <= '@') goto yy978; + goto yy1023; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy548; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1023; + goto yy978; } } -yy546: +yy1021: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; + } else { + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1023; + goto yy978; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1023; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1023; + goto yy978; + } + } +yy1022: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy1024; + if (yych <= '/') goto yy978; + goto yy1025; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy978; + goto yy1025; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1025; + goto yy978; + } + } +yy1023: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy548; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1025; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy548; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1025; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy548; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1025; + goto yy978; } } -yy547: +yy1024: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy549; - if (yych <= '/') goto yy493; - goto yy550; + if (yych == '-') goto yy1026; + if (yych <= '/') goto yy978; + goto yy1027; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy550; + if (yych <= '@') goto yy978; + goto yy1027; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy550; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1027; + goto yy978; } } -yy548: +yy1025: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy550; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1027; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy550; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1027; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy550; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1027; + goto yy978; } } -yy549: +yy1026: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy551; - if (yych <= '/') goto yy493; - goto yy552; + if (yych == '-') goto yy1028; + if (yych <= '/') goto yy978; + goto yy1029; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy552; + if (yych <= '@') goto yy978; + goto yy1029; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy552; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1029; + goto yy978; } } -yy550: +yy1027: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy552; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1029; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy552; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1029; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy552; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1029; + goto yy978; } } -yy551: +yy1028: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy553; - if (yych <= '/') goto yy493; - goto yy554; + if (yych == '-') goto yy1030; + if (yych <= '/') goto yy978; + goto yy1031; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy554; + if (yych <= '@') goto yy978; + goto yy1031; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy554; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1031; + goto yy978; } } -yy552: +yy1029: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy554; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1031; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy554; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1031; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy554; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1031; + goto yy978; } } -yy553: +yy1030: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy555; - if (yych <= '/') goto yy493; - goto yy556; + if (yych == '-') goto yy1032; + if (yych <= '/') goto yy978; + goto yy1033; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy556; + if (yych <= '@') goto yy978; + goto yy1033; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy556; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1033; + goto yy978; } } -yy554: +yy1031: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy556; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1033; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy556; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1033; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy556; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1033; + goto yy978; } } -yy555: +yy1032: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy557; - if (yych <= '/') goto yy493; - goto yy558; + if (yych == '-') goto yy1034; + if (yych <= '/') goto yy978; + goto yy1035; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy558; + if (yych <= '@') goto yy978; + goto yy1035; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy558; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1035; + goto yy978; } } -yy556: +yy1033: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy558; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1035; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy558; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1035; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy558; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1035; + goto yy978; } } -yy557: +yy1034: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy1036; + if (yych <= '/') goto yy978; + goto yy1037; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy978; + goto yy1037; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1037; + goto yy978; + } + } +yy1035: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; + } else { + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1037; + goto yy978; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1037; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1037; + goto yy978; + } + } +yy1036: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy1038; + if (yych <= '/') goto yy978; + goto yy1039; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy978; + goto yy1039; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1039; + goto yy978; + } + } +yy1037: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; + } else { + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1039; + goto yy978; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1039; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1039; + goto yy978; + } + } +yy1038: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy1040; + if (yych <= '/') goto yy978; + goto yy1041; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy978; + goto yy1041; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1041; + goto yy978; + } + } +yy1039: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; + } else { + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1041; + goto yy978; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1041; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1041; + goto yy978; + } + } +yy1040: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy1042; + if (yych <= '/') goto yy978; + goto yy1043; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy978; + goto yy1043; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1043; + goto yy978; + } + } +yy1041: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; + } else { + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1043; + goto yy978; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1043; + } else { + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1043; + goto yy978; + } + } +yy1042: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy559; - if (yych <= '/') goto yy493; - goto yy560; + if (yych == '-') goto yy1044; + if (yych <= '/') goto yy978; + goto yy1045; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy560; + if (yych <= '@') goto yy978; + goto yy1045; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy560; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1045; + goto yy978; } } -yy558: +yy1043: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy560; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1045; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy560; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1045; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy560; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1045; + goto yy978; } } -yy559: +yy1044: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy561; - if (yych <= '/') goto yy493; - goto yy562; + if (yych == '-') goto yy1046; + if (yych <= '/') goto yy978; + goto yy1047; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy562; + if (yych <= '@') goto yy978; + goto yy1047; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy562; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1047; + goto yy978; } } -yy560: +yy1045: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy562; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1047; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy562; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1047; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy562; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1047; + goto yy978; } } -yy561: +yy1046: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy563; - if (yych <= '/') goto yy493; - goto yy564; + if (yych == '-') goto yy1048; + if (yych <= '/') goto yy978; + goto yy1049; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy564; + if (yych <= '@') goto yy978; + goto yy1049; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy564; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1049; + goto yy978; } } -yy562: +yy1047: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy564; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1049; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy564; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1049; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy564; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1049; + goto yy978; } } -yy563: +yy1048: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy565; - if (yych <= '/') goto yy493; - goto yy566; + if (yych == '-') goto yy1050; + if (yych <= '/') goto yy978; + goto yy1051; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy566; + if (yych <= '@') goto yy978; + goto yy1051; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy566; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1051; + goto yy978; } } -yy564: +yy1049: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy566; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1051; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy566; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1051; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy566; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1051; + goto yy978; } } -yy565: +yy1050: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy567; - if (yych <= '/') goto yy493; - goto yy568; + if (yych == '-') goto yy1052; + if (yych <= '/') goto yy978; + goto yy1053; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy568; + if (yych <= '@') goto yy978; + goto yy1053; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy568; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1053; + goto yy978; } } -yy566: +yy1051: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy568; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1053; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy568; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1053; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy568; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1053; + goto yy978; } } -yy567: +yy1052: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy569; - if (yych <= '/') goto yy493; - goto yy570; + if (yych == '-') goto yy1054; + if (yych <= '/') goto yy978; + goto yy1055; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy570; + if (yych <= '@') goto yy978; + goto yy1055; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy570; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1055; + goto yy978; } } -yy568: +yy1053: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy570; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1055; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy570; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1055; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy570; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1055; + goto yy978; } } -yy569: +yy1054: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy571; - if (yych <= '/') goto yy493; - goto yy572; + if (yych == '-') goto yy1056; + if (yych <= '/') goto yy978; + goto yy1057; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy572; + if (yych <= '@') goto yy978; + goto yy1057; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy572; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1057; + goto yy978; } } -yy570: +yy1055: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy572; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1057; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy572; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1057; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy572; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1057; + goto yy978; } } -yy571: +yy1056: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy573; - if (yych <= '/') goto yy493; - goto yy574; + if (yych == '-') goto yy1058; + if (yych <= '/') goto yy978; + goto yy1059; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy574; + if (yych <= '@') goto yy978; + goto yy1059; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy574; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1059; + goto yy978; } } -yy572: +yy1057: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy574; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1059; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy574; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1059; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy574; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1059; + goto yy978; } } -yy573: +yy1058: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy575; - if (yych <= '/') goto yy493; - goto yy576; + if (yych == '-') goto yy1060; + if (yych <= '/') goto yy978; + goto yy1061; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy576; + if (yych <= '@') goto yy978; + goto yy1061; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy576; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1061; + goto yy978; } } -yy574: +yy1059: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy576; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1061; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy576; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1061; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy576; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1061; + goto yy978; } } -yy575: +yy1060: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy577; - if (yych <= '/') goto yy493; - goto yy578; + if (yych == '-') goto yy1062; + if (yych <= '/') goto yy978; + goto yy1063; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy578; + if (yych <= '@') goto yy978; + goto yy1063; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy578; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1063; + goto yy978; } } -yy576: +yy1061: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy578; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1063; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy578; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1063; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy578; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1063; + goto yy978; } } -yy577: +yy1062: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy579; - if (yych <= '/') goto yy493; - goto yy580; + if (yych == '-') goto yy1064; + if (yych <= '/') goto yy978; + goto yy1065; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy580; + if (yych <= '@') goto yy978; + goto yy1065; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy580; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1065; + goto yy978; } } -yy578: +yy1063: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy580; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1065; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy580; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1065; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy580; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1065; + goto yy978; } } -yy579: +yy1064: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy581; - if (yych <= '/') goto yy493; - goto yy582; + if (yych == '-') goto yy1066; + if (yych <= '/') goto yy978; + goto yy1067; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy582; + if (yych <= '@') goto yy978; + goto yy1067; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy582; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1067; + goto yy978; } } -yy580: +yy1065: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy582; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1067; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy582; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1067; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy582; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1067; + goto yy978; } } -yy581: +yy1066: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy583; - if (yych <= '/') goto yy493; - goto yy584; + if (yych == '-') goto yy1068; + if (yych <= '/') goto yy978; + goto yy1069; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy584; + if (yych <= '@') goto yy978; + goto yy1069; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy584; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1069; + goto yy978; } } -yy582: +yy1067: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy584; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1069; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy584; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1069; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy584; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1069; + goto yy978; } } -yy583: +yy1068: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy585; - if (yych <= '/') goto yy493; - goto yy586; + if (yych == '-') goto yy1070; + if (yych <= '/') goto yy978; + goto yy1071; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy586; + if (yych <= '@') goto yy978; + goto yy1071; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy586; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1071; + goto yy978; } } -yy584: +yy1069: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy586; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1071; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy586; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1071; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy586; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1071; + goto yy978; } } -yy585: +yy1070: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy587; - if (yych <= '/') goto yy493; - goto yy588; + if (yych == '-') goto yy1072; + if (yych <= '/') goto yy978; + goto yy1073; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy588; + if (yych <= '@') goto yy978; + goto yy1073; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy588; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1073; + goto yy978; } } -yy586: +yy1071: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy588; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1073; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy588; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1073; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy588; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1073; + goto yy978; } } -yy587: +yy1072: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy589; - if (yych <= '/') goto yy493; - goto yy590; + if (yych == '-') goto yy1074; + if (yych <= '/') goto yy978; + goto yy1075; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy590; + if (yych <= '@') goto yy978; + goto yy1075; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy590; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1075; + goto yy978; } } -yy588: +yy1073: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy590; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1075; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy590; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1075; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy590; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1075; + goto yy978; } } -yy589: +yy1074: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy591; - if (yych <= '/') goto yy493; - goto yy592; + if (yych == '-') goto yy1076; + if (yych <= '/') goto yy978; + goto yy1077; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy592; + if (yych <= '@') goto yy978; + goto yy1077; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy592; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1077; + goto yy978; } } -yy590: +yy1075: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy592; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1077; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy592; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1077; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy592; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1077; + goto yy978; } } -yy591: +yy1076: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy593; - if (yych <= '/') goto yy493; - goto yy594; + if (yych == '-') goto yy1078; + if (yych <= '/') goto yy978; + goto yy1079; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy594; + if (yych <= '@') goto yy978; + goto yy1079; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy594; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1079; + goto yy978; } } -yy592: +yy1077: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy594; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1079; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy594; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1079; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy594; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1079; + goto yy978; } } -yy593: +yy1078: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy595; - if (yych <= '/') goto yy493; - goto yy596; + if (yych == '-') goto yy1080; + if (yych <= '/') goto yy978; + goto yy1081; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy596; + if (yych <= '@') goto yy978; + goto yy1081; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy596; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1081; + goto yy978; } } -yy594: +yy1079: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy596; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1081; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy596; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1081; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy596; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1081; + goto yy978; } } -yy595: +yy1080: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy597; - if (yych <= '/') goto yy493; - goto yy598; + if (yych == '-') goto yy1082; + if (yych <= '/') goto yy978; + goto yy1083; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy598; + if (yych <= '@') goto yy978; + goto yy1083; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy598; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1083; + goto yy978; } } -yy596: +yy1081: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy598; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1083; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy598; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1083; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy598; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1083; + goto yy978; } } -yy597: +yy1082: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy599; - if (yych <= '/') goto yy493; - goto yy600; + if (yych == '-') goto yy1084; + if (yych <= '/') goto yy978; + goto yy1085; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy600; + if (yych <= '@') goto yy978; + goto yy1085; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy600; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1085; + goto yy978; } } -yy598: +yy1083: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy600; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1085; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy600; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1085; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy600; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1085; + goto yy978; } } -yy599: +yy1084: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy601; - if (yych <= '/') goto yy493; - goto yy602; + if (yych == '-') goto yy1086; + if (yych <= '/') goto yy978; + goto yy1087; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy602; + if (yych <= '@') goto yy978; + goto yy1087; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy602; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1087; + goto yy978; } } -yy600: +yy1085: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy602; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1087; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy602; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1087; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy602; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1087; + goto yy978; } } -yy601: +yy1086: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy603; - if (yych <= '/') goto yy493; - goto yy604; + if (yych == '-') goto yy1088; + if (yych <= '/') goto yy978; + goto yy1089; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy604; + if (yych <= '@') goto yy978; + goto yy1089; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy604; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1089; + goto yy978; } } -yy602: +yy1087: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy604; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1089; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy604; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1089; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy604; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1089; + goto yy978; } } -yy603: +yy1088: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy605; - if (yych <= '/') goto yy493; - goto yy606; + if (yych == '-') goto yy1090; + if (yych <= '/') goto yy978; + goto yy1091; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy606; + if (yych <= '@') goto yy978; + goto yy1091; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy606; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1091; + goto yy978; } } -yy604: +yy1089: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy606; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1091; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy606; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1091; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy606; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1091; + goto yy978; } } -yy605: +yy1090: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy607; - if (yych <= '/') goto yy493; - goto yy608; + if (yych == '-') goto yy1092; + if (yych <= '/') goto yy978; + goto yy1093; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy608; + if (yych <= '@') goto yy978; + goto yy1093; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy608; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1093; + goto yy978; } } -yy606: +yy1091: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy608; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1093; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy608; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1093; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy608; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1093; + goto yy978; } } -yy607: +yy1092: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy609; - if (yych <= '/') goto yy493; - goto yy610; + if (yych == '-') goto yy1094; + if (yych <= '/') goto yy978; + goto yy1095; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy610; + if (yych <= '@') goto yy978; + goto yy1095; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy610; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1095; + goto yy978; } } -yy608: +yy1093: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy610; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1095; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy610; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1095; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy610; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1095; + goto yy978; } } -yy609: +yy1094: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy611; - if (yych <= '/') goto yy493; - goto yy612; + if (yych == '-') goto yy1096; + if (yych <= '/') goto yy978; + goto yy1097; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy612; + if (yych <= '@') goto yy978; + goto yy1097; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy612; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1097; + goto yy978; } } -yy610: +yy1095: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy612; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1097; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy612; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1097; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy612; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1097; + goto yy978; } } -yy611: +yy1096: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy613; - if (yych <= '/') goto yy493; - goto yy614; + if (yych == '-') goto yy1098; + if (yych <= '/') goto yy978; + goto yy1099; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy614; + if (yych <= '@') goto yy978; + goto yy1099; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy614; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1099; + goto yy978; } } -yy612: +yy1097: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy614; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1099; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy614; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1099; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy614; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1099; + goto yy978; } } -yy613: +yy1098: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy615; - if (yych <= '/') goto yy493; - goto yy616; + if (yych == '-') goto yy1100; + if (yych <= '/') goto yy978; + goto yy1101; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy616; + if (yych <= '@') goto yy978; + goto yy1101; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy616; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1101; + goto yy978; } } -yy614: +yy1099: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy616; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1101; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy616; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1101; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy616; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1101; + goto yy978; } } -yy615: +yy1100: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy617; - if (yych <= '/') goto yy493; - goto yy618; + if (yych == '-') goto yy1102; + if (yych <= '/') goto yy978; + goto yy1103; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy618; + if (yych <= '@') goto yy978; + goto yy1103; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy618; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1103; + goto yy978; } } -yy616: +yy1101: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy618; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1103; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy618; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1103; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy618; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1103; + goto yy978; } } -yy617: +yy1102: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy619; - if (yych <= '/') goto yy493; - goto yy620; + if (yych == '-') goto yy1104; + if (yych <= '/') goto yy978; + goto yy1105; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy620; + if (yych <= '@') goto yy978; + goto yy1105; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy620; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1105; + goto yy978; } } -yy618: +yy1103: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy620; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1105; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy620; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1105; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy620; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1105; + goto yy978; } } -yy619: +yy1104: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy621; - if (yych <= '/') goto yy493; - goto yy622; + if (yych == '-') goto yy1106; + if (yych <= '/') goto yy978; + goto yy1107; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy622; + if (yych <= '@') goto yy978; + goto yy1107; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy622; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1107; + goto yy978; } } -yy620: +yy1105: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy622; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1107; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy622; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1107; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy622; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1107; + goto yy978; } } -yy621: +yy1106: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy623; - if (yych <= '/') goto yy493; - goto yy624; + if (yych == '-') goto yy1108; + if (yych <= '/') goto yy978; + goto yy1109; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy624; + if (yych <= '@') goto yy978; + goto yy1109; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy624; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1109; + goto yy978; } } -yy622: +yy1107: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy624; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1109; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy624; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1109; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy624; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1109; + goto yy978; } } -yy623: +yy1108: ++p; yych = *p; if (yych <= '@') { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy625; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1110; + goto yy978; } else { - if (yych <= 'Z') goto yy625; - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy625; - goto yy493; + if (yych <= 'Z') goto yy1110; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1110; + goto yy978; } -yy624: +yy1109: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= '-') goto yy493; - goto yy499; + if (yych <= '-') goto yy978; + goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych >= ':') goto yy493; + if (yych <= '/') goto yy978; + if (yych >= ':') goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; } else { - if (yych <= '`') goto yy493; - if (yych >= '{') goto yy493; + if (yych <= '`') goto yy978; + if (yych >= '{') goto yy978; } } -yy625: +yy1110: ++p; yych = *p; - if (yych == '.') goto yy499; - if (yych == '>') goto yy500; - goto yy493; -yy626: + if (yych == '.') goto yy984; + if (yych == '>') goto yy985; + goto yy978; +yy1111: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy628; - if (yych <= '/') goto yy493; - goto yy629; + if (yych == '-') goto yy1113; + if (yych <= '/') goto yy978; + goto yy1114; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy629; + if (yych <= '@') goto yy978; + goto yy1114; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy629; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1114; + goto yy978; } } -yy627: +yy1112: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy629; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1114; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy629; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1114; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy629; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1114; + goto yy978; } } -yy628: +yy1113: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy630; - if (yych <= '/') goto yy493; - goto yy631; + if (yych == '-') goto yy1115; + if (yych <= '/') goto yy978; + goto yy1116; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy631; + if (yych <= '@') goto yy978; + goto yy1116; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy631; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1116; + goto yy978; } } -yy629: +yy1114: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy631; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1116; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy631; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1116; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy631; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1116; + goto yy978; } } -yy630: +yy1115: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy632; - if (yych <= '/') goto yy493; - goto yy633; + if (yych == '-') goto yy1117; + if (yych <= '/') goto yy978; + goto yy1118; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy633; + if (yych <= '@') goto yy978; + goto yy1118; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy633; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1118; + goto yy978; } } -yy631: +yy1116: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy633; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1118; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy633; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1118; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy633; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1118; + goto yy978; } } -yy632: +yy1117: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy634; - if (yych <= '/') goto yy493; - goto yy635; + if (yych == '-') goto yy1119; + if (yych <= '/') goto yy978; + goto yy1120; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy635; + if (yych <= '@') goto yy978; + goto yy1120; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy635; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1120; + goto yy978; } } -yy633: +yy1118: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy635; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1120; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy635; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1120; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy635; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1120; + goto yy978; } } -yy634: +yy1119: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy636; - if (yych <= '/') goto yy493; - goto yy637; + if (yych == '-') goto yy1121; + if (yych <= '/') goto yy978; + goto yy1122; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy637; + if (yych <= '@') goto yy978; + goto yy1122; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy637; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1122; + goto yy978; } } -yy635: +yy1120: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy637; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1122; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy637; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1122; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy637; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1122; + goto yy978; } } -yy636: +yy1121: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy638; - if (yych <= '/') goto yy493; - goto yy639; + if (yych == '-') goto yy1123; + if (yych <= '/') goto yy978; + goto yy1124; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy639; + if (yych <= '@') goto yy978; + goto yy1124; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy639; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1124; + goto yy978; } } -yy637: +yy1122: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy639; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1124; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy639; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1124; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy639; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1124; + goto yy978; } } -yy638: +yy1123: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy640; - if (yych <= '/') goto yy493; - goto yy641; + if (yych == '-') goto yy1125; + if (yych <= '/') goto yy978; + goto yy1126; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy641; + if (yych <= '@') goto yy978; + goto yy1126; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy641; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1126; + goto yy978; } } -yy639: +yy1124: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy641; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1126; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy641; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1126; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy641; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1126; + goto yy978; } } -yy640: +yy1125: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy642; - if (yych <= '/') goto yy493; - goto yy643; + if (yych == '-') goto yy1127; + if (yych <= '/') goto yy978; + goto yy1128; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy643; + if (yych <= '@') goto yy978; + goto yy1128; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy643; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1128; + goto yy978; } } -yy641: +yy1126: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy643; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1128; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy643; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1128; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy643; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1128; + goto yy978; } } -yy642: +yy1127: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy644; - if (yych <= '/') goto yy493; - goto yy645; + if (yych == '-') goto yy1129; + if (yych <= '/') goto yy978; + goto yy1130; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy645; + if (yych <= '@') goto yy978; + goto yy1130; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy645; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1130; + goto yy978; } } -yy643: +yy1128: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy645; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1130; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy645; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1130; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy645; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1130; + goto yy978; } } -yy644: +yy1129: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy646; - if (yych <= '/') goto yy493; - goto yy647; + if (yych == '-') goto yy1131; + if (yych <= '/') goto yy978; + goto yy1132; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy647; + if (yych <= '@') goto yy978; + goto yy1132; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy647; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1132; + goto yy978; } } -yy645: +yy1130: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy647; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1132; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy647; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1132; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy647; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1132; + goto yy978; } } -yy646: +yy1131: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy648; - if (yych <= '/') goto yy493; - goto yy649; + if (yych == '-') goto yy1133; + if (yych <= '/') goto yy978; + goto yy1134; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy649; + if (yych <= '@') goto yy978; + goto yy1134; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy649; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1134; + goto yy978; } } -yy647: +yy1132: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy649; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1134; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy649; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1134; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy649; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1134; + goto yy978; } } -yy648: +yy1133: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy650; - if (yych <= '/') goto yy493; - goto yy651; + if (yych == '-') goto yy1135; + if (yych <= '/') goto yy978; + goto yy1136; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy651; + if (yych <= '@') goto yy978; + goto yy1136; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy651; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1136; + goto yy978; } } -yy649: +yy1134: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy651; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1136; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy651; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1136; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy651; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1136; + goto yy978; } } -yy650: +yy1135: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy652; - if (yych <= '/') goto yy493; - goto yy653; + if (yych == '-') goto yy1137; + if (yych <= '/') goto yy978; + goto yy1138; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy653; + if (yych <= '@') goto yy978; + goto yy1138; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy653; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1138; + goto yy978; } } -yy651: +yy1136: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy653; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1138; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy653; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1138; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy653; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1138; + goto yy978; } } -yy652: +yy1137: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy654; - if (yych <= '/') goto yy493; - goto yy655; + if (yych == '-') goto yy1139; + if (yych <= '/') goto yy978; + goto yy1140; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy655; + if (yych <= '@') goto yy978; + goto yy1140; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy655; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1140; + goto yy978; } } -yy653: +yy1138: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy655; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1140; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy655; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1140; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy655; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1140; + goto yy978; } } -yy654: +yy1139: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy656; - if (yych <= '/') goto yy493; - goto yy657; + if (yych == '-') goto yy1141; + if (yych <= '/') goto yy978; + goto yy1142; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy657; + if (yych <= '@') goto yy978; + goto yy1142; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy657; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1142; + goto yy978; } } -yy655: +yy1140: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy657; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1142; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy657; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1142; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy657; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1142; + goto yy978; } } -yy656: +yy1141: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy658; - if (yych <= '/') goto yy493; - goto yy659; + if (yych == '-') goto yy1143; + if (yych <= '/') goto yy978; + goto yy1144; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy659; + if (yych <= '@') goto yy978; + goto yy1144; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy659; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1144; + goto yy978; } } -yy657: +yy1142: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy659; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1144; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy659; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1144; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy659; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1144; + goto yy978; } } -yy658: +yy1143: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy660; - if (yych <= '/') goto yy493; - goto yy661; + if (yych == '-') goto yy1145; + if (yych <= '/') goto yy978; + goto yy1146; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy661; + if (yych <= '@') goto yy978; + goto yy1146; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy661; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1146; + goto yy978; } } -yy659: +yy1144: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy661; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1146; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy661; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1146; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy661; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1146; + goto yy978; } } -yy660: +yy1145: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy662; - if (yych <= '/') goto yy493; - goto yy663; + if (yych == '-') goto yy1147; + if (yych <= '/') goto yy978; + goto yy1148; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy663; + if (yych <= '@') goto yy978; + goto yy1148; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy663; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1148; + goto yy978; } } -yy661: +yy1146: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy663; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1148; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy663; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1148; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy663; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1148; + goto yy978; } } -yy662: +yy1147: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy664; - if (yych <= '/') goto yy493; - goto yy665; + if (yych == '-') goto yy1149; + if (yych <= '/') goto yy978; + goto yy1150; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy665; + if (yych <= '@') goto yy978; + goto yy1150; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy665; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1150; + goto yy978; } } -yy663: +yy1148: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy665; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1150; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy665; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1150; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy665; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1150; + goto yy978; } } -yy664: +yy1149: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy666; - if (yych <= '/') goto yy493; - goto yy667; + if (yych == '-') goto yy1151; + if (yych <= '/') goto yy978; + goto yy1152; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy667; + if (yych <= '@') goto yy978; + goto yy1152; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy667; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1152; + goto yy978; } } -yy665: +yy1150: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy667; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1152; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy667; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1152; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy667; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1152; + goto yy978; } } -yy666: +yy1151: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy668; - if (yych <= '/') goto yy493; - goto yy669; + if (yych == '-') goto yy1153; + if (yych <= '/') goto yy978; + goto yy1154; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy669; + if (yych <= '@') goto yy978; + goto yy1154; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy669; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1154; + goto yy978; } } -yy667: +yy1152: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy669; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1154; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy669; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1154; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy669; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1154; + goto yy978; } } -yy668: +yy1153: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy670; - if (yych <= '/') goto yy493; - goto yy671; + if (yych == '-') goto yy1155; + if (yych <= '/') goto yy978; + goto yy1156; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy671; + if (yych <= '@') goto yy978; + goto yy1156; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy671; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1156; + goto yy978; } } -yy669: +yy1154: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy671; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1156; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy671; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1156; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy671; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1156; + goto yy978; } } -yy670: +yy1155: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy672; - if (yych <= '/') goto yy493; - goto yy673; + if (yych == '-') goto yy1157; + if (yych <= '/') goto yy978; + goto yy1158; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy673; + if (yych <= '@') goto yy978; + goto yy1158; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy673; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1158; + goto yy978; } } -yy671: +yy1156: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy673; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1158; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy673; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1158; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy673; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1158; + goto yy978; } } -yy672: +yy1157: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy674; - if (yych <= '/') goto yy493; - goto yy675; + if (yych == '-') goto yy1159; + if (yych <= '/') goto yy978; + goto yy1160; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy675; + if (yych <= '@') goto yy978; + goto yy1160; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy675; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1160; + goto yy978; } } -yy673: +yy1158: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy675; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1160; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy675; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1160; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy675; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1160; + goto yy978; } } -yy674: +yy1159: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy676; - if (yych <= '/') goto yy493; - goto yy677; + if (yych == '-') goto yy1161; + if (yych <= '/') goto yy978; + goto yy1162; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy677; + if (yych <= '@') goto yy978; + goto yy1162; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy677; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1162; + goto yy978; } } -yy675: +yy1160: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy677; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1162; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy677; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1162; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy677; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1162; + goto yy978; } } -yy676: +yy1161: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy678; - if (yych <= '/') goto yy493; - goto yy679; + if (yych == '-') goto yy1163; + if (yych <= '/') goto yy978; + goto yy1164; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy679; + if (yych <= '@') goto yy978; + goto yy1164; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy679; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1164; + goto yy978; } } -yy677: +yy1162: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy679; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1164; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy679; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1164; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy679; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1164; + goto yy978; } } -yy678: +yy1163: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy680; - if (yych <= '/') goto yy493; - goto yy681; + if (yych == '-') goto yy1165; + if (yych <= '/') goto yy978; + goto yy1166; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy681; + if (yych <= '@') goto yy978; + goto yy1166; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy681; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1166; + goto yy978; } } -yy679: +yy1164: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy681; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1166; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy681; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1166; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy681; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1166; + goto yy978; } } -yy680: +yy1165: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy682; - if (yych <= '/') goto yy493; - goto yy683; + if (yych == '-') goto yy1167; + if (yych <= '/') goto yy978; + goto yy1168; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy683; + if (yych <= '@') goto yy978; + goto yy1168; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy683; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1168; + goto yy978; } } -yy681: +yy1166: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy683; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1168; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy683; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1168; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy683; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1168; + goto yy978; } } -yy682: +yy1167: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy684; - if (yych <= '/') goto yy493; - goto yy685; + if (yych == '-') goto yy1169; + if (yych <= '/') goto yy978; + goto yy1170; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy685; + if (yych <= '@') goto yy978; + goto yy1170; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy685; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1170; + goto yy978; } } -yy683: +yy1168: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy685; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1170; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy685; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1170; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy685; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1170; + goto yy978; } } -yy684: +yy1169: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy686; - if (yych <= '/') goto yy493; - goto yy687; + if (yych == '-') goto yy1171; + if (yych <= '/') goto yy978; + goto yy1172; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy687; + if (yych <= '@') goto yy978; + goto yy1172; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy687; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1172; + goto yy978; } } -yy685: +yy1170: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy687; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1172; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy687; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1172; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy687; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1172; + goto yy978; } } -yy686: +yy1171: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy688; - if (yych <= '/') goto yy493; - goto yy689; + if (yych == '-') goto yy1173; + if (yych <= '/') goto yy978; + goto yy1174; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy689; + if (yych <= '@') goto yy978; + goto yy1174; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy689; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1174; + goto yy978; } } -yy687: +yy1172: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy689; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1174; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy689; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1174; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy689; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1174; + goto yy978; } } -yy688: +yy1173: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy690; - if (yych <= '/') goto yy493; - goto yy691; + if (yych == '-') goto yy1175; + if (yych <= '/') goto yy978; + goto yy1176; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy691; + if (yych <= '@') goto yy978; + goto yy1176; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy691; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1176; + goto yy978; } } -yy689: +yy1174: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy691; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1176; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy691; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1176; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy691; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1176; + goto yy978; } } -yy690: +yy1175: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy692; - if (yych <= '/') goto yy493; - goto yy693; + if (yych == '-') goto yy1177; + if (yych <= '/') goto yy978; + goto yy1178; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy693; + if (yych <= '@') goto yy978; + goto yy1178; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy693; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1178; + goto yy978; } } -yy691: +yy1176: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy693; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1178; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy693; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1178; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy693; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1178; + goto yy978; } } -yy692: +yy1177: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy694; - if (yych <= '/') goto yy493; - goto yy695; + if (yych == '-') goto yy1179; + if (yych <= '/') goto yy978; + goto yy1180; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy695; + if (yych <= '@') goto yy978; + goto yy1180; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy695; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1180; + goto yy978; } } -yy693: +yy1178: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy695; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1180; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy695; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1180; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy695; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1180; + goto yy978; } } -yy694: +yy1179: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy696; - if (yych <= '/') goto yy493; - goto yy697; + if (yych == '-') goto yy1181; + if (yych <= '/') goto yy978; + goto yy1182; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy697; + if (yych <= '@') goto yy978; + goto yy1182; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy697; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1182; + goto yy978; } } -yy695: +yy1180: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy697; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1182; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy697; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1182; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy697; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1182; + goto yy978; } } -yy696: +yy1181: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy698; - if (yych <= '/') goto yy493; - goto yy699; + if (yych == '-') goto yy1183; + if (yych <= '/') goto yy978; + goto yy1184; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy699; + if (yych <= '@') goto yy978; + goto yy1184; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy699; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1184; + goto yy978; } } -yy697: +yy1182: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy699; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1184; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy699; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1184; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy699; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1184; + goto yy978; } } -yy698: +yy1183: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy700; - if (yych <= '/') goto yy493; - goto yy701; + if (yych == '-') goto yy1185; + if (yych <= '/') goto yy978; + goto yy1186; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy701; + if (yych <= '@') goto yy978; + goto yy1186; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy701; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1186; + goto yy978; } } -yy699: +yy1184: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy701; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1186; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy701; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1186; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy701; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1186; + goto yy978; } } -yy700: +yy1185: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy702; - if (yych <= '/') goto yy493; - goto yy703; + if (yych == '-') goto yy1187; + if (yych <= '/') goto yy978; + goto yy1188; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy703; + if (yych <= '@') goto yy978; + goto yy1188; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy703; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1188; + goto yy978; } } -yy701: +yy1186: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy703; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1188; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy703; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1188; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy703; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1188; + goto yy978; } } -yy702: +yy1187: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy704; - if (yych <= '/') goto yy493; - goto yy705; + if (yych == '-') goto yy1189; + if (yych <= '/') goto yy978; + goto yy1190; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy705; + if (yych <= '@') goto yy978; + goto yy1190; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy705; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1190; + goto yy978; } } -yy703: +yy1188: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy705; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1190; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy705; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1190; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy705; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1190; + goto yy978; } } -yy704: +yy1189: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy706; - if (yych <= '/') goto yy493; - goto yy707; + if (yych == '-') goto yy1191; + if (yych <= '/') goto yy978; + goto yy1192; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy707; + if (yych <= '@') goto yy978; + goto yy1192; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy707; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1192; + goto yy978; } } -yy705: +yy1190: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy707; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1192; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy707; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1192; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy707; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1192; + goto yy978; } } -yy706: +yy1191: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy708; - if (yych <= '/') goto yy493; - goto yy709; + if (yych == '-') goto yy1193; + if (yych <= '/') goto yy978; + goto yy1194; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy709; + if (yych <= '@') goto yy978; + goto yy1194; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy709; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1194; + goto yy978; } } -yy707: +yy1192: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy709; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1194; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy709; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1194; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy709; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1194; + goto yy978; } } -yy708: +yy1193: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy710; - if (yych <= '/') goto yy493; - goto yy711; + if (yych == '-') goto yy1195; + if (yych <= '/') goto yy978; + goto yy1196; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy711; + if (yych <= '@') goto yy978; + goto yy1196; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy711; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1196; + goto yy978; } } -yy709: +yy1194: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy711; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1196; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy711; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1196; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy711; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1196; + goto yy978; } } -yy710: +yy1195: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy712; - if (yych <= '/') goto yy493; - goto yy713; + if (yych == '-') goto yy1197; + if (yych <= '/') goto yy978; + goto yy1198; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy713; + if (yych <= '@') goto yy978; + goto yy1198; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy713; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1198; + goto yy978; } } -yy711: +yy1196: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy713; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1198; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy713; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1198; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy713; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1198; + goto yy978; } } -yy712: +yy1197: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy714; - if (yych <= '/') goto yy493; - goto yy715; + if (yych == '-') goto yy1199; + if (yych <= '/') goto yy978; + goto yy1200; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy715; + if (yych <= '@') goto yy978; + goto yy1200; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy715; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1200; + goto yy978; } } -yy713: +yy1198: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy715; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1200; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy715; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1200; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy715; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1200; + goto yy978; } } -yy714: +yy1199: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy716; - if (yych <= '/') goto yy493; - goto yy717; + if (yych == '-') goto yy1201; + if (yych <= '/') goto yy978; + goto yy1202; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy717; + if (yych <= '@') goto yy978; + goto yy1202; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy717; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1202; + goto yy978; } } -yy715: +yy1200: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy717; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1202; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy717; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1202; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy717; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1202; + goto yy978; } } -yy716: +yy1201: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy718; - if (yych <= '/') goto yy493; - goto yy719; + if (yych == '-') goto yy1203; + if (yych <= '/') goto yy978; + goto yy1204; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy719; + if (yych <= '@') goto yy978; + goto yy1204; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy719; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1204; + goto yy978; } } -yy717: +yy1202: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy719; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1204; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy719; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1204; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy719; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1204; + goto yy978; } } -yy718: +yy1203: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy720; - if (yych <= '/') goto yy493; - goto yy721; + if (yych == '-') goto yy1205; + if (yych <= '/') goto yy978; + goto yy1206; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy721; + if (yych <= '@') goto yy978; + goto yy1206; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy721; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1206; + goto yy978; } } -yy719: +yy1204: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy721; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1206; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy721; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1206; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy721; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1206; + goto yy978; } } -yy720: +yy1205: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy722; - if (yych <= '/') goto yy493; - goto yy723; + if (yych == '-') goto yy1207; + if (yych <= '/') goto yy978; + goto yy1208; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy723; + if (yych <= '@') goto yy978; + goto yy1208; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy723; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1208; + goto yy978; } } -yy721: +yy1206: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy723; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1208; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy723; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1208; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy723; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1208; + goto yy978; } } -yy722: +yy1207: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy724; - if (yych <= '/') goto yy493; - goto yy725; + if (yych == '-') goto yy1209; + if (yych <= '/') goto yy978; + goto yy1210; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy725; + if (yych <= '@') goto yy978; + goto yy1210; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy725; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1210; + goto yy978; } } -yy723: +yy1208: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy725; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1210; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy725; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1210; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy725; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1210; + goto yy978; } } -yy724: +yy1209: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy726; - if (yych <= '/') goto yy493; - goto yy727; + if (yych == '-') goto yy1211; + if (yych <= '/') goto yy978; + goto yy1212; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy727; + if (yych <= '@') goto yy978; + goto yy1212; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy727; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1212; + goto yy978; } } -yy725: +yy1210: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy727; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1212; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy727; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1212; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy727; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1212; + goto yy978; } } -yy726: +yy1211: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy728; - if (yych <= '/') goto yy493; - goto yy729; + if (yych == '-') goto yy1213; + if (yych <= '/') goto yy978; + goto yy1214; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy729; + if (yych <= '@') goto yy978; + goto yy1214; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy729; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1214; + goto yy978; } } -yy727: +yy1212: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy729; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1214; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy729; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1214; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy729; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1214; + goto yy978; } } -yy728: +yy1213: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy730; - if (yych <= '/') goto yy493; - goto yy731; + if (yych == '-') goto yy1215; + if (yych <= '/') goto yy978; + goto yy1216; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy731; + if (yych <= '@') goto yy978; + goto yy1216; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy731; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1216; + goto yy978; } } -yy729: +yy1214: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy731; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1216; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy731; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1216; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy731; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1216; + goto yy978; } } -yy730: +yy1215: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy732; - if (yych <= '/') goto yy493; - goto yy733; + if (yych == '-') goto yy1217; + if (yych <= '/') goto yy978; + goto yy1218; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy733; + if (yych <= '@') goto yy978; + goto yy1218; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy733; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1218; + goto yy978; } } -yy731: +yy1216: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy733; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1218; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy733; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1218; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy733; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1218; + goto yy978; } } -yy732: +yy1217: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy734; - if (yych <= '/') goto yy493; - goto yy735; + if (yych == '-') goto yy1219; + if (yych <= '/') goto yy978; + goto yy1220; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy735; + if (yych <= '@') goto yy978; + goto yy1220; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy735; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1220; + goto yy978; } } -yy733: +yy1218: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy735; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1220; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy735; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1220; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy735; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1220; + goto yy978; } } -yy734: +yy1219: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy736; - if (yych <= '/') goto yy493; - goto yy737; + if (yych == '-') goto yy1221; + if (yych <= '/') goto yy978; + goto yy1222; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy737; + if (yych <= '@') goto yy978; + goto yy1222; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy737; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1222; + goto yy978; } } -yy735: +yy1220: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy737; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1222; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy737; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1222; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy737; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1222; + goto yy978; } } -yy736: +yy1221: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy738; - if (yych <= '/') goto yy493; - goto yy739; + if (yych == '-') goto yy1223; + if (yych <= '/') goto yy978; + goto yy1224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy739; + if (yych <= '@') goto yy978; + goto yy1224; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy739; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1224; + goto yy978; } } -yy737: +yy1222: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy739; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1224; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy739; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1224; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy739; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1224; + goto yy978; } } -yy738: +yy1223: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy740; - if (yych <= '/') goto yy493; - goto yy741; + if (yych == '-') goto yy1225; + if (yych <= '/') goto yy978; + goto yy1226; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy741; + if (yych <= '@') goto yy978; + goto yy1226; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy741; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1226; + goto yy978; } } -yy739: +yy1224: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy741; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1226; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy741; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1226; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy741; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1226; + goto yy978; } } -yy740: +yy1225: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy742; - if (yych <= '/') goto yy493; - goto yy743; + if (yych == '-') goto yy1227; + if (yych <= '/') goto yy978; + goto yy1228; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy743; + if (yych <= '@') goto yy978; + goto yy1228; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy743; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1228; + goto yy978; } } -yy741: +yy1226: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy743; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1228; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy743; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1228; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy743; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1228; + goto yy978; } } -yy742: +yy1227: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy744; - if (yych <= '/') goto yy493; - goto yy745; + if (yych == '-') goto yy1229; + if (yych <= '/') goto yy978; + goto yy1230; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy493; - goto yy745; + if (yych <= '@') goto yy978; + goto yy1230; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy745; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1230; + goto yy978; } } -yy743: +yy1228: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy493; - if (yych >= '.') goto yy499; + if (yych <= ',') goto yy978; + if (yych >= '.') goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy745; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1230; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy745; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1230; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy745; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1230; + goto yy978; } } -yy744: +yy1229: yych = *++p; if (yych <= '@') { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy625; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1110; + goto yy978; } else { - if (yych <= 'Z') goto yy625; - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy625; - goto yy493; + if (yych <= 'Z') goto yy1110; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1110; + goto yy978; } -yy745: +yy1230: ++p; if ((yych = *p) <= '=') { if (yych <= '.') { - if (yych <= '-') goto yy493; - goto yy499; + if (yych <= '-') goto yy978; + goto yy984; } else { - if (yych <= '/') goto yy493; - if (yych <= '9') goto yy625; - goto yy493; + if (yych <= '/') goto yy978; + if (yych <= '9') goto yy1110; + goto yy978; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy500; - if (yych <= '@') goto yy493; - goto yy625; + if (yych <= '>') goto yy985; + if (yych <= '@') goto yy978; + goto yy1110; } else { - if (yych <= '`') goto yy493; - if (yych <= 'z') goto yy625; - goto yy493; + if (yych <= '`') goto yy978; + if (yych <= 'z') goto yy1110; + goto yy978; } } } @@ -7973,2369 +10872,2369 @@ int _scan_html_tag(const unsigned char *p) 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 160, 160, - 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; + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 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 <= '9') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy756; - if (yych >= 0x0E) goto yy756; + if (yych <= '/') { + if (yych <= ' ') { + if (yych != '\n') goto yy1238; } else { - if (yych <= ' ') goto yy790; - if (yych <= '.') goto yy756; - if (yych <= '/') goto yy792; - goto yy788; + if (yych <= '!') goto yy1236; + if (yych <= '.') goto yy1238; + goto yy1235; } } else { if (yych <= '@') { - if (yych == '>') goto yy758; - goto yy756; + if (yych == '?') goto yy1237; + goto yy1238; } else { - if (yych <= 'Z') goto yy788; - if (yych <= '`') goto yy756; - if (yych <= 'z') goto yy788; - goto yy756; + if (yych <= 'Z') goto yy1234; + if (yych <= '`') goto yy1238; + if (yych <= 'z') goto yy1234; + goto yy1238; } } -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; +yy1233: + { return 0; } +yy1234: + yych = *(marker = ++p); + if (yych <= '9') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1233; + if (yych <= '\r') goto yy1275; + goto yy1233; } else { - if (yych == '/') goto yy792; - if (yych <= '9') goto yy756; - goto yy793; + if (yych <= ' ') goto yy1275; + if (yych <= '.') goto yy1233; + if (yych <= '/') goto yy1277; + goto yy1273; } } else { - if (yych <= 'Z') { - if (yych == '>') goto yy758; - if (yych <= '@') goto yy756; - goto yy793; + if (yych <= '@') { + if (yych == '>') goto yy1243; + goto yy1233; } else { - if (yych <= '_') { - if (yych <= '^') goto yy756; - goto yy793; - } else { - if (yych <= '`') goto yy756; - if (yych <= 'z') goto yy793; - goto yy756; - } + if (yych <= 'Z') goto yy1273; + if (yych <= '`') goto yy1233; + if (yych <= 'z') goto yy1273; + goto yy1233; } } -yy792: +yy1235: + yych = *(marker = ++p); + if (yych <= '@') goto yy1233; + if (yych <= 'Z') goto yy1269; + if (yych <= '`') goto yy1233; + if (yych <= 'z') goto yy1269; + goto yy1233; +yy1236: + yych = *(marker = ++p); + if (yybm[256+yych] & 64) { + goto yy1246; + } + if (yych == '-') goto yy1248; + if (yych == '[') goto yy1245; + goto yy1233; +yy1237: + yych = *(marker = ++p); + if (yych <= 0x00) goto yy1233; + goto yy1240; +yy1238: yych = *++p; - if (yych == '>') goto yy758; - goto yy756; -yy793: + goto yy1233; +yy1239: ++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; - } +yy1240: + if (yybm[256+yych] & 32) { + goto yy1239; } -yy795: + if (yych >= 0x01) goto yy1242; +yy1241: + p = marker; + goto yy1233; +yy1242: ++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: + if (yych <= 0x00) goto yy1241; + if (yych != '>') goto yy1239; +yy1243: ++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: + { return (p - start); } +yy1245: + yych = *++p; + if (yych == 'C') goto yy1260; + if (yych == 'c') goto yy1260; + goto yy1241; +yy1246: ++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; + if (yybm[0+yych] & 1) { + goto yy1256; } -yy799: + if (yych <= '@') goto yy1241; + if (yych <= 'Z') goto yy1246; + goto yy1241; +yy1248: + yych = *++p; + if (yych != '-') goto yy1241; + yych = *++p; + if (yych == '-') goto yy1250; + if (yych == '>') goto yy1241; + goto yy1252; +yy1250: + yych = *++p; + if (yych == '-') goto yy1255; + if (yych == '>') goto yy1241; + goto yy1252; +yy1251: ++p; yych = *p; - if (yybm[0+yych] & 32) { - goto yy799; +yy1252: + if (yybm[256+yych] & 128) { + goto yy1251; } - if (yych <= 0x00) goto yy756; - if (yych <= '!') goto yy806; - if (yych == '>') goto yy758; - goto yy756; -yy801: + if (yych <= 0x00) goto yy1241; ++p; yych = *p; - if (yybm[0+yych] & 64) { - goto yy801; + if (yybm[256+yych] & 128) { + goto yy1251; } - if (yych <= 0x00) goto yy756; - goto yy805; -yy803: + if (yych <= 0x00) goto yy1241; + yych = *++p; + if (yych == '>') goto yy1243; + goto yy1241; +yy1255: + yych = *++p; + if (yych == '>') goto yy1243; + goto yy1241; +yy1256: ++p; yych = *p; - if (yybm[0+yych] & 128) { - goto yy803; + if (yybm[0+yych] & 1) { + goto yy1256; } - if (yych <= 0x00) goto yy756; -yy805: + if (yych <= 0x00) goto yy1241; + if (yych == '>') goto yy1243; +yy1258: ++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; - } + if (yybm[0+yych] & 2) { + goto yy1258; } -yy806: + if (yych <= 0x00) goto yy1241; + goto yy1243; +yy1260: + yych = *++p; + if (yych == 'D') goto yy1261; + if (yych != 'd') goto yy1241; +yy1261: + yych = *++p; + if (yych == 'A') goto yy1262; + if (yych != 'a') goto yy1241; +yy1262: + yych = *++p; + if (yych == 'T') goto yy1263; + if (yych != 't') goto yy1241; +yy1263: + yych = *++p; + if (yych == 'A') goto yy1264; + if (yych != 'a') goto yy1241; +yy1264: + yych = *++p; + if (yych != '[') goto yy1241; +yy1265: ++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; - } - } + if (yybm[0+yych] & 4) { + goto yy1265; } -yy808: + if (yych <= 0x00) goto yy1241; ++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; - } - } + if (yybm[0+yych] & 4) { + goto yy1265; } -yy810: + if (yych <= 0x00) goto yy1241; ++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: + if (yych <= 0x00) goto yy1241; + if (yych == '>') goto yy1243; + goto yy1265; +yy1269: ++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; - } + if (yybm[0+yych] & 8) { + goto yy1269; + } + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1241; + if (yych >= 0x0E) goto yy1241; } else { - if (yych <= 'Q') { - if (yych == '>') goto yy982; - } else { - if (yych <= 'R') goto yy1095; - if (yych == 'r') goto yy1095; - } + if (yych <= ' ') goto yy1271; + if (yych == '>') goto yy1243; + goto yy1241; } -yy822: - p = marker; - goto yy816; -yy823: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'Q') goto yy822; - if (yych <= 'R') goto yy1088; - goto yy1087; +yy1271: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1241; + if (yych <= '\r') goto yy1271; + goto yy1241; } else { - if (yych <= 'q') goto yy822; - if (yych <= 'r') goto yy1088; - if (yych <= 's') goto yy1087; - goto yy822; + if (yych <= ' ') goto yy1271; + if (yych == '>') goto yy1243; + goto yy1241; } -yy824: - yych = *++p; - if (yych <= 'Q') { - if (yych <= 'D') { - if (yych <= '0') goto yy822; - if (yych <= '6') goto yy981; - goto yy822; +yy1273: + ++p; + yych = *p; + if (yych <= '9') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1241; + if (yych >= 0x0E) goto yy1241; } else { - if (yych <= 'E') goto yy1080; - if (yych == 'G') goto yy1079; - goto yy822; + if (yych <= ' ') goto yy1275; + if (yych <= '.') goto yy1241; + if (yych <= '/') goto yy1277; + goto yy1273; } } else { - if (yych <= 'f') { - if (yych <= 'R') goto yy981; - if (yych == 'e') goto yy1080; - goto yy822; + if (yych <= '@') { + if (yych == '>') goto yy1243; + goto yy1241; } else { - if (yych <= 'g') goto yy1079; - if (yych == 'r') goto yy981; - goto yy822; + if (yych <= 'Z') goto yy1273; + if (yych <= '`') goto yy1241; + if (yych <= 'z') goto yy1273; + goto yy1241; } } -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; +yy1275: + ++p; + yych = *p; + if (yych <= ':') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy1241; + if (yych <= '\r') goto yy1275; + if (yych <= 0x1F) goto yy1241; + goto yy1275; } else { - if (yych <= 'O') goto yy1062; - if (yych <= 'T') goto yy822; - goto yy1061; + if (yych == '/') goto yy1277; + if (yych <= '9') goto yy1241; + goto yy1278; } } else { - if (yych <= 'n') { - if (yych == 'l') goto yy1063; - goto yy822; + if (yych <= 'Z') { + if (yych == '>') goto yy1243; + if (yych <= '@') goto yy1241; + goto yy1278; } else { - if (yych <= 'o') goto yy1062; - if (yych == 'u') goto yy1061; - goto yy822; + if (yych <= '_') { + if (yych <= '^') goto yy1241; + goto yy1278; + } else { + if (yych <= '`') goto yy1241; + if (yych <= 'z') goto yy1278; + goto yy1241; + } } } -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: +yy1277: 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; + if (yych == '>') goto yy1243; + goto yy1241; +yy1278: + ++p; + yych = *p; + if (yybm[0+yych] & 16) { + goto yy1278; + } + if (yych <= '.') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy1241; } else { - if (yych <= 'l') goto yy981; - if (yych == 'u') goto yy1052; - goto yy822; + if (yych != ' ') goto yy1241; } - } -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; + if (yych <= '<') { + if (yych <= '/') goto yy1277; + goto yy1241; } else { - if (yych == 'o') goto yy1038; - goto yy822; + if (yych <= '=') goto yy1282; + if (yych <= '>') goto yy1243; + goto yy1241; } } -yy831: - yych = *++p; - if (yych <= 'T') { - if (yych <= 'I') { - if (yych == 'D') goto yy981; - if (yych <= 'H') goto yy822; - goto yy1037; +yy1280: + ++p; + yych = *p; + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy1241; + if (yych <= '\r') goto yy1280; + if (yych <= 0x1F) goto yy1241; + goto yy1280; } else { - if (yych == 'L') goto yy981; - if (yych <= 'S') goto yy822; - goto yy981; + if (yych <= '/') { + if (yych <= '.') goto yy1241; + goto yy1277; + } else { + if (yych == ':') goto yy1278; + goto yy1241; + } } } else { - if (yych <= 'i') { - if (yych == 'd') goto yy981; - if (yych <= 'h') goto yy822; - goto yy1037; + if (yych <= 'Z') { + if (yych <= '=') goto yy1282; + if (yych <= '>') goto yy1243; + if (yych <= '@') goto yy1241; + goto yy1278; } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy822; - goto yy981; + if (yych <= '_') { + if (yych <= '^') goto yy1241; + goto yy1278; } else { - if (yych == 't') goto yy981; - goto yy822; + if (yych <= '`') goto yy1241; + if (yych <= 'z') goto yy1278; + goto yy1241; } } } -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; - } +yy1282: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1284; } -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; + if (yych <= 0x00) goto yy1241; + if (yych <= '!') goto yy1283; + if (yych <= '"') goto yy1288; + if (yych <= ';') goto yy1286; + goto yy1241; +yy1283: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1284; } -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; + if (yych <= '"') { + if (yych <= 0x00) goto yy1241; + if (yych <= '!') goto yy1297; + goto yy1288; } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy822; - goto yy985; - } else { - if (yych == 'o') goto yy984; - goto yy822; - } + if (yych <= ';') goto yy1286; + if (yych == '>') goto yy1243; + goto yy1241; } -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; +yy1284: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1284; } -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; - } + if (yych <= 0x00) goto yy1241; + if (yych <= '!') goto yy1291; + if (yych == '>') goto yy1243; + goto yy1241; +yy1286: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1286; } -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; + if (yych <= 0x00) goto yy1241; + goto yy1290; +yy1288: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1288; } -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; - } + if (yych <= 0x00) goto yy1241; +yy1290: + ++p; + yych = *p; + if (yych <= ' ') { + if (yych <= 0x08) goto yy1241; + if (yych <= '\r') goto yy1275; + if (yych <= 0x1F) goto yy1241; + goto yy1275; } else { - if (yych <= 'f') { - if (yych <= 'R') goto yy858; - if (yych == 'e') goto yy957; - goto yy822; + if (yych <= '/') { + if (yych <= '.') goto yy1241; + goto yy1277; } else { - if (yych <= 'g') goto yy956; - if (yych == 'r') goto yy858; - goto yy822; + if (yych == '>') goto yy1243; + goto yy1241; } } -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; +yy1291: + ++p; + yych = *p; + if (yych <= '9') { + if (yych <= ' ') { + if (yych <= 0x08) { + if (yych <= 0x00) goto yy1241; + goto yy1284; + } else { + if (yych <= '\r') goto yy1291; + if (yych <= 0x1F) goto yy1284; + goto yy1291; + } } else { - if (yych <= 'O') goto yy939; - if (yych <= 'T') goto yy822; - goto yy938; + if (yych <= '"') { + if (yych <= '!') goto yy1284; + goto yy1241; + } else { + if (yych == '\'') goto yy1241; + goto yy1284; + } } } else { - if (yych <= 'n') { - if (yych == 'l') goto yy940; - goto yy822; + if (yych <= '@') { + if (yych <= ';') { + if (yych >= ';') goto yy1284; + } else { + if (yych <= '=') goto yy1241; + if (yych <= '>') goto yy1243; + goto yy1284; + } } else { - if (yych <= 'o') goto yy939; - if (yych == 'u') goto yy938; - goto yy822; + if (yych <= '_') { + if (yych <= 'Z') goto yy1293; + if (yych <= '^') goto yy1284; + } else { + if (yych <= '`') goto yy1241; + if (yych >= '{') goto yy1284; + } } } -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; +yy1293: + ++p; + yych = *p; + if (yych <= '/') { + if (yych <= '!') { + if (yych <= '\r') { + if (yych <= 0x00) goto yy1241; + if (yych <= 0x08) goto yy1284; + } else { + if (yych != ' ') goto yy1284; + } } else { - if (yych <= 'l') goto yy858; - if (yych == 'u') goto yy929; - goto yy822; + if (yych <= '\'') { + if (yych <= '"') goto yy1241; + if (yych <= '&') goto yy1284; + goto yy1241; + } else { + if (yych <= ',') goto yy1284; + if (yych <= '.') goto yy1293; + goto yy1284; + } } - } -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; + if (yych <= '@') { + if (yych <= '<') { + if (yych <= ':') goto yy1293; + if (yych <= ';') goto yy1284; + goto yy1241; + } else { + if (yych <= '=') goto yy1282; + if (yych <= '>') goto yy1243; + goto yy1284; + } } else { - if (yych == 'o') goto yy915; - goto yy822; + if (yych <= '_') { + if (yych <= 'Z') goto yy1293; + if (yych <= '^') goto yy1284; + goto yy1293; + } else { + if (yych <= '`') goto yy1241; + if (yych <= 'z') goto yy1293; + goto yy1284; + } } } -yy848: - yych = *++p; - if (yych <= 'T') { - if (yych <= 'I') { - if (yych == 'D') goto yy858; - if (yych <= 'H') goto yy822; - goto yy914; +yy1295: + ++p; + yych = *p; + if (yych <= ':') { + if (yych <= ' ') { + if (yych <= 0x08) { + if (yych <= 0x00) goto yy1241; + goto yy1284; + } else { + if (yych <= '\r') goto yy1295; + if (yych <= 0x1F) goto yy1284; + goto yy1295; + } } else { - if (yych == 'L') goto yy858; - if (yych <= 'S') goto yy822; - goto yy858; + if (yych <= '&') { + if (yych == '"') goto yy1241; + goto yy1284; + } else { + if (yych <= '\'') goto yy1241; + if (yych <= '9') goto yy1284; + goto yy1293; + } } } else { - if (yych <= 'i') { - if (yych == 'd') goto yy858; - if (yych <= 'h') goto yy822; - goto yy914; + if (yych <= '@') { + if (yych <= '<') { + if (yych <= ';') goto yy1284; + goto yy1241; + } else { + if (yych <= '=') goto yy1282; + if (yych <= '>') goto yy1243; + goto yy1284; + } } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy822; - goto yy858; + if (yych <= '_') { + if (yych <= 'Z') goto yy1293; + if (yych <= '^') goto yy1284; + goto yy1293; } else { - if (yych == 't') goto yy858; - goto yy822; + if (yych <= '`') goto yy1241; + if (yych <= 'z') goto yy1293; + goto yy1284; } } } -yy849: - yych = *++p; - if (yych <= 'T') { - if (yych <= 'D') { - if (yych == 'C') goto yy903; - goto yy822; +yy1297: + ++p; + yych = *p; + if (yych <= '9') { + if (yych <= ' ') { + if (yych <= 0x08) { + if (yych <= 0x00) goto yy1241; + goto yy1284; + } else { + if (yych <= '\r') goto yy1297; + if (yych <= 0x1F) goto yy1284; + goto yy1297; + } } else { - if (yych <= 'E') goto yy904; - if (yych <= 'S') goto yy822; - goto yy902; + if (yych <= '"') { + if (yych <= '!') goto yy1284; + goto yy1288; + } else { + if (yych == '\'') goto yy1286; + goto yy1284; + } } } else { - if (yych <= 'd') { - if (yych == 'c') goto yy903; - goto yy822; + if (yych <= '@') { + if (yych <= ';') { + if (yych <= ':') goto yy1293; + goto yy1284; + } else { + if (yych <= '=') goto yy1241; + if (yych <= '>') goto yy1243; + goto yy1284; + } } else { - if (yych <= 'e') goto yy904; - if (yych == 't') goto yy902; - goto yy822; + if (yych <= '_') { + if (yych <= 'Z') goto yy1293; + if (yych <= '^') goto yy1284; + goto yy1293; + } else { + if (yych <= '`') goto yy1241; + if (yych <= 'z') goto yy1293; + goto yy1284; + } } } -yy850: - yych = *++p; +} + +} + +// 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 yy1301; + if (yych == '<') goto yy1302; + goto yy1303; +yy1301: + { return 0; } +yy1302: + yych = *(marker = ++p); switch (yych) { + case '!': + case '?': goto yy1304; + case '/': goto yy1323; case 'A': - case 'a': goto yy888; + case 'a': goto yy1308; case 'B': - case 'b': goto yy887; + case 'b': goto yy1311; + case 'C': + case 'c': goto yy1315; case 'D': - case 'R': - case 'd': - case 'r': goto yy858; + case 'd': goto yy1316; case 'E': - case 'e': goto yy886; + case 'e': goto yy1319; case 'F': - case 'f': goto yy885; + case 'f': goto yy1320; 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: + case 'h': goto yy1309; + case 'I': + case 'i': goto yy1310; + case 'L': + case 'l': goto yy1312; + case 'M': + case 'm': goto yy1313; + case 'O': + case 'o': goto yy1314; + case 'P': + case 'p': goto yy1306; + case 'S': + case 's': goto yy1317; + case 'T': + case 't': goto yy1318; + case 'U': + case 'u': goto yy1321; + case 'V': + case 'v': goto yy1322; + default: goto yy1301; + } +yy1303: yych = *++p; - if (yych == 'T') goto yy858; - if (yych == 't') goto yy858; - goto yy822; -yy912: + goto yy1301; +yy1304: + ++p; + { return (p - start); } +yy1306: yych = *++p; - if (yych == 'L') goto yy913; - if (yych != 'l') goto yy822; -yy913: + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1307; + if (yych <= '\r') goto yy1467; + } else { + if (yych <= ' ') goto yy1467; + if (yych >= '/') goto yy1467; + } + } else { + if (yych <= 'Q') { + if (yych == '>') goto yy1467; + } else { + if (yych <= 'R') goto yy1580; + if (yych == 'r') goto yy1580; + } + } +yy1307: + p = marker; + goto yy1301; +yy1308: yych = *++p; - if (yych == 'E') goto yy858; - if (yych == 'e') goto yy858; - goto yy822; -yy914: + if (yych <= 'S') { + if (yych <= 'Q') goto yy1307; + if (yych <= 'R') goto yy1573; + goto yy1572; + } else { + if (yych <= 'q') goto yy1307; + if (yych <= 'r') goto yy1573; + if (yych <= 's') goto yy1572; + goto yy1307; + } +yy1309: yych = *++p; - if (yych == 'V') goto yy858; - if (yych == 'v') goto yy858; - goto yy822; -yy915: + if (yych <= 'Q') { + if (yych <= 'D') { + if (yych <= '0') goto yy1307; + if (yych <= '6') goto yy1466; + goto yy1307; + } else { + if (yych <= 'E') goto yy1565; + if (yych == 'G') goto yy1564; + goto yy1307; + } + } else { + if (yych <= 'f') { + if (yych <= 'R') goto yy1466; + if (yych == 'e') goto yy1565; + goto yy1307; + } else { + if (yych <= 'g') goto yy1564; + if (yych == 'r') goto yy1466; + goto yy1307; + } + } +yy1310: yych = *++p; - if (yych == 'L') goto yy924; - if (yych == 'l') goto yy924; - goto yy822; -yy916: + if (yych == 'F') goto yy1560; + if (yych == 'f') goto yy1560; + goto yy1307; +yy1311: yych = *++p; - if (yych <= 'P') { - if (yych == 'N') goto yy917; - if (yych <= 'O') goto yy822; - goto yy918; + if (yych <= 'U') { + if (yych <= 'N') { + if (yych == 'L') goto yy1548; + goto yy1307; + } else { + if (yych <= 'O') goto yy1547; + if (yych <= 'T') goto yy1307; + goto yy1546; + } } else { if (yych <= 'n') { - if (yych <= 'm') goto yy822; + if (yych == 'l') goto yy1548; + goto yy1307; } else { - if (yych == 'p') goto yy918; - goto yy822; + if (yych <= 'o') goto yy1547; + if (yych == 'u') goto yy1546; + goto yy1307; } } -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: +yy1312: yych = *++p; - if (yych == 'A') goto yy923; - if (yych != 'a') goto yy822; -yy923: + if (yych == 'I') goto yy1466; + if (yych == 'i') goto yy1466; + goto yy1307; +yy1313: yych = *++p; - if (yych == 'S') goto yy858; - if (yych == 's') goto yy858; - goto yy822; -yy924: + if (yych == 'A') goto yy1545; + if (yych == 'a') goto yy1545; + goto yy1307; +yy1314: yych = *++p; - if (yych <= '=') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy822; - goto yy859; + if (yych <= 'U') { + if (yych <= 'K') { + if (yych == 'B') goto yy1538; + goto yy1307; } else { - if (yych == ' ') goto yy859; - goto yy822; + if (yych <= 'L') goto yy1466; + if (yych <= 'T') goto yy1307; + goto yy1537; } } else { - if (yych <= 'G') { - if (yych <= '>') goto yy859; - if (yych <= 'F') goto yy822; + if (yych <= 'k') { + if (yych == 'b') goto yy1538; + goto yy1307; } else { - if (yych != 'g') goto yy822; + if (yych <= 'l') goto yy1466; + if (yych == 'u') goto yy1537; + goto yy1307; } } +yy1315: 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: + if (yych <= 'O') { + if (yych == 'A') goto yy1524; + if (yych <= 'N') goto yy1307; + goto yy1523; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy1307; + goto yy1524; + } else { + if (yych == 'o') goto yy1523; + goto yy1307; + } + } +yy1316: yych = *++p; - if (yych == 'R') goto yy961; - if (yych == 'r') goto yy961; - goto yy822; -yy957: + if (yych <= 'T') { + if (yych <= 'I') { + if (yych == 'D') goto yy1466; + if (yych <= 'H') goto yy1307; + goto yy1522; + } else { + if (yych == 'L') goto yy1466; + if (yych <= 'S') goto yy1307; + goto yy1466; + } + } else { + if (yych <= 'i') { + if (yych == 'd') goto yy1466; + if (yych <= 'h') goto yy1307; + goto yy1522; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy1307; + goto yy1466; + } else { + if (yych == 't') goto yy1466; + goto yy1307; + } + } + } +yy1317: yych = *++p; - if (yych == 'A') goto yy958; - if (yych != 'a') goto yy822; -yy958: + if (yych <= 'T') { + if (yych <= 'D') { + if (yych == 'C') goto yy1511; + goto yy1307; + } else { + if (yych <= 'E') goto yy1512; + if (yych <= 'S') goto yy1307; + goto yy1510; + } + } else { + if (yych <= 'd') { + if (yych == 'c') goto yy1511; + goto yy1307; + } else { + if (yych <= 'e') goto yy1512; + if (yych == 't') goto yy1510; + goto yy1307; + } + } +yy1318: yych = *++p; - if (yych == 'D') goto yy959; - if (yych != 'd') goto yy822; -yy959: + switch (yych) { + case 'A': + case 'a': goto yy1496; + case 'B': + case 'b': goto yy1495; + case 'D': + case 'R': + case 'd': + case 'r': goto yy1466; + case 'E': + case 'e': goto yy1494; + case 'F': + case 'f': goto yy1493; + case 'H': + case 'h': goto yy1492; + default: goto yy1307; + } +yy1319: yych = *++p; - if (yych == 'E') goto yy960; - if (yych != 'e') goto yy822; -yy960: + if (yych == 'M') goto yy1489; + if (yych == 'm') goto yy1489; + goto yy1307; +yy1320: yych = *++p; - if (yych == 'R') goto yy858; - if (yych == 'r') goto yy858; - goto yy822; -yy961: + if (yych <= 'O') { + if (yych == 'I') goto yy1470; + if (yych <= 'N') goto yy1307; + goto yy1469; + } else { + if (yych <= 'i') { + if (yych <= 'h') goto yy1307; + goto yy1470; + } else { + if (yych == 'o') goto yy1469; + goto yy1307; + } + } +yy1321: yych = *++p; - if (yych == 'O') goto yy962; - if (yych != 'o') goto yy822; -yy962: + if (yych == 'L') goto yy1466; + if (yych == 'l') goto yy1466; + goto yy1307; +yy1322: yych = *++p; - if (yych == 'U') goto yy963; - if (yych != 'u') goto yy822; -yy963: + if (yych == 'I') goto yy1463; + if (yych == 'i') goto yy1463; + goto yy1307; +yy1323: yych = *++p; - if (yych == 'P') goto yy858; - if (yych == 'p') goto yy858; - goto yy822; -yy964: + switch (yych) { + case 'A': + case 'a': goto yy1325; + case 'B': + case 'b': goto yy1328; + case 'C': + case 'c': goto yy1332; + case 'D': + case 'd': goto yy1333; + case 'E': + case 'e': goto yy1336; + case 'F': + case 'f': goto yy1337; + case 'H': + case 'h': goto yy1326; + case 'I': + case 'i': goto yy1327; + case 'L': + case 'l': goto yy1329; + case 'M': + case 'm': goto yy1330; + case 'O': + case 'o': goto yy1331; + case 'P': + case 'p': goto yy1324; + case 'S': + case 's': goto yy1334; + case 'T': + case 't': goto yy1335; + case 'U': + case 'u': goto yy1338; + case 'V': + case 'v': goto yy1339; + default: goto yy1307; + } +yy1324: yych = *++p; - if (yych == 'I') goto yy970; - if (yych == 'i') goto yy970; - goto yy822; -yy965: + if (yych <= '=') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy1307; + goto yy1344; + } else { + if (yych == ' ') goto yy1344; + goto yy1307; + } + } else { + if (yych <= 'R') { + if (yych <= '>') goto yy1344; + if (yych <= 'Q') goto yy1307; + goto yy1457; + } else { + if (yych == 'r') goto yy1457; + goto yy1307; + } + } +yy1325: yych = *++p; - if (yych == 'T') goto yy966; - if (yych != 't') goto yy822; -yy966: + if (yych <= 'S') { + if (yych <= 'Q') goto yy1307; + if (yych <= 'R') goto yy1450; + goto yy1449; + } else { + if (yych <= 'q') goto yy1307; + if (yych <= 'r') goto yy1450; + if (yych <= 's') goto yy1449; + goto yy1307; + } +yy1326: yych = *++p; - if (yych == 'I') goto yy967; - if (yych != 'i') goto yy822; -yy967: + if (yych <= 'Q') { + if (yych <= 'D') { + if (yych <= '0') goto yy1307; + if (yych <= '6') goto yy1343; + goto yy1307; + } else { + if (yych <= 'E') goto yy1442; + if (yych == 'G') goto yy1441; + goto yy1307; + } + } else { + if (yych <= 'f') { + if (yych <= 'R') goto yy1343; + if (yych == 'e') goto yy1442; + goto yy1307; + } else { + if (yych <= 'g') goto yy1441; + if (yych == 'r') goto yy1343; + goto yy1307; + } + } +yy1327: yych = *++p; - if (yych == 'C') goto yy968; - if (yych != 'c') goto yy822; -yy968: + if (yych == 'F') goto yy1437; + if (yych == 'f') goto yy1437; + goto yy1307; +yy1328: yych = *++p; - if (yych == 'L') goto yy969; - if (yych != 'l') goto yy822; -yy969: + if (yych <= 'U') { + if (yych <= 'N') { + if (yych == 'L') goto yy1425; + goto yy1307; + } else { + if (yych <= 'O') goto yy1424; + if (yych <= 'T') goto yy1307; + goto yy1423; + } + } else { + if (yych <= 'n') { + if (yych == 'l') goto yy1425; + goto yy1307; + } else { + if (yych <= 'o') goto yy1424; + if (yych == 'u') goto yy1423; + goto yy1307; + } + } +yy1329: yych = *++p; - if (yych == 'E') goto yy858; - if (yych == 'e') goto yy858; - goto yy822; -yy970: + if (yych == 'I') goto yy1343; + if (yych == 'i') goto yy1343; + goto yy1307; +yy1330: yych = *++p; - if (yych == 'D') goto yy971; - if (yych != 'd') goto yy822; -yy971: + if (yych == 'A') goto yy1422; + if (yych == 'a') goto yy1422; + goto yy1307; +yy1331: yych = *++p; - if (yych == 'E') goto yy858; - if (yych == 'e') goto yy858; - goto yy822; -yy972: + if (yych <= 'U') { + if (yych <= 'K') { + if (yych == 'B') goto yy1415; + goto yy1307; + } else { + if (yych <= 'L') goto yy1343; + if (yych <= 'T') goto yy1307; + goto yy1414; + } + } else { + if (yych <= 'k') { + if (yych == 'b') goto yy1415; + goto yy1307; + } else { + if (yych <= 'l') goto yy1343; + if (yych == 'u') goto yy1414; + goto yy1307; + } + } +yy1332: yych = *++p; if (yych <= 'O') { - if (yych == 'E') goto yy858; - if (yych <= 'N') goto yy822; + if (yych == 'A') goto yy1401; + if (yych <= 'N') goto yy1307; + goto yy1400; } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy822; - goto yy858; + if (yych <= 'a') { + if (yych <= '`') goto yy1307; + goto yy1401; } else { - if (yych != 'o') goto yy822; + if (yych == 'o') goto yy1400; + goto yy1307; } } +yy1333: yych = *++p; - if (yych == 'G') goto yy974; - if (yych != 'g') goto yy822; -yy974: + if (yych <= 'T') { + if (yych <= 'I') { + if (yych == 'D') goto yy1343; + if (yych <= 'H') goto yy1307; + goto yy1399; + } else { + if (yych == 'L') goto yy1343; + if (yych <= 'S') goto yy1307; + goto yy1343; + } + } else { + if (yych <= 'i') { + if (yych == 'd') goto yy1343; + if (yych <= 'h') goto yy1307; + goto yy1399; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy1307; + goto yy1343; + } else { + if (yych == 't') goto yy1343; + goto yy1307; + } + } + } +yy1334: yych = *++p; - if (yych == 'R') goto yy975; - if (yych != 'r') goto yy822; -yy975: + if (yych <= 'T') { + if (yych <= 'D') { + if (yych == 'C') goto yy1388; + goto yy1307; + } else { + if (yych <= 'E') goto yy1389; + if (yych <= 'S') goto yy1307; + goto yy1387; + } + } else { + if (yych <= 'd') { + if (yych == 'c') goto yy1388; + goto yy1307; + } else { + if (yych <= 'e') goto yy1389; + if (yych == 't') goto yy1387; + goto yy1307; + } + } +yy1335: yych = *++p; - if (yych == 'E') goto yy976; - if (yych != 'e') goto yy822; -yy976: + switch (yych) { + case 'A': + case 'a': goto yy1373; + case 'B': + case 'b': goto yy1372; + case 'D': + case 'R': + case 'd': + case 'r': goto yy1343; + case 'E': + case 'e': goto yy1371; + case 'F': + case 'f': goto yy1370; + case 'H': + case 'h': goto yy1369; + default: goto yy1307; + } +yy1336: yych = *++p; - if (yych == 'S') goto yy977; - if (yych != 's') goto yy822; -yy977: + if (yych == 'M') goto yy1366; + if (yych == 'm') goto yy1366; + goto yy1307; +yy1337: yych = *++p; - if (yych == 'S') goto yy858; - if (yych == 's') goto yy858; - goto yy822; -yy978: + if (yych <= 'O') { + if (yych == 'I') goto yy1347; + if (yych <= 'N') goto yy1307; + goto yy1346; + } else { + if (yych <= 'i') { + if (yych <= 'h') goto yy1307; + goto yy1347; + } else { + if (yych == 'o') goto yy1346; + goto yy1307; + } + } +yy1338: yych = *++p; - if (yych == 'D') goto yy979; - if (yych != 'd') goto yy822; -yy979: + if (yych == 'L') goto yy1343; + if (yych == 'l') goto yy1343; + goto yy1307; +yy1339: yych = *++p; - if (yych == 'E') goto yy980; - if (yych != 'e') goto yy822; -yy980: + if (yych == 'I') goto yy1340; + if (yych != 'i') goto yy1307; +yy1340: yych = *++p; - if (yych == 'O') goto yy981; - if (yych != 'o') goto yy822; -yy981: + if (yych == 'D') goto yy1341; + if (yych != 'd') goto yy1307; +yy1341: yych = *++p; - if (yych <= ' ') { - if (yych <= 0x08) goto yy822; - if (yych <= '\r') goto yy982; - if (yych <= 0x1F) goto yy822; + if (yych == 'E') goto yy1342; + if (yych != 'e') goto yy1307; +yy1342: + yych = *++p; + if (yych == 'O') goto yy1343; + if (yych != 'o') goto yy1307; +yy1343: + yych = *++p; + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1307; + if (yych >= 0x0E) goto yy1307; } else { - if (yych <= '/') { - if (yych <= '.') goto yy822; - } else { - if (yych != '>') goto yy822; - } + if (yych <= ' ') goto yy1344; + if (yych != '>') goto yy1307; } -yy982: +yy1344: ++p; { return (p - start); } -yy984: +yy1346: yych = *++p; if (yych <= 'R') { - if (yych == 'O') goto yy1000; - if (yych <= 'Q') goto yy822; - goto yy1001; + if (yych == 'O') goto yy1362; + if (yych <= 'Q') goto yy1307; + goto yy1363; } else { if (yych <= 'o') { - if (yych <= 'n') goto yy822; - goto yy1000; + if (yych <= 'n') goto yy1307; + goto yy1362; } else { - if (yych == 'r') goto yy1001; - goto yy822; + if (yych == 'r') goto yy1363; + goto yy1307; } } -yy985: +yy1347: yych = *++p; if (yych <= 'G') { - if (yych == 'E') goto yy986; - if (yych <= 'F') goto yy822; - goto yy987; + if (yych == 'E') goto yy1348; + if (yych <= 'F') goto yy1307; + goto yy1349; } else { if (yych <= 'e') { - if (yych <= 'd') goto yy822; + if (yych <= 'd') goto yy1307; } else { - if (yych == 'g') goto yy987; - goto yy822; + if (yych == 'g') goto yy1349; + goto yy1307; } } -yy986: +yy1348: yych = *++p; - if (yych == 'L') goto yy996; - if (yych == 'l') goto yy996; - goto yy822; -yy987: + if (yych == 'L') goto yy1358; + if (yych == 'l') goto yy1358; + goto yy1307; +yy1349: yych = *++p; if (yych <= 'U') { - if (yych == 'C') goto yy989; - if (yych <= 'T') goto yy822; + if (yych == 'C') goto yy1351; + if (yych <= 'T') goto yy1307; } else { if (yych <= 'c') { - if (yych <= 'b') goto yy822; - goto yy989; + if (yych <= 'b') goto yy1307; + goto yy1351; } else { - if (yych != 'u') goto yy822; + if (yych != 'u') goto yy1307; } } yych = *++p; - if (yych == 'R') goto yy995; - if (yych == 'r') goto yy995; - goto yy822; -yy989: + if (yych == 'R') goto yy1357; + if (yych == 'r') goto yy1357; + goto yy1307; +yy1351: yych = *++p; - if (yych == 'A') goto yy990; - if (yych != 'a') goto yy822; -yy990: + if (yych == 'A') goto yy1352; + if (yych != 'a') goto yy1307; +yy1352: yych = *++p; - if (yych == 'P') goto yy991; - if (yych != 'p') goto yy822; -yy991: + if (yych == 'P') goto yy1353; + if (yych != 'p') goto yy1307; +yy1353: yych = *++p; - if (yych == 'T') goto yy992; - if (yych != 't') goto yy822; -yy992: + if (yych == 'T') goto yy1354; + if (yych != 't') goto yy1307; +yy1354: yych = *++p; - if (yych == 'I') goto yy993; - if (yych != 'i') goto yy822; -yy993: + if (yych == 'I') goto yy1355; + if (yych != 'i') goto yy1307; +yy1355: yych = *++p; - if (yych == 'O') goto yy994; - if (yych != 'o') goto yy822; -yy994: + if (yych == 'O') goto yy1356; + if (yych != 'o') goto yy1307; +yy1356: yych = *++p; - if (yych == 'N') goto yy981; - if (yych == 'n') goto yy981; - goto yy822; -yy995: + if (yych == 'N') goto yy1343; + if (yych == 'n') goto yy1343; + goto yy1307; +yy1357: yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy996: + if (yych == 'E') goto yy1343; + if (yych == 'e') goto yy1343; + goto yy1307; +yy1358: yych = *++p; - if (yych == 'D') goto yy997; - if (yych != 'd') goto yy822; -yy997: + if (yych == 'D') goto yy1359; + if (yych != 'd') goto yy1307; +yy1359: yych = *++p; - if (yych == 'S') goto yy998; - if (yych != 's') goto yy822; -yy998: + if (yych == 'S') goto yy1360; + if (yych != 's') goto yy1307; +yy1360: yych = *++p; - if (yych == 'E') goto yy999; - if (yych != 'e') goto yy822; -yy999: + if (yych == 'E') goto yy1361; + if (yych != 'e') goto yy1307; +yy1361: yych = *++p; - if (yych == 'T') goto yy981; - if (yych == 't') goto yy981; - goto yy822; -yy1000: + if (yych == 'T') goto yy1343; + if (yych == 't') goto yy1343; + goto yy1307; +yy1362: yych = *++p; - if (yych == 'T') goto yy1002; - if (yych == 't') goto yy1002; - goto yy822; -yy1001: + if (yych == 'T') goto yy1364; + if (yych == 't') goto yy1364; + goto yy1307; +yy1363: yych = *++p; - if (yych == 'M') goto yy981; - if (yych == 'm') goto yy981; - goto yy822; -yy1002: + if (yych == 'M') goto yy1343; + if (yych == 'm') goto yy1343; + goto yy1307; +yy1364: yych = *++p; - if (yych == 'E') goto yy1003; - if (yych != 'e') goto yy822; -yy1003: + if (yych == 'E') goto yy1365; + if (yych != 'e') goto yy1307; +yy1365: yych = *++p; - if (yych == 'R') goto yy981; - if (yych == 'r') goto yy981; - goto yy822; -yy1004: + if (yych == 'R') goto yy1343; + if (yych == 'r') goto yy1343; + goto yy1307; +yy1366: yych = *++p; - if (yych == 'B') goto yy1005; - if (yych != 'b') goto yy822; -yy1005: + if (yych == 'B') goto yy1367; + if (yych != 'b') goto yy1307; +yy1367: yych = *++p; - if (yych == 'E') goto yy1006; - if (yych != 'e') goto yy822; -yy1006: + if (yych == 'E') goto yy1368; + if (yych != 'e') goto yy1307; +yy1368: yych = *++p; - if (yych == 'D') goto yy981; - if (yych == 'd') goto yy981; - goto yy822; -yy1007: + if (yych == 'D') goto yy1343; + if (yych == 'd') goto yy1343; + goto yy1307; +yy1369: yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy822; - if (yych <= '\r') goto yy982; - goto yy822; + if (yych <= '=') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy1307; + goto yy1344; } else { - if (yych <= ' ') goto yy982; - if (yych <= '.') goto yy822; - goto yy982; + if (yych == ' ') goto yy1344; + goto yy1307; } } else { - if (yych <= 'D') { - if (yych == '>') goto yy982; - goto yy822; + if (yych <= 'E') { + if (yych <= '>') goto yy1344; + if (yych <= 'D') goto yy1307; + goto yy1385; + } else { + if (yych == 'e') goto yy1385; + goto yy1307; + } + } +yy1370: + yych = *++p; + if (yych == 'O') goto yy1383; + if (yych == 'o') goto yy1383; + goto yy1307; +yy1371: + yych = *++p; + if (yych == 'X') goto yy1378; + if (yych == 'x') goto yy1378; + goto yy1307; +yy1372: + yych = *++p; + if (yych == 'O') goto yy1376; + if (yych == 'o') goto yy1376; + goto yy1307; +yy1373: + yych = *++p; + if (yych == 'B') goto yy1374; + if (yych != 'b') goto yy1307; +yy1374: + yych = *++p; + if (yych == 'L') goto yy1375; + if (yych != 'l') goto yy1307; +yy1375: + yych = *++p; + if (yych == 'E') goto yy1343; + if (yych == 'e') goto yy1343; + goto yy1307; +yy1376: + yych = *++p; + if (yych == 'D') goto yy1377; + if (yych != 'd') goto yy1307; +yy1377: + yych = *++p; + if (yych == 'Y') goto yy1343; + if (yych == 'y') goto yy1343; + goto yy1307; +yy1378: + yych = *++p; + if (yych == 'T') goto yy1379; + if (yych != 't') goto yy1307; +yy1379: + yych = *++p; + if (yych == 'A') goto yy1380; + if (yych != 'a') goto yy1307; +yy1380: + yych = *++p; + if (yych == 'R') goto yy1381; + if (yych != 'r') goto yy1307; +yy1381: + yych = *++p; + if (yych == 'E') goto yy1382; + if (yych != 'e') goto yy1307; +yy1382: + yych = *++p; + if (yych == 'A') goto yy1343; + if (yych == 'a') goto yy1343; + goto yy1307; +yy1383: + yych = *++p; + if (yych == 'O') goto yy1384; + if (yych != 'o') goto yy1307; +yy1384: + yych = *++p; + if (yych == 'T') goto yy1343; + if (yych == 't') goto yy1343; + goto yy1307; +yy1385: + yych = *++p; + if (yych == 'A') goto yy1386; + if (yych != 'a') goto yy1307; +yy1386: + yych = *++p; + if (yych == 'D') goto yy1343; + if (yych == 'd') goto yy1343; + goto yy1307; +yy1387: + yych = *++p; + if (yych == 'Y') goto yy1397; + if (yych == 'y') goto yy1397; + goto yy1307; +yy1388: + yych = *++p; + if (yych == 'R') goto yy1394; + if (yych == 'r') goto yy1394; + goto yy1307; +yy1389: + yych = *++p; + if (yych == 'C') goto yy1390; + if (yych != 'c') goto yy1307; +yy1390: + yych = *++p; + if (yych == 'T') goto yy1391; + if (yych != 't') goto yy1307; +yy1391: + yych = *++p; + if (yych == 'I') goto yy1392; + if (yych != 'i') goto yy1307; +yy1392: + yych = *++p; + if (yych == 'O') goto yy1393; + if (yych != 'o') goto yy1307; +yy1393: + yych = *++p; + if (yych == 'N') goto yy1343; + if (yych == 'n') goto yy1343; + goto yy1307; +yy1394: + yych = *++p; + if (yych == 'I') goto yy1395; + if (yych != 'i') goto yy1307; +yy1395: + yych = *++p; + if (yych == 'P') goto yy1396; + if (yych != 'p') goto yy1307; +yy1396: + yych = *++p; + if (yych == 'T') goto yy1343; + if (yych == 't') goto yy1343; + goto yy1307; +yy1397: + yych = *++p; + if (yych == 'L') goto yy1398; + if (yych != 'l') goto yy1307; +yy1398: + yych = *++p; + if (yych == 'E') goto yy1343; + if (yych == 'e') goto yy1343; + goto yy1307; +yy1399: + yych = *++p; + if (yych == 'V') goto yy1343; + if (yych == 'v') goto yy1343; + goto yy1307; +yy1400: + yych = *++p; + if (yych == 'L') goto yy1409; + if (yych == 'l') goto yy1409; + goto yy1307; +yy1401: + yych = *++p; + if (yych <= 'P') { + if (yych == 'N') goto yy1402; + if (yych <= 'O') goto yy1307; + goto yy1403; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy1307; } else { - if (yych <= 'E') goto yy1023; - if (yych == 'e') goto yy1023; - goto yy822; + if (yych == 'p') goto yy1403; + goto yy1307; } } -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: +yy1402: yych = *++p; - if (yych == 'D') goto yy1015; - if (yych != 'd') goto yy822; -yy1015: + if (yych == 'V') goto yy1407; + if (yych == 'v') goto yy1407; + goto yy1307; +yy1403: yych = *++p; - if (yych == 'Y') goto yy981; - if (yych == 'y') goto yy981; - goto yy822; -yy1016: + if (yych == 'T') goto yy1404; + if (yych != 't') goto yy1307; +yy1404: yych = *++p; - if (yych == 'T') goto yy1017; - if (yych != 't') goto yy822; -yy1017: + if (yych == 'I') goto yy1405; + if (yych != 'i') goto yy1307; +yy1405: yych = *++p; - if (yych == 'A') goto yy1018; - if (yych != 'a') goto yy822; -yy1018: + if (yych == 'O') goto yy1406; + if (yych != 'o') goto yy1307; +yy1406: yych = *++p; - if (yych == 'R') goto yy1019; - if (yych != 'r') goto yy822; -yy1019: + if (yych == 'N') goto yy1343; + if (yych == 'n') goto yy1343; + goto yy1307; +yy1407: yych = *++p; - if (yych == 'E') goto yy1020; - if (yych != 'e') goto yy822; -yy1020: + if (yych == 'A') goto yy1408; + if (yych != 'a') goto yy1307; +yy1408: yych = *++p; - if (yych == 'A') goto yy981; - if (yych == 'a') goto yy981; - goto yy822; -yy1021: + if (yych == 'S') goto yy1343; + if (yych == 's') goto yy1343; + goto yy1307; +yy1409: yych = *++p; - if (yych == 'O') goto yy1022; - if (yych != 'o') goto yy822; -yy1022: + if (yych <= '=') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy1307; + goto yy1344; + } else { + if (yych == ' ') goto yy1344; + goto yy1307; + } + } else { + if (yych <= 'G') { + if (yych <= '>') goto yy1344; + if (yych <= 'F') goto yy1307; + } else { + if (yych != 'g') goto yy1307; + } + } yych = *++p; - if (yych == 'T') goto yy981; - if (yych == 't') goto yy981; - goto yy822; -yy1023: + if (yych == 'R') goto yy1411; + if (yych != 'r') goto yy1307; +yy1411: yych = *++p; - if (yych == 'A') goto yy1024; - if (yych != 'a') goto yy822; -yy1024: + if (yych == 'O') goto yy1412; + if (yych != 'o') goto yy1307; +yy1412: yych = *++p; - if (yych == 'D') goto yy981; - if (yych == 'd') goto yy981; - goto yy822; -yy1025: + if (yych == 'U') goto yy1413; + if (yych != 'u') goto yy1307; +yy1413: yych = *++p; - if (yych == 'Y') goto yy1035; - if (yych == 'y') goto yy1035; - goto yy822; -yy1026: + if (yych == 'P') goto yy1343; + if (yych == 'p') goto yy1343; + goto yy1307; +yy1414: + yych = *++p; + if (yych == 'T') goto yy1419; + if (yych == 't') goto yy1419; + goto yy1307; +yy1415: yych = *++p; - if (yych == 'R') goto yy1032; - if (yych == 'r') goto yy1032; - goto yy822; -yy1027: + if (yych == 'J') goto yy1416; + if (yych != 'j') goto yy1307; +yy1416: yych = *++p; - if (yych == 'C') goto yy1028; - if (yych != 'c') goto yy822; -yy1028: + if (yych == 'E') goto yy1417; + if (yych != 'e') goto yy1307; +yy1417: yych = *++p; - if (yych == 'T') goto yy1029; - if (yych != 't') goto yy822; -yy1029: + if (yych == 'C') goto yy1418; + if (yych != 'c') goto yy1307; +yy1418: + yych = *++p; + if (yych == 'T') goto yy1343; + if (yych == 't') goto yy1343; + goto yy1307; +yy1419: + yych = *++p; + if (yych == 'P') goto yy1420; + if (yych != 'p') goto yy1307; +yy1420: + yych = *++p; + if (yych == 'U') goto yy1421; + if (yych != 'u') goto yy1307; +yy1421: + yych = *++p; + if (yych == 'T') goto yy1343; + if (yych == 't') goto yy1343; + goto yy1307; +yy1422: yych = *++p; - if (yych == 'I') goto yy1030; - if (yych != 'i') goto yy822; -yy1030: + if (yych == 'P') goto yy1343; + if (yych == 'p') goto yy1343; + goto yy1307; +yy1423: + yych = *++p; + if (yych == 'T') goto yy1434; + if (yych == 't') goto yy1434; + goto yy1307; +yy1424: + yych = *++p; + if (yych == 'D') goto yy1433; + if (yych == 'd') goto yy1433; + goto yy1307; +yy1425: + yych = *++p; + if (yych == 'O') goto yy1426; + if (yych != 'o') goto yy1307; +yy1426: + yych = *++p; + if (yych == 'C') goto yy1427; + if (yych != 'c') goto yy1307; +yy1427: + yych = *++p; + if (yych == 'K') goto yy1428; + if (yych != 'k') goto yy1307; +yy1428: + yych = *++p; + if (yych == 'Q') goto yy1429; + if (yych != 'q') goto yy1307; +yy1429: + yych = *++p; + if (yych == 'U') goto yy1430; + if (yych != 'u') goto yy1307; +yy1430: + yych = *++p; + if (yych == 'O') goto yy1431; + if (yych != 'o') goto yy1307; +yy1431: + yych = *++p; + if (yych == 'T') goto yy1432; + if (yych != 't') goto yy1307; +yy1432: + yych = *++p; + if (yych == 'E') goto yy1343; + if (yych == 'e') goto yy1343; + goto yy1307; +yy1433: + yych = *++p; + if (yych == 'Y') goto yy1343; + if (yych == 'y') goto yy1343; + goto yy1307; +yy1434: + yych = *++p; + if (yych == 'T') goto yy1435; + if (yych != 't') goto yy1307; +yy1435: + yych = *++p; + if (yych == 'O') goto yy1436; + if (yych != 'o') goto yy1307; +yy1436: + yych = *++p; + if (yych == 'N') goto yy1343; + if (yych == 'n') goto yy1343; + goto yy1307; +yy1437: + yych = *++p; + if (yych == 'R') goto yy1438; + if (yych != 'r') goto yy1307; +yy1438: + yych = *++p; + if (yych == 'A') goto yy1439; + if (yych != 'a') goto yy1307; +yy1439: + yych = *++p; + if (yych == 'M') goto yy1440; + if (yych != 'm') goto yy1307; +yy1440: + yych = *++p; + if (yych == 'E') goto yy1343; + if (yych == 'e') goto yy1343; + goto yy1307; +yy1441: + yych = *++p; + if (yych == 'R') goto yy1446; + if (yych == 'r') goto yy1446; + goto yy1307; +yy1442: + yych = *++p; + if (yych == 'A') goto yy1443; + if (yych != 'a') goto yy1307; +yy1443: + yych = *++p; + if (yych == 'D') goto yy1444; + if (yych != 'd') goto yy1307; +yy1444: + yych = *++p; + if (yych == 'E') goto yy1445; + if (yych != 'e') goto yy1307; +yy1445: + yych = *++p; + if (yych == 'R') goto yy1343; + if (yych == 'r') goto yy1343; + goto yy1307; +yy1446: + yych = *++p; + if (yych == 'O') goto yy1447; + if (yych != 'o') goto yy1307; +yy1447: + yych = *++p; + if (yych == 'U') goto yy1448; + if (yych != 'u') goto yy1307; +yy1448: + yych = *++p; + if (yych == 'P') goto yy1343; + if (yych == 'p') goto yy1343; + goto yy1307; +yy1449: + yych = *++p; + if (yych == 'I') goto yy1455; + if (yych == 'i') goto yy1455; + goto yy1307; +yy1450: + yych = *++p; + if (yych == 'T') goto yy1451; + if (yych != 't') goto yy1307; +yy1451: + yych = *++p; + if (yych == 'I') goto yy1452; + if (yych != 'i') goto yy1307; +yy1452: + yych = *++p; + if (yych == 'C') goto yy1453; + if (yych != 'c') goto yy1307; +yy1453: + yych = *++p; + if (yych == 'L') goto yy1454; + if (yych != 'l') goto yy1307; +yy1454: + yych = *++p; + if (yych == 'E') goto yy1343; + if (yych == 'e') goto yy1343; + goto yy1307; +yy1455: + yych = *++p; + if (yych == 'D') goto yy1456; + if (yych != 'd') goto yy1307; +yy1456: + yych = *++p; + if (yych == 'E') goto yy1343; + if (yych == 'e') goto yy1343; + goto yy1307; +yy1457: yych = *++p; - if (yych == 'O') goto yy1031; - if (yych != 'o') goto yy822; -yy1031: + if (yych <= 'O') { + if (yych == 'E') goto yy1343; + if (yych <= 'N') goto yy1307; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy1307; + goto yy1343; + } else { + if (yych != 'o') goto yy1307; + } + } yych = *++p; - if (yych == 'N') goto yy981; - if (yych == 'n') goto yy981; - goto yy822; -yy1032: + if (yych == 'G') goto yy1459; + if (yych != 'g') goto yy1307; +yy1459: yych = *++p; - if (yych == 'I') goto yy1033; - if (yych != 'i') goto yy822; -yy1033: + if (yych == 'R') goto yy1460; + if (yych != 'r') goto yy1307; +yy1460: yych = *++p; - if (yych == 'P') goto yy1034; - if (yych != 'p') goto yy822; -yy1034: + if (yych == 'E') goto yy1461; + if (yych != 'e') goto yy1307; +yy1461: yych = *++p; - if (yych == 'T') goto yy981; - if (yych == 't') goto yy981; - goto yy822; -yy1035: + if (yych == 'S') goto yy1462; + if (yych != 's') goto yy1307; +yy1462: yych = *++p; - if (yych == 'L') goto yy1036; - if (yych != 'l') goto yy822; -yy1036: + if (yych == 'S') goto yy1343; + if (yych == 's') goto yy1343; + goto yy1307; +yy1463: yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1037: + if (yych == 'D') goto yy1464; + if (yych != 'd') goto yy1307; +yy1464: yych = *++p; - if (yych == 'V') goto yy981; - if (yych == 'v') goto yy981; - goto yy822; -yy1038: + if (yych == 'E') goto yy1465; + if (yych != 'e') goto yy1307; +yy1465: yych = *++p; - if (yych == 'L') goto yy1047; - if (yych == 'l') goto yy1047; - goto yy822; -yy1039: + if (yych == 'O') goto yy1466; + if (yych != 'o') goto yy1307; +yy1466: yych = *++p; - if (yych <= 'P') { - if (yych == 'N') goto yy1040; - if (yych <= 'O') goto yy822; - goto yy1041; + if (yych <= ' ') { + if (yych <= 0x08) goto yy1307; + if (yych <= '\r') goto yy1467; + if (yych <= 0x1F) goto yy1307; } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy822; + if (yych <= '/') { + if (yych <= '.') goto yy1307; } else { - if (yych == 'p') goto yy1041; - goto yy822; + if (yych != '>') goto yy1307; } } -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: +yy1467: + ++p; + { return (p - start); } +yy1469: yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy822; - if (yych <= '\r') goto yy982; - goto yy822; + if (yych <= 'R') { + if (yych == 'O') goto yy1485; + if (yych <= 'Q') goto yy1307; + goto yy1486; + } else { + if (yych <= 'o') { + if (yych <= 'n') goto yy1307; + goto yy1485; } else { - if (yych <= ' ') goto yy982; - if (yych <= '.') goto yy822; - goto yy982; + if (yych == 'r') goto yy1486; + goto yy1307; } + } +yy1470: + yych = *++p; + if (yych <= 'G') { + if (yych == 'E') goto yy1471; + if (yych <= 'F') goto yy1307; + goto yy1472; } else { - if (yych <= 'F') { - if (yych == '>') goto yy982; - goto yy822; + if (yych <= 'e') { + if (yych <= 'd') goto yy1307; } else { - if (yych <= 'G') goto yy1048; - if (yych != 'g') goto yy822; + if (yych == 'g') goto yy1472; + goto yy1307; } } -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: +yy1471: yych = *++p; - if (yych == 'P') goto yy981; - if (yych == 'p') goto yy981; - goto yy822; -yy1061: + if (yych == 'L') goto yy1481; + if (yych == 'l') goto yy1481; + goto yy1307; +yy1472: yych = *++p; - if (yych == 'T') goto yy1072; - if (yych == 't') goto yy1072; - goto yy822; -yy1062: + if (yych <= 'U') { + if (yych == 'C') goto yy1474; + if (yych <= 'T') goto yy1307; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy1307; + goto yy1474; + } else { + if (yych != 'u') goto yy1307; + } + } yych = *++p; - if (yych == 'D') goto yy1071; - if (yych == 'd') goto yy1071; - goto yy822; -yy1063: + if (yych == 'R') goto yy1480; + if (yych == 'r') goto yy1480; + goto yy1307; +yy1474: yych = *++p; - if (yych == 'O') goto yy1064; - if (yych != 'o') goto yy822; -yy1064: + if (yych == 'A') goto yy1475; + if (yych != 'a') goto yy1307; +yy1475: yych = *++p; - if (yych == 'C') goto yy1065; - if (yych != 'c') goto yy822; -yy1065: + if (yych == 'P') goto yy1476; + if (yych != 'p') goto yy1307; +yy1476: yych = *++p; - if (yych == 'K') goto yy1066; - if (yych != 'k') goto yy822; -yy1066: + if (yych == 'T') goto yy1477; + if (yych != 't') goto yy1307; +yy1477: yych = *++p; - if (yych == 'Q') goto yy1067; - if (yych != 'q') goto yy822; -yy1067: + if (yych == 'I') goto yy1478; + if (yych != 'i') goto yy1307; +yy1478: yych = *++p; - if (yych == 'U') goto yy1068; - if (yych != 'u') goto yy822; -yy1068: + if (yych == 'O') goto yy1479; + if (yych != 'o') goto yy1307; +yy1479: yych = *++p; - if (yych == 'O') goto yy1069; - if (yych != 'o') goto yy822; -yy1069: + if (yych == 'N') goto yy1466; + if (yych == 'n') goto yy1466; + goto yy1307; +yy1480: yych = *++p; - if (yych == 'T') goto yy1070; - if (yych != 't') goto yy822; -yy1070: + if (yych == 'E') goto yy1466; + if (yych == 'e') goto yy1466; + goto yy1307; +yy1481: yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1071: + if (yych == 'D') goto yy1482; + if (yych != 'd') goto yy1307; +yy1482: yych = *++p; - if (yych == 'Y') goto yy981; - if (yych == 'y') goto yy981; - goto yy822; -yy1072: + if (yych == 'S') goto yy1483; + if (yych != 's') goto yy1307; +yy1483: yych = *++p; - if (yych == 'T') goto yy1073; - if (yych != 't') goto yy822; -yy1073: + if (yych == 'E') goto yy1484; + if (yych != 'e') goto yy1307; +yy1484: yych = *++p; - if (yych == 'O') goto yy1074; - if (yych != 'o') goto yy822; -yy1074: + if (yych == 'T') goto yy1466; + if (yych == 't') goto yy1466; + goto yy1307; +yy1485: yych = *++p; - if (yych == 'N') goto yy981; - if (yych == 'n') goto yy981; - goto yy822; -yy1075: + if (yych == 'T') goto yy1487; + if (yych == 't') goto yy1487; + goto yy1307; +yy1486: yych = *++p; - if (yych == 'R') goto yy1076; - if (yych != 'r') goto yy822; -yy1076: + if (yych == 'M') goto yy1466; + if (yych == 'm') goto yy1466; + goto yy1307; +yy1487: yych = *++p; - if (yych == 'A') goto yy1077; - if (yych != 'a') goto yy822; -yy1077: + if (yych == 'E') goto yy1488; + if (yych != 'e') goto yy1307; +yy1488: yych = *++p; - if (yych == 'M') goto yy1078; - if (yych != 'm') goto yy822; -yy1078: + if (yych == 'R') goto yy1466; + if (yych == 'r') goto yy1466; + goto yy1307; +yy1489: yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1079: + if (yych == 'B') goto yy1490; + if (yych != 'b') goto yy1307; +yy1490: yych = *++p; - if (yych == 'R') goto yy1084; - if (yych == 'r') goto yy1084; - goto yy822; -yy1080: + if (yych == 'E') goto yy1491; + if (yych != 'e') goto yy1307; +yy1491: yych = *++p; - if (yych == 'A') goto yy1081; - if (yych != 'a') goto yy822; -yy1081: + if (yych == 'D') goto yy1466; + if (yych == 'd') goto yy1466; + goto yy1307; +yy1492: yych = *++p; - if (yych == 'D') goto yy1082; - if (yych != 'd') goto yy822; -yy1082: + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1307; + if (yych <= '\r') goto yy1467; + goto yy1307; + } else { + if (yych <= ' ') goto yy1467; + if (yych <= '.') goto yy1307; + goto yy1467; + } + } else { + if (yych <= 'D') { + if (yych == '>') goto yy1467; + goto yy1307; + } else { + if (yych <= 'E') goto yy1508; + if (yych == 'e') goto yy1508; + goto yy1307; + } + } +yy1493: + yych = *++p; + if (yych == 'O') goto yy1506; + if (yych == 'o') goto yy1506; + goto yy1307; +yy1494: + yych = *++p; + if (yych == 'X') goto yy1501; + if (yych == 'x') goto yy1501; + goto yy1307; +yy1495: + yych = *++p; + if (yych == 'O') goto yy1499; + if (yych == 'o') goto yy1499; + goto yy1307; +yy1496: + yych = *++p; + if (yych == 'B') goto yy1497; + if (yych != 'b') goto yy1307; +yy1497: + yych = *++p; + if (yych == 'L') goto yy1498; + if (yych != 'l') goto yy1307; +yy1498: + yych = *++p; + if (yych == 'E') goto yy1466; + if (yych == 'e') goto yy1466; + goto yy1307; +yy1499: + yych = *++p; + if (yych == 'D') goto yy1500; + if (yych != 'd') goto yy1307; +yy1500: + yych = *++p; + if (yych == 'Y') goto yy1466; + if (yych == 'y') goto yy1466; + goto yy1307; +yy1501: + yych = *++p; + if (yych == 'T') goto yy1502; + if (yych != 't') goto yy1307; +yy1502: + yych = *++p; + if (yych == 'A') goto yy1503; + if (yych != 'a') goto yy1307; +yy1503: + yych = *++p; + if (yych == 'R') goto yy1504; + if (yych != 'r') goto yy1307; +yy1504: + yych = *++p; + if (yych == 'E') goto yy1505; + if (yych != 'e') goto yy1307; +yy1505: + yych = *++p; + if (yych == 'A') goto yy1466; + if (yych == 'a') goto yy1466; + goto yy1307; +yy1506: + yych = *++p; + if (yych == 'O') goto yy1507; + if (yych != 'o') goto yy1307; +yy1507: + yych = *++p; + if (yych == 'T') goto yy1466; + if (yych == 't') goto yy1466; + goto yy1307; +yy1508: + yych = *++p; + if (yych == 'A') goto yy1509; + if (yych != 'a') goto yy1307; +yy1509: + yych = *++p; + if (yych == 'D') goto yy1466; + if (yych == 'd') goto yy1466; + goto yy1307; +yy1510: + yych = *++p; + if (yych == 'Y') goto yy1520; + if (yych == 'y') goto yy1520; + goto yy1307; +yy1511: + yych = *++p; + if (yych == 'R') goto yy1517; + if (yych == 'r') goto yy1517; + goto yy1307; +yy1512: + yych = *++p; + if (yych == 'C') goto yy1513; + if (yych != 'c') goto yy1307; +yy1513: + yych = *++p; + if (yych == 'T') goto yy1514; + if (yych != 't') goto yy1307; +yy1514: + yych = *++p; + if (yych == 'I') goto yy1515; + if (yych != 'i') goto yy1307; +yy1515: + yych = *++p; + if (yych == 'O') goto yy1516; + if (yych != 'o') goto yy1307; +yy1516: + yych = *++p; + if (yych == 'N') goto yy1466; + if (yych == 'n') goto yy1466; + goto yy1307; +yy1517: + yych = *++p; + if (yych == 'I') goto yy1518; + if (yych != 'i') goto yy1307; +yy1518: + yych = *++p; + if (yych == 'P') goto yy1519; + if (yych != 'p') goto yy1307; +yy1519: + yych = *++p; + if (yych == 'T') goto yy1466; + if (yych == 't') goto yy1466; + goto yy1307; +yy1520: + yych = *++p; + if (yych == 'L') goto yy1521; + if (yych != 'l') goto yy1307; +yy1521: + yych = *++p; + if (yych == 'E') goto yy1466; + if (yych == 'e') goto yy1466; + goto yy1307; +yy1522: + yych = *++p; + if (yych == 'V') goto yy1466; + if (yych == 'v') goto yy1466; + goto yy1307; +yy1523: + yych = *++p; + if (yych == 'L') goto yy1532; + if (yych == 'l') goto yy1532; + goto yy1307; +yy1524: yych = *++p; - if (yych == 'E') goto yy1083; - if (yych != 'e') goto yy822; -yy1083: + if (yych <= 'P') { + if (yych == 'N') goto yy1525; + if (yych <= 'O') goto yy1307; + goto yy1526; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy1307; + } else { + if (yych == 'p') goto yy1526; + goto yy1307; + } + } +yy1525: yych = *++p; - if (yych == 'R') goto yy981; - if (yych == 'r') goto yy981; - goto yy822; -yy1084: + if (yych == 'V') goto yy1530; + if (yych == 'v') goto yy1530; + goto yy1307; +yy1526: yych = *++p; - if (yych == 'O') goto yy1085; - if (yych != 'o') goto yy822; -yy1085: + if (yych == 'T') goto yy1527; + if (yych != 't') goto yy1307; +yy1527: yych = *++p; - if (yych == 'U') goto yy1086; - if (yych != 'u') goto yy822; -yy1086: + if (yych == 'I') goto yy1528; + if (yych != 'i') goto yy1307; +yy1528: yych = *++p; - if (yych == 'P') goto yy981; - if (yych == 'p') goto yy981; - goto yy822; -yy1087: + if (yych == 'O') goto yy1529; + if (yych != 'o') goto yy1307; +yy1529: yych = *++p; - if (yych == 'I') goto yy1093; - if (yych == 'i') goto yy1093; - goto yy822; -yy1088: + if (yych == 'N') goto yy1466; + if (yych == 'n') goto yy1466; + goto yy1307; +yy1530: yych = *++p; - if (yych == 'T') goto yy1089; - if (yych != 't') goto yy822; -yy1089: + if (yych == 'A') goto yy1531; + if (yych != 'a') goto yy1307; +yy1531: yych = *++p; - if (yych == 'I') goto yy1090; - if (yych != 'i') goto yy822; -yy1090: + if (yych == 'S') goto yy1466; + if (yych == 's') goto yy1466; + goto yy1307; +yy1532: yych = *++p; - if (yych == 'C') goto yy1091; - if (yych != 'c') goto yy822; -yy1091: + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1307; + if (yych <= '\r') goto yy1467; + goto yy1307; + } else { + if (yych <= ' ') goto yy1467; + if (yych <= '.') goto yy1307; + goto yy1467; + } + } else { + if (yych <= 'F') { + if (yych == '>') goto yy1467; + goto yy1307; + } else { + if (yych <= 'G') goto yy1533; + if (yych != 'g') goto yy1307; + } + } +yy1533: yych = *++p; - if (yych == 'L') goto yy1092; - if (yych != 'l') goto yy822; -yy1092: + if (yych == 'R') goto yy1534; + if (yych != 'r') goto yy1307; +yy1534: + yych = *++p; + if (yych == 'O') goto yy1535; + if (yych != 'o') goto yy1307; +yy1535: + yych = *++p; + if (yych == 'U') goto yy1536; + if (yych != 'u') goto yy1307; +yy1536: + yych = *++p; + if (yych == 'P') goto yy1466; + if (yych == 'p') goto yy1466; + goto yy1307; +yy1537: + yych = *++p; + if (yych == 'T') goto yy1542; + if (yych == 't') goto yy1542; + goto yy1307; +yy1538: yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1093: + if (yych == 'J') goto yy1539; + if (yych != 'j') goto yy1307; +yy1539: yych = *++p; - if (yych == 'D') goto yy1094; - if (yych != 'd') goto yy822; -yy1094: + if (yych == 'E') goto yy1540; + if (yych != 'e') goto yy1307; +yy1540: yych = *++p; - if (yych == 'E') goto yy981; - if (yych == 'e') goto yy981; - goto yy822; -yy1095: + if (yych == 'C') goto yy1541; + if (yych != 'c') goto yy1307; +yy1541: + yych = *++p; + if (yych == 'T') goto yy1466; + if (yych == 't') goto yy1466; + goto yy1307; +yy1542: + yych = *++p; + if (yych == 'P') goto yy1543; + if (yych != 'p') goto yy1307; +yy1543: + yych = *++p; + if (yych == 'U') goto yy1544; + if (yych != 'u') goto yy1307; +yy1544: + yych = *++p; + if (yych == 'T') goto yy1466; + if (yych == 't') goto yy1466; + goto yy1307; +yy1545: + yych = *++p; + if (yych == 'P') goto yy1466; + if (yych == 'p') goto yy1466; + goto yy1307; +yy1546: + yych = *++p; + if (yych == 'T') goto yy1557; + if (yych == 't') goto yy1557; + goto yy1307; +yy1547: + yych = *++p; + if (yych == 'D') goto yy1556; + if (yych == 'd') goto yy1556; + goto yy1307; +yy1548: + yych = *++p; + if (yych == 'O') goto yy1549; + if (yych != 'o') goto yy1307; +yy1549: + yych = *++p; + if (yych == 'C') goto yy1550; + if (yych != 'c') goto yy1307; +yy1550: + yych = *++p; + if (yych == 'K') goto yy1551; + if (yych != 'k') goto yy1307; +yy1551: + yych = *++p; + if (yych == 'Q') goto yy1552; + if (yych != 'q') goto yy1307; +yy1552: + yych = *++p; + if (yych == 'U') goto yy1553; + if (yych != 'u') goto yy1307; +yy1553: + yych = *++p; + if (yych == 'O') goto yy1554; + if (yych != 'o') goto yy1307; +yy1554: + yych = *++p; + if (yych == 'T') goto yy1555; + if (yych != 't') goto yy1307; +yy1555: + yych = *++p; + if (yych == 'E') goto yy1466; + if (yych == 'e') goto yy1466; + goto yy1307; +yy1556: + yych = *++p; + if (yych == 'Y') goto yy1466; + if (yych == 'y') goto yy1466; + goto yy1307; +yy1557: + yych = *++p; + if (yych == 'T') goto yy1558; + if (yych != 't') goto yy1307; +yy1558: + yych = *++p; + if (yych == 'O') goto yy1559; + if (yych != 'o') goto yy1307; +yy1559: + yych = *++p; + if (yych == 'N') goto yy1466; + if (yych == 'n') goto yy1466; + goto yy1307; +yy1560: + yych = *++p; + if (yych == 'R') goto yy1561; + if (yych != 'r') goto yy1307; +yy1561: + yych = *++p; + if (yych == 'A') goto yy1562; + if (yych != 'a') goto yy1307; +yy1562: + yych = *++p; + if (yych == 'M') goto yy1563; + if (yych != 'm') goto yy1307; +yy1563: + yych = *++p; + if (yych == 'E') goto yy1466; + if (yych == 'e') goto yy1466; + goto yy1307; +yy1564: + yych = *++p; + if (yych == 'R') goto yy1569; + if (yych == 'r') goto yy1569; + goto yy1307; +yy1565: + yych = *++p; + if (yych == 'A') goto yy1566; + if (yych != 'a') goto yy1307; +yy1566: + yych = *++p; + if (yych == 'D') goto yy1567; + if (yych != 'd') goto yy1307; +yy1567: + yych = *++p; + if (yych == 'E') goto yy1568; + if (yych != 'e') goto yy1307; +yy1568: + yych = *++p; + if (yych == 'R') goto yy1466; + if (yych == 'r') goto yy1466; + goto yy1307; +yy1569: + yych = *++p; + if (yych == 'O') goto yy1570; + if (yych != 'o') goto yy1307; +yy1570: + yych = *++p; + if (yych == 'U') goto yy1571; + if (yych != 'u') goto yy1307; +yy1571: + yych = *++p; + if (yych == 'P') goto yy1466; + if (yych == 'p') goto yy1466; + goto yy1307; +yy1572: + yych = *++p; + if (yych == 'I') goto yy1578; + if (yych == 'i') goto yy1578; + goto yy1307; +yy1573: + yych = *++p; + if (yych == 'T') goto yy1574; + if (yych != 't') goto yy1307; +yy1574: + yych = *++p; + if (yych == 'I') goto yy1575; + if (yych != 'i') goto yy1307; +yy1575: + yych = *++p; + if (yych == 'C') goto yy1576; + if (yych != 'c') goto yy1307; +yy1576: + yych = *++p; + if (yych == 'L') goto yy1577; + if (yych != 'l') goto yy1307; +yy1577: + yych = *++p; + if (yych == 'E') goto yy1466; + if (yych == 'e') goto yy1466; + goto yy1307; +yy1578: + yych = *++p; + if (yych == 'D') goto yy1579; + if (yych != 'd') goto yy1307; +yy1579: + yych = *++p; + if (yych == 'E') goto yy1466; + if (yych == 'e') goto yy1466; + goto yy1307; +yy1580: yych = *++p; if (yych <= 'O') { - if (yych == 'E') goto yy981; - if (yych <= 'N') goto yy822; + if (yych == 'E') goto yy1466; + if (yych <= 'N') goto yy1307; } else { if (yych <= 'e') { - if (yych <= 'd') goto yy822; - goto yy981; + if (yych <= 'd') goto yy1307; + goto yy1466; } else { - if (yych != 'o') goto yy822; + if (yych != 'o') goto yy1307; } } yych = *++p; - if (yych == 'G') goto yy1097; - if (yych != 'g') goto yy822; -yy1097: + if (yych == 'G') goto yy1582; + if (yych != 'g') goto yy1307; +yy1582: yych = *++p; - if (yych == 'R') goto yy1098; - if (yych != 'r') goto yy822; -yy1098: + if (yych == 'R') goto yy1583; + if (yych != 'r') goto yy1307; +yy1583: yych = *++p; - if (yych == 'E') goto yy1099; - if (yych != 'e') goto yy822; -yy1099: + if (yych == 'E') goto yy1584; + if (yych != 'e') goto yy1307; +yy1584: yych = *++p; - if (yych == 'S') goto yy1100; - if (yych != 's') goto yy822; -yy1100: + if (yych == 'S') goto yy1585; + if (yych != 's') goto yy1307; +yy1585: ++p; - if ((yych = *p) == 'S') goto yy981; - if (yych == 's') goto yy981; - goto yy822; + if ((yych = *p) == 'S') goto yy1466; + if (yych == 's') goto yy1466; + goto yy1307; } } @@ -10389,402 +13288,402 @@ int _scan_link_url(const unsigned char *p) yych = *p; if (yych <= '(') { if (yych <= 0x1F) { - if (yych == '\n') goto yy1104; - goto yy1112; + if (yych == '\n') goto yy1589; + goto yy1597; } else { - if (yych <= ' ') goto yy1106; - if (yych <= '\'') goto yy1108; - goto yy1111; + if (yych <= ' ') goto yy1591; + if (yych <= '\'') goto yy1593; + goto yy1596; } } else { if (yych <= '<') { - if (yych <= ')') goto yy1112; - if (yych <= ';') goto yy1108; - goto yy1107; + if (yych <= ')') goto yy1597; + if (yych <= ';') goto yy1593; + goto yy1592; } else { - if (yych == '\\') goto yy1109; - goto yy1108; + if (yych == '\\') goto yy1594; + goto yy1593; } } -yy1103: +yy1588: { return (p - start); } -yy1104: +yy1589: yyaccept = 0; marker = ++p; yych = *p; -yy1105: +yy1590: if (yybm[0+yych] & 8) { - goto yy1104; + goto yy1589; } if (yych <= ')') { - if (yych <= ' ') goto yy1103; - if (yych <= '\'') goto yy1117; - if (yych <= '(') goto yy1113; - goto yy1103; + if (yych <= ' ') goto yy1588; + if (yych <= '\'') goto yy1602; + if (yych <= '(') goto yy1598; + goto yy1588; } else { if (yych <= '<') { - if (yych <= ';') goto yy1117; - goto yy1120; + if (yych <= ';') goto yy1602; + goto yy1605; } else { - if (yych == '\\') goto yy1119; - goto yy1117; + if (yych == '\\') goto yy1604; + goto yy1602; } } -yy1106: +yy1591: yyaccept = 0; yych = *(marker = ++p); - goto yy1105; -yy1107: + goto yy1590; +yy1592: yyaccept = 0; yych = *(marker = ++p); if (yybm[0+yych] & 32) { - goto yy1120; + goto yy1605; } if (yych <= '\'') { - if (yych <= 0x00) goto yy1103; - if (yych == '\n') goto yy1103; - goto yy1127; + if (yych <= 0x00) goto yy1588; + if (yych == '\n') goto yy1588; + goto yy1612; } else { if (yych <= ')') { - if (yych <= '(') goto yy1125; - goto yy1127; + if (yych <= '(') goto yy1610; + goto yy1612; } else { - if (yych <= '=') goto yy1117; - if (yych <= '>') goto yy1122; - goto yy1124; + if (yych <= '=') goto yy1602; + if (yych <= '>') goto yy1607; + goto yy1609; } } -yy1108: +yy1593: yyaccept = 0; yych = *(marker = ++p); - goto yy1118; -yy1109: + goto yy1603; +yy1594: ++p; if ((yych = *p) <= '@') { - if (yych <= ' ') goto yy1110; - if (yych <= '/') goto yy1117; - if (yych >= ':') goto yy1117; + if (yych <= ' ') goto yy1595; + if (yych <= '/') goto yy1602; + if (yych >= ':') goto yy1602; } else { if (yych <= '`') { - if (yych >= '[') goto yy1117; + if (yych >= '[') goto yy1602; } else { - if (yych <= 'z') goto yy1110; - if (yych <= '~') goto yy1117; + if (yych <= 'z') goto yy1595; + if (yych <= '~') goto yy1602; } } -yy1110: +yy1595: { return 0; } -yy1111: +yy1596: yyaccept = 1; yych = *(marker = ++p); - if (yych <= ' ') goto yy1110; - if (yych == '(') goto yy1110; - goto yy1114; -yy1112: + if (yych <= ' ') goto yy1595; + if (yych == '(') goto yy1595; + goto yy1599; +yy1597: yych = *++p; - goto yy1110; -yy1113: + goto yy1595; +yy1598: ++p; yych = *p; -yy1114: +yy1599: if (yybm[0+yych] & 16) { - goto yy1113; + goto yy1598; } - if (yych <= '(') goto yy1115; - if (yych <= ')') goto yy1117; - goto yy1116; -yy1115: + if (yych <= '(') goto yy1600; + if (yych <= ')') goto yy1602; + goto yy1601; +yy1600: p = marker; if (yyaccept <= 1) { if (yyaccept == 0) { - goto yy1103; + goto yy1588; } else { - goto yy1110; + goto yy1595; } } else { - goto yy1123; + goto yy1608; } -yy1116: +yy1601: ++p; yych = *p; if (yych <= '@') { - if (yych <= ' ') goto yy1115; - if (yych <= '/') goto yy1113; - if (yych <= '9') goto yy1115; - goto yy1113; + if (yych <= ' ') goto yy1600; + if (yych <= '/') goto yy1598; + if (yych <= '9') goto yy1600; + goto yy1598; } else { if (yych <= '`') { - if (yych <= 'Z') goto yy1115; - goto yy1113; + if (yych <= 'Z') goto yy1600; + goto yy1598; } else { - if (yych <= 'z') goto yy1115; - if (yych <= '~') goto yy1113; - goto yy1115; + if (yych <= 'z') goto yy1600; + if (yych <= '~') goto yy1598; + goto yy1600; } } -yy1117: +yy1602: yyaccept = 0; marker = ++p; yych = *p; -yy1118: +yy1603: if (yych <= '(') { - if (yych <= ' ') goto yy1103; - if (yych <= '\'') goto yy1117; - goto yy1113; + if (yych <= ' ') goto yy1588; + if (yych <= '\'') goto yy1602; + goto yy1598; } else { - if (yych <= ')') goto yy1103; - if (yych != '\\') goto yy1117; + if (yych <= ')') goto yy1588; + if (yych != '\\') goto yy1602; } -yy1119: +yy1604: ++p; yych = *p; if (yych <= '@') { - if (yych <= ' ') goto yy1115; - if (yych <= '/') goto yy1117; - if (yych <= '9') goto yy1115; - goto yy1117; + if (yych <= ' ') goto yy1600; + if (yych <= '/') goto yy1602; + if (yych <= '9') goto yy1600; + goto yy1602; } else { if (yych <= '`') { - if (yych <= 'Z') goto yy1115; - goto yy1117; + if (yych <= 'Z') goto yy1600; + goto yy1602; } else { - if (yych <= 'z') goto yy1115; - if (yych <= '~') goto yy1117; - goto yy1115; + if (yych <= 'z') goto yy1600; + if (yych <= '~') goto yy1602; + goto yy1600; } } -yy1120: +yy1605: yyaccept = 0; marker = ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1120; + goto yy1605; } if (yych <= '\'') { - if (yych <= 0x00) goto yy1103; - if (yych == '\n') goto yy1103; - goto yy1127; + if (yych <= 0x00) goto yy1588; + if (yych == '\n') goto yy1588; + goto yy1612; } else { if (yych <= ')') { - if (yych <= '(') goto yy1125; - goto yy1127; + if (yych <= '(') goto yy1610; + goto yy1612; } else { - if (yych <= '=') goto yy1117; - if (yych >= '?') goto yy1124; + if (yych <= '=') goto yy1602; + if (yych >= '?') goto yy1609; } } -yy1122: +yy1607: yyaccept = 2; yych = *(marker = ++p); - if (yych <= ' ') goto yy1123; - if (yych != ')') goto yy1118; -yy1123: + if (yych <= ' ') goto yy1608; + if (yych != ')') goto yy1603; +yy1608: { return (p - start); } -yy1124: +yy1609: ++p; yych = *p; if (yych <= '>') { if (yych <= ' ') { - if (yych <= 0x00) goto yy1115; - if (yych == '\n') goto yy1115; - goto yy1127; + if (yych <= 0x00) goto yy1600; + if (yych == '\n') goto yy1600; + goto yy1612; } else { - if (yych <= '/') goto yy1120; - if (yych <= '9') goto yy1127; - if (yych <= '=') goto yy1120; - goto yy1137; + if (yych <= '/') goto yy1605; + if (yych <= '9') goto yy1612; + if (yych <= '=') goto yy1605; + goto yy1622; } } else { if (yych <= '\\') { - if (yych <= '@') goto yy1120; - if (yych <= 'Z') goto yy1127; - if (yych <= '[') goto yy1120; - goto yy1138; + if (yych <= '@') goto yy1605; + if (yych <= 'Z') goto yy1612; + if (yych <= '[') goto yy1605; + goto yy1623; } else { - if (yych <= '`') goto yy1120; - if (yych <= 'z') goto yy1127; - if (yych <= '~') goto yy1120; - goto yy1127; + if (yych <= '`') goto yy1605; + if (yych <= 'z') goto yy1612; + if (yych <= '~') goto yy1605; + goto yy1612; } } -yy1125: +yy1610: ++p; yych = *p; if (yych <= ')') { if (yych <= '\n') { - if (yych <= 0x00) goto yy1115; - if (yych >= '\n') goto yy1115; + if (yych <= 0x00) goto yy1600; + if (yych >= '\n') goto yy1600; } else { - if (yych <= ' ') goto yy1127; - if (yych <= '\'') goto yy1125; - if (yych >= ')') goto yy1120; + if (yych <= ' ') goto yy1612; + if (yych <= '\'') goto yy1610; + if (yych >= ')') goto yy1605; } } else { if (yych <= '=') { - if (yych == '<') goto yy1113; - goto yy1125; + if (yych == '<') goto yy1598; + goto yy1610; } else { - if (yych <= '>') goto yy1133; - if (yych == '\\') goto yy1134; - goto yy1125; + if (yych <= '>') goto yy1618; + if (yych == '\\') goto yy1619; + goto yy1610; } } -yy1127: +yy1612: ++p; yych = *p; if (yybm[0+yych] & 64) { - goto yy1127; + goto yy1612; } - if (yych <= '=') goto yy1115; - if (yych >= '?') goto yy1130; -yy1129: + if (yych <= '=') goto yy1600; + if (yych >= '?') goto yy1615; +yy1614: yych = *++p; - goto yy1123; -yy1130: + goto yy1608; +yy1615: ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1130; + goto yy1615; } if (yych <= '\n') { - if (yych <= 0x00) goto yy1115; - if (yych <= '\t') goto yy1127; - goto yy1115; + if (yych <= 0x00) goto yy1600; + if (yych <= '\t') goto yy1612; + goto yy1600; } else { - if (yych != '>') goto yy1127; + if (yych != '>') goto yy1612; } yyaccept = 2; marker = ++p; yych = *p; if (yybm[0+yych] & 64) { - goto yy1127; + goto yy1612; } - if (yych <= '=') goto yy1123; - if (yych <= '>') goto yy1129; - goto yy1130; -yy1133: + if (yych <= '=') goto yy1608; + if (yych <= '>') goto yy1614; + goto yy1615; +yy1618: yyaccept = 2; yych = *(marker = ++p); - if (yych <= ' ') goto yy1123; - if (yych == '(') goto yy1123; - goto yy1114; -yy1134: + if (yych <= ' ') goto yy1608; + if (yych == '(') goto yy1608; + goto yy1599; +yy1619: ++p; yych = *p; if (yych <= '>') { if (yych <= ' ') { - if (yych <= 0x00) goto yy1115; - if (yych == '\n') goto yy1115; - goto yy1127; + if (yych <= 0x00) goto yy1600; + if (yych == '\n') goto yy1600; + goto yy1612; } else { - if (yych <= '/') goto yy1125; - if (yych <= '9') goto yy1127; - if (yych <= '=') goto yy1125; + if (yych <= '/') goto yy1610; + if (yych <= '9') goto yy1612; + if (yych <= '=') goto yy1610; } } else { if (yych <= '\\') { - if (yych <= '@') goto yy1125; - if (yych <= 'Z') goto yy1127; - if (yych <= '[') goto yy1125; - goto yy1136; + if (yych <= '@') goto yy1610; + if (yych <= 'Z') goto yy1612; + if (yych <= '[') goto yy1610; + goto yy1621; } else { - if (yych <= '`') goto yy1125; - if (yych <= 'z') goto yy1127; - if (yych <= '~') goto yy1125; - goto yy1127; + if (yych <= '`') goto yy1610; + if (yych <= 'z') goto yy1612; + if (yych <= '~') goto yy1610; + goto yy1612; } } -yy1135: +yy1620: yyaccept = 2; marker = ++p; yych = *p; if (yych <= ')') { if (yych <= '\n') { - if (yych <= 0x00) goto yy1123; - if (yych <= '\t') goto yy1127; - goto yy1123; + if (yych <= 0x00) goto yy1608; + if (yych <= '\t') goto yy1612; + goto yy1608; } else { - if (yych <= ' ') goto yy1127; - if (yych <= '\'') goto yy1125; - if (yych <= '(') goto yy1127; - goto yy1120; + if (yych <= ' ') goto yy1612; + if (yych <= '\'') goto yy1610; + if (yych <= '(') goto yy1612; + goto yy1605; } } else { if (yych <= '=') { - if (yych == '<') goto yy1113; - goto yy1125; + if (yych == '<') goto yy1598; + goto yy1610; } else { - if (yych <= '>') goto yy1133; - if (yych == '\\') goto yy1134; - goto yy1125; + if (yych <= '>') goto yy1618; + if (yych == '\\') goto yy1619; + goto yy1610; } } -yy1136: +yy1621: ++p; yych = *p; if (yych <= '(') { if (yych <= '\n') { - if (yych <= 0x00) goto yy1115; - if (yych <= '\t') goto yy1127; - goto yy1115; + if (yych <= 0x00) goto yy1600; + if (yych <= '\t') goto yy1612; + goto yy1600; } else { - if (yych <= ' ') goto yy1127; - if (yych <= '\'') goto yy1125; - goto yy1127; + if (yych <= ' ') goto yy1612; + if (yych <= '\'') goto yy1610; + goto yy1612; } } else { if (yych <= '>') { - if (yych <= ')') goto yy1120; - if (yych <= '=') goto yy1125; - goto yy1135; + if (yych <= ')') goto yy1605; + if (yych <= '=') goto yy1610; + goto yy1620; } else { - if (yych == '\\') goto yy1134; - goto yy1125; + if (yych == '\\') goto yy1619; + goto yy1610; } } -yy1137: +yy1622: yyaccept = 2; marker = ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1120; + goto yy1605; } if (yych <= '\'') { - if (yych <= 0x00) goto yy1123; - if (yych == '\n') goto yy1123; - goto yy1127; + if (yych <= 0x00) goto yy1608; + if (yych == '\n') goto yy1608; + goto yy1612; } else { if (yych <= ')') { - if (yych <= '(') goto yy1125; - goto yy1127; + if (yych <= '(') goto yy1610; + goto yy1612; } else { - if (yych <= '=') goto yy1117; - if (yych <= '>') goto yy1122; - goto yy1124; + if (yych <= '=') goto yy1602; + if (yych <= '>') goto yy1607; + goto yy1609; } } -yy1138: +yy1623: yyaccept = 0; marker = ++p; yych = *p; if (yych <= '(') { if (yych <= '\n') { - if (yych <= 0x00) goto yy1103; - if (yych <= '\t') goto yy1127; - goto yy1103; + if (yych <= 0x00) goto yy1588; + if (yych <= '\t') goto yy1612; + goto yy1588; } else { - if (yych <= ' ') goto yy1127; - if (yych <= '\'') goto yy1120; - goto yy1125; + if (yych <= ' ') goto yy1612; + if (yych <= '\'') goto yy1605; + goto yy1610; } } else { if (yych <= '>') { - if (yych <= ')') goto yy1127; - if (yych <= '=') goto yy1120; - goto yy1137; + if (yych <= ')') goto yy1612; + if (yych <= '=') goto yy1605; + goto yy1622; } else { - if (yych == '\\') goto yy1124; - goto yy1120; + if (yych == '\\') goto yy1609; + goto yy1605; } } } @@ -10838,147 +13737,147 @@ int _scan_link_title(const unsigned char *p) }; yych = *p; if (yych <= '"') { - if (yych == '\n') goto yy1141; - if (yych <= '!') goto yy1145; - goto yy1142; + if (yych == '\n') goto yy1626; + if (yych <= '!') goto yy1630; + goto yy1627; } else { - if (yych <= '&') goto yy1145; - if (yych <= '\'') goto yy1143; - if (yych <= '(') goto yy1144; - goto yy1145; + if (yych <= '&') goto yy1630; + if (yych <= '\'') goto yy1628; + if (yych <= '(') goto yy1629; + goto yy1630; } -yy1141: +yy1626: { return 0; } -yy1142: +yy1627: yyaccept = 0; yych = *(marker = ++p); - if (yych <= 0x00) goto yy1141; - goto yy1162; -yy1143: + if (yych <= 0x00) goto yy1626; + goto yy1647; +yy1628: yyaccept = 0; yych = *(marker = ++p); - if (yych <= 0x00) goto yy1141; - goto yy1155; -yy1144: + if (yych <= 0x00) goto yy1626; + goto yy1640; +yy1629: yyaccept = 0; yych = *(marker = ++p); - if (yych <= 0x00) goto yy1141; - goto yy1147; -yy1145: + if (yych <= 0x00) goto yy1626; + goto yy1632; +yy1630: yych = *++p; - goto yy1141; -yy1146: + goto yy1626; +yy1631: ++p; yych = *p; -yy1147: +yy1632: if (yybm[0+yych] & 16) { - goto yy1146; + goto yy1631; } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1151; - goto yy1149; -yy1148: + if (yych <= 0x00) goto yy1633; + if (yych <= '[') goto yy1636; + goto yy1634; +yy1633: p = marker; if (yyaccept <= 1) { if (yyaccept == 0) { - goto yy1141; + goto yy1626; } else { - goto yy1152; + goto yy1637; } } else { if (yyaccept == 2) { - goto yy1159; + goto yy1644; } else { - goto yy1166; + goto yy1651; } } -yy1149: +yy1634: ++p; yych = *p; if (yybm[0+yych] & 16) { - goto yy1146; + goto yy1631; } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1153; - goto yy1149; -yy1151: + if (yych <= 0x00) goto yy1633; + if (yych <= '[') goto yy1638; + goto yy1634; +yy1636: ++p; -yy1152: +yy1637: { return (p - start); } -yy1153: +yy1638: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0+yych] & 16) { - goto yy1146; + goto yy1631; } - if (yych <= 0x00) goto yy1152; - if (yych <= '[') goto yy1151; - goto yy1149; -yy1154: + if (yych <= 0x00) goto yy1637; + if (yych <= '[') goto yy1636; + goto yy1634; +yy1639: ++p; yych = *p; -yy1155: +yy1640: if (yybm[0+yych] & 64) { - goto yy1154; + goto yy1639; } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1158; -yy1156: + if (yych <= 0x00) goto yy1633; + if (yych <= '[') goto yy1643; +yy1641: ++p; yych = *p; if (yybm[0+yych] & 64) { - goto yy1154; + goto yy1639; } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1160; - goto yy1156; -yy1158: + if (yych <= 0x00) goto yy1633; + if (yych <= '[') goto yy1645; + goto yy1641; +yy1643: ++p; -yy1159: +yy1644: { return (p - start); } -yy1160: +yy1645: yyaccept = 2; marker = ++p; yych = *p; if (yybm[0+yych] & 64) { - goto yy1154; + goto yy1639; } - if (yych <= 0x00) goto yy1159; - if (yych <= '[') goto yy1158; - goto yy1156; -yy1161: + if (yych <= 0x00) goto yy1644; + if (yych <= '[') goto yy1643; + goto yy1641; +yy1646: ++p; yych = *p; -yy1162: +yy1647: if (yybm[0+yych] & 128) { - goto yy1161; + goto yy1646; } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1165; -yy1163: + if (yych <= 0x00) goto yy1633; + if (yych <= '[') goto yy1650; +yy1648: ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1161; + goto yy1646; } - if (yych <= 0x00) goto yy1148; - if (yych <= '[') goto yy1167; - goto yy1163; -yy1165: + if (yych <= 0x00) goto yy1633; + if (yych <= '[') goto yy1652; + goto yy1648; +yy1650: ++p; -yy1166: +yy1651: { return (p - start); } -yy1167: +yy1652: yyaccept = 3; marker = ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1161; + goto yy1646; } - if (yych <= 0x00) goto yy1166; - if (yych <= '[') goto yy1165; - goto yy1163; + if (yych <= 0x00) goto yy1651; + if (yych <= '[') goto yy1650; + goto yy1648; } } @@ -11026,28 +13925,28 @@ int _scan_spacechars(const unsigned char *p) }; yych = *p; if (yych <= '\n') { - if (yych <= 0x08) goto yy1174; - if (yych <= '\t') goto yy1171; - goto yy1172; + if (yych <= 0x08) goto yy1659; + if (yych <= '\t') goto yy1656; + goto yy1657; } else { - if (yych <= '\r') goto yy1171; - if (yych == ' ') goto yy1171; - goto yy1174; + if (yych <= '\r') goto yy1656; + if (yych == ' ') goto yy1656; + goto yy1659; } -yy1170: +yy1655: { return (p - start); } -yy1171: +yy1656: yych = *++p; - goto yy1173; -yy1172: + goto yy1658; +yy1657: ++p; yych = *p; -yy1173: +yy1658: if (yybm[0+yych] & 128) { - goto yy1172; + goto yy1657; } - goto yy1170; -yy1174: + goto yy1655; +yy1659: ++p; { return 0; } } @@ -11097,68 +13996,68 @@ int _scan_atx_header_start(const unsigned char *p) 0, 0, 0, 0, 0, 0, 0, 0, }; yych = *p; - if (yych == '\n') goto yy1178; - if (yych == '#') goto yy1179; - goto yy1180; -yy1178: + if (yych == '\n') goto yy1663; + if (yych == '#') goto yy1664; + goto yy1665; +yy1663: { return 0; } -yy1179: +yy1664: yych = *(marker = ++p); if (yybm[0+yych] & 128) { - goto yy1183; + goto yy1668; } - if (yych == '\n') goto yy1181; - if (yych == '#') goto yy1185; - goto yy1178; -yy1180: + if (yych == '\n') goto yy1666; + if (yych == '#') goto yy1670; + goto yy1663; +yy1665: yych = *++p; - goto yy1178; -yy1181: + goto yy1663; +yy1666: ++p; -yy1182: +yy1667: { return (p - start); } -yy1183: +yy1668: ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1183; + goto yy1668; } - goto yy1182; -yy1185: + goto yy1667; +yy1670: yych = *++p; if (yybm[0+yych] & 128) { - goto yy1183; + goto yy1668; } - if (yych == '\n') goto yy1181; - if (yych == '#') goto yy1187; -yy1186: + if (yych == '\n') goto yy1666; + if (yych == '#') goto yy1672; +yy1671: p = marker; - goto yy1178; -yy1187: + goto yy1663; +yy1672: yych = *++p; if (yybm[0+yych] & 128) { - goto yy1183; + goto yy1668; } - if (yych == '\n') goto yy1181; - if (yych != '#') goto yy1186; + if (yych == '\n') goto yy1666; + if (yych != '#') goto yy1671; yych = *++p; if (yybm[0+yych] & 128) { - goto yy1183; + goto yy1668; } - if (yych == '\n') goto yy1181; - if (yych != '#') goto yy1186; + if (yych == '\n') goto yy1666; + if (yych != '#') goto yy1671; yych = *++p; if (yybm[0+yych] & 128) { - goto yy1183; + goto yy1668; } - if (yych == '\n') goto yy1181; - if (yych != '#') goto yy1186; + if (yych == '\n') goto yy1666; + if (yych != '#') goto yy1671; ++p; if (yybm[0+(yych = *p)] & 128) { - goto yy1183; + goto yy1668; } - if (yych == '\n') goto yy1181; - goto yy1186; + if (yych == '\n') goto yy1666; + goto yy1671; } } @@ -11207,73 +14106,73 @@ int _scan_setext_header_line(const unsigned char *p) }; yych = *p; if (yych <= ',') { - if (yych != '\n') goto yy1196; + if (yych != '\n') goto yy1681; } else { - if (yych <= '-') goto yy1195; - if (yych == '=') goto yy1194; - goto yy1196; + if (yych <= '-') goto yy1680; + if (yych == '=') goto yy1679; + goto yy1681; } -yy1193: +yy1678: { return 0; } -yy1194: +yy1679: yych = *(marker = ++p); if (yybm[0+yych] & 128) { - goto yy1208; + goto yy1693; } - if (yych == '\n') goto yy1206; - if (yych == ' ') goto yy1204; - goto yy1193; -yy1195: + if (yych == '\n') goto yy1691; + if (yych == ' ') goto yy1689; + goto yy1678; +yy1680: yych = *(marker = ++p); if (yybm[0+yych] & 32) { - goto yy1197; + goto yy1682; } - if (yych == '\n') goto yy1200; - if (yych == '-') goto yy1202; - goto yy1193; -yy1196: + if (yych == '\n') goto yy1685; + if (yych == '-') goto yy1687; + goto yy1678; +yy1681: yych = *++p; - goto yy1193; -yy1197: + goto yy1678; +yy1682: ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1197; + goto yy1682; } - if (yych == '\n') goto yy1200; -yy1199: + if (yych == '\n') goto yy1685; +yy1684: p = marker; - goto yy1193; -yy1200: + goto yy1678; +yy1685: ++p; { return 2; } -yy1202: +yy1687: ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1197; + goto yy1682; } - if (yych == '\n') goto yy1200; - if (yych == '-') goto yy1202; - goto yy1199; -yy1204: + if (yych == '\n') goto yy1685; + if (yych == '-') goto yy1687; + goto yy1684; +yy1689: ++p; yych = *p; - if (yych == '\n') goto yy1206; - if (yych == ' ') goto yy1204; - goto yy1199; -yy1206: + if (yych == '\n') goto yy1691; + if (yych == ' ') goto yy1689; + goto yy1684; +yy1691: ++p; { return 1; } -yy1208: +yy1693: ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1208; + goto yy1693; } - if (yych == '\n') goto yy1206; - if (yych == ' ') goto yy1204; - goto yy1199; + if (yych == '\n') goto yy1691; + if (yych == ' ') goto yy1689; + goto yy1684; } } @@ -11324,139 +14223,139 @@ int _scan_hrule(const unsigned char *p) }; yych = *p; if (yych <= '*') { - if (yych == '\n') goto yy1212; - if (yych <= ')') goto yy1216; - goto yy1213; + if (yych == '\n') goto yy1697; + if (yych <= ')') goto yy1701; + goto yy1698; } else { if (yych <= '-') { - if (yych <= ',') goto yy1216; - goto yy1215; + if (yych <= ',') goto yy1701; + goto yy1700; } else { - if (yych == '_') goto yy1214; - goto yy1216; + if (yych == '_') goto yy1699; + goto yy1701; } } -yy1212: +yy1697: { return 0; } -yy1213: +yy1698: yych = *(marker = ++p); - if (yych == ' ') goto yy1238; - if (yych == '*') goto yy1240; - goto yy1212; -yy1214: + if (yych == ' ') goto yy1723; + if (yych == '*') goto yy1725; + goto yy1697; +yy1699: yych = *(marker = ++p); - if (yych == ' ') goto yy1228; - if (yych == '_') goto yy1230; - goto yy1212; -yy1215: + if (yych == ' ') goto yy1713; + if (yych == '_') goto yy1715; + goto yy1697; +yy1700: yych = *(marker = ++p); if (yybm[0+yych] & 8) { - goto yy1217; + goto yy1702; } - if (yych == '-') goto yy1220; - goto yy1212; -yy1216: + if (yych == '-') goto yy1705; + goto yy1697; +yy1701: yych = *++p; - goto yy1212; -yy1217: + goto yy1697; +yy1702: ++p; yych = *p; if (yybm[0+yych] & 8) { - goto yy1217; + goto yy1702; } - if (yych == '-') goto yy1220; -yy1219: + if (yych == '-') goto yy1705; +yy1704: p = marker; - goto yy1212; -yy1220: + goto yy1697; +yy1705: ++p; yych = *p; - if (yych == ' ') goto yy1220; - if (yych != '-') goto yy1219; -yy1222: + if (yych == ' ') goto yy1705; + if (yych != '-') goto yy1704; +yy1707: ++p; yych = *p; if (yybm[0+yych] & 16) { - goto yy1222; + goto yy1707; } - if (yych <= 0x08) goto yy1219; - if (yych <= '\t') goto yy1224; - if (yych <= '\n') goto yy1226; - goto yy1219; -yy1224: + if (yych <= 0x08) goto yy1704; + if (yych <= '\t') goto yy1709; + if (yych <= '\n') goto yy1711; + goto yy1704; +yy1709: ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1224; + goto yy1709; } - if (yych != '\n') goto yy1219; -yy1226: + if (yych != '\n') goto yy1704; +yy1711: ++p; { return (p - start); } -yy1228: +yy1713: ++p; yych = *p; - if (yych == ' ') goto yy1228; - if (yych != '_') goto yy1219; -yy1230: + if (yych == ' ') goto yy1713; + if (yych != '_') goto yy1704; +yy1715: ++p; yych = *p; - if (yych == ' ') goto yy1230; - if (yych != '_') goto yy1219; -yy1232: + if (yych == ' ') goto yy1715; + if (yych != '_') goto yy1704; +yy1717: ++p; yych = *p; if (yybm[0+yych] & 64) { - goto yy1232; + goto yy1717; } - if (yych <= 0x08) goto yy1219; - if (yych <= '\t') goto yy1234; - if (yych <= '\n') goto yy1236; - goto yy1219; -yy1234: + if (yych <= 0x08) goto yy1704; + if (yych <= '\t') goto yy1719; + if (yych <= '\n') goto yy1721; + goto yy1704; +yy1719: ++p; yych = *p; if (yych <= '\n') { - if (yych <= 0x08) goto yy1219; - if (yych <= '\t') goto yy1234; + if (yych <= 0x08) goto yy1704; + if (yych <= '\t') goto yy1719; } else { - if (yych == ' ') goto yy1234; - goto yy1219; + if (yych == ' ') goto yy1719; + goto yy1704; } -yy1236: +yy1721: ++p; { return (p - start); } -yy1238: +yy1723: ++p; yych = *p; - if (yych == ' ') goto yy1238; - if (yych != '*') goto yy1219; -yy1240: + if (yych == ' ') goto yy1723; + if (yych != '*') goto yy1704; +yy1725: ++p; yych = *p; - if (yych == ' ') goto yy1240; - if (yych != '*') goto yy1219; -yy1242: + if (yych == ' ') goto yy1725; + if (yych != '*') goto yy1704; +yy1727: ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1242; + goto yy1727; } - if (yych <= 0x08) goto yy1219; - if (yych <= '\t') goto yy1244; - if (yych <= '\n') goto yy1246; - goto yy1219; -yy1244: + if (yych <= 0x08) goto yy1704; + if (yych <= '\t') goto yy1729; + if (yych <= '\n') goto yy1731; + goto yy1704; +yy1729: ++p; yych = *p; if (yych <= '\n') { - if (yych <= 0x08) goto yy1219; - if (yych <= '\t') goto yy1244; + if (yych <= 0x08) goto yy1704; + if (yych <= '\t') goto yy1729; } else { - if (yych == ' ') goto yy1244; - goto yy1219; + if (yych == ' ') goto yy1729; + goto yy1704; } -yy1246: +yy1731: ++p; { return (p - start); } } @@ -11507,80 +14406,80 @@ int _scan_open_code_fence(const unsigned char *p) }; yych = *p; if (yych <= '_') { - if (yych != '\n') goto yy1253; + if (yych != '\n') goto yy1738; } else { - if (yych <= '`') goto yy1251; - if (yych == '~') goto yy1252; - goto yy1253; + if (yych <= '`') goto yy1736; + if (yych == '~') goto yy1737; + goto yy1738; } -yy1250: +yy1735: { return 0; } -yy1251: +yy1736: yych = *(marker = ++p); - if (yych == '`') goto yy1262; - goto yy1250; -yy1252: + if (yych == '`') goto yy1747; + goto yy1735; +yy1737: yych = *(marker = ++p); - if (yych == '~') goto yy1254; - goto yy1250; -yy1253: + if (yych == '~') goto yy1739; + goto yy1735; +yy1738: yych = *++p; - goto yy1250; -yy1254: + goto yy1735; +yy1739: yych = *++p; if (yybm[0+yych] & 16) { - goto yy1256; + goto yy1741; } -yy1255: +yy1740: p = marker; - goto yy1250; -yy1256: + goto yy1735; +yy1741: marker = p + 1; ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1258; + goto yy1743; } - if (yych <= 0x00) goto yy1255; - if (yych <= '}') goto yy1260; - goto yy1256; -yy1258: + if (yych <= 0x00) goto yy1740; + if (yych <= '}') goto yy1745; + goto yy1741; +yy1743: ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1258; + goto yy1743; } - if (yych <= 0x00) goto yy1255; - if (yych >= '~') goto yy1255; -yy1260: + if (yych <= 0x00) goto yy1740; + if (yych >= '~') goto yy1740; +yy1745: ++p; p = marker; { return (p - start); } -yy1262: +yy1747: yych = *++p; if (yybm[0+yych] & 64) { - goto yy1263; + goto yy1748; } - goto yy1255; -yy1263: + goto yy1740; +yy1748: marker = p + 1; ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1265; + goto yy1750; } - if (yych <= 0x00) goto yy1255; - if (yych <= '_') goto yy1267; - goto yy1263; -yy1265: + if (yych <= 0x00) goto yy1740; + if (yych <= '_') goto yy1752; + goto yy1748; +yy1750: ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1265; + goto yy1750; } - if (yych <= 0x00) goto yy1255; - if (yych >= '`') goto yy1255; -yy1267: + if (yych <= 0x00) goto yy1740; + if (yych >= '`') goto yy1740; +yy1752: ++p; p = marker; { return (p - start); } @@ -11632,84 +14531,84 @@ int _scan_close_code_fence(const unsigned char *p) }; yych = *p; if (yych <= '_') { - if (yych != '\n') goto yy1274; + if (yych != '\n') goto yy1759; } else { - if (yych <= '`') goto yy1272; - if (yych == '~') goto yy1273; - goto yy1274; + if (yych <= '`') goto yy1757; + if (yych == '~') goto yy1758; + goto yy1759; } -yy1271: +yy1756: { return 0; } -yy1272: +yy1757: yych = *(marker = ++p); - if (yych == '`') goto yy1283; - goto yy1271; -yy1273: + if (yych == '`') goto yy1768; + goto yy1756; +yy1758: yych = *(marker = ++p); - if (yych == '~') goto yy1275; - goto yy1271; -yy1274: + if (yych == '~') goto yy1760; + goto yy1756; +yy1759: yych = *++p; - goto yy1271; -yy1275: + goto yy1756; +yy1760: yych = *++p; if (yybm[0+yych] & 32) { - goto yy1277; + goto yy1762; } -yy1276: +yy1761: p = marker; - goto yy1271; -yy1277: + goto yy1756; +yy1762: marker = p + 1; ++p; yych = *p; if (yybm[0+yych] & 64) { - goto yy1279; + goto yy1764; } - if (yych == '\n') goto yy1281; - if (yych == '~') goto yy1277; - goto yy1276; -yy1279: + if (yych == '\n') goto yy1766; + if (yych == '~') goto yy1762; + goto yy1761; +yy1764: ++p; yych = *p; if (yybm[0+yych] & 64) { - goto yy1279; + goto yy1764; } - if (yych != '\n') goto yy1276; -yy1281: + if (yych != '\n') goto yy1761; +yy1766: ++p; p = marker; { return (p - start); } -yy1283: +yy1768: yych = *++p; if (yybm[0+yych] & 128) { - goto yy1284; + goto yy1769; } - goto yy1276; -yy1284: + goto yy1761; +yy1769: marker = p + 1; ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1284; + goto yy1769; } if (yych <= '\n') { - if (yych <= 0x08) goto yy1276; - if (yych >= '\n') goto yy1288; + if (yych <= 0x08) goto yy1761; + if (yych >= '\n') goto yy1773; } else { - if (yych != ' ') goto yy1276; + if (yych != ' ') goto yy1761; } -yy1286: +yy1771: ++p; yych = *p; if (yych <= '\n') { - if (yych <= 0x08) goto yy1276; - if (yych <= '\t') goto yy1286; + if (yych <= 0x08) goto yy1761; + if (yych <= '\t') goto yy1771; } else { - if (yych == ' ') goto yy1286; - goto yy1276; + if (yych == ' ') goto yy1771; + goto yy1761; } -yy1288: +yy1773: ++p; p = marker; { return (p - start); } @@ -11727,664 +14626,664 @@ int _scan_entity(const unsigned char *p) { unsigned char yych; yych = *p; - if (yych == '\n') goto yy1292; - if (yych == '&') goto yy1293; - goto yy1294; -yy1292: + if (yych == '\n') goto yy1777; + if (yych == '&') goto yy1778; + goto yy1779; +yy1777: { return 0; } -yy1293: +yy1778: yych = *(marker = ++p); if (yych <= '@') { - if (yych == '#') goto yy1295; - goto yy1292; + if (yych == '#') goto yy1780; + goto yy1777; } else { - if (yych <= 'Z') goto yy1297; - if (yych <= '`') goto yy1292; - if (yych <= 'z') goto yy1297; - goto yy1292; + if (yych <= 'Z') goto yy1782; + if (yych <= '`') goto yy1777; + if (yych <= 'z') goto yy1782; + goto yy1777; } -yy1294: +yy1779: yych = *++p; - goto yy1292; -yy1295: + goto yy1777; +yy1780: yych = *++p; if (yych <= 'W') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1332; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1817; } else { - if (yych <= 'X') goto yy1331; - if (yych == 'x') goto yy1331; + if (yych <= 'X') goto yy1816; + if (yych == 'x') goto yy1816; } -yy1296: +yy1781: p = marker; - goto yy1292; -yy1297: + goto yy1777; +yy1782: yych = *++p; if (yych <= '@') { - if (yych <= '/') goto yy1296; - if (yych >= ':') goto yy1296; + if (yych <= '/') goto yy1781; + if (yych >= ':') goto yy1781; } else { - if (yych <= 'Z') goto yy1298; - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= 'Z') goto yy1783; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } -yy1298: +yy1783: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1301; - if (yych <= ':') goto yy1296; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1786; + if (yych <= ':') goto yy1781; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; - goto yy1301; + if (yych <= '@') goto yy1781; + goto yy1786; } else { - if (yych <= '`') goto yy1296; - if (yych <= 'z') goto yy1301; - goto yy1296; + if (yych <= '`') goto yy1781; + if (yych <= 'z') goto yy1786; + goto yy1781; } } -yy1299: +yy1784: ++p; { return (p - start); } -yy1301: +yy1786: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1302; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1787; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1302: +yy1787: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1303; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1788; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1303: +yy1788: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1304; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1789; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1304: +yy1789: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1305; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1790; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1305: +yy1790: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1306; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1791; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1306: +yy1791: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1307; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1792; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1307: +yy1792: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1308; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1793; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1308: +yy1793: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1309; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1794; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1309: +yy1794: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1310; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1795; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1310: +yy1795: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1311; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1796; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1311: +yy1796: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1312; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1797; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1312: +yy1797: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1313; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1798; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1313: +yy1798: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1314; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1799; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1314: +yy1799: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1315; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1800; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1315: +yy1800: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1316; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1801; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1316: +yy1801: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1317; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1802; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1317: +yy1802: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1318; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1803; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1318: +yy1803: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1319; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1804; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1319: +yy1804: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1320; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1805; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1320: +yy1805: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1321; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1806; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1321: +yy1806: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1322; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1807; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1322: +yy1807: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1323; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1808; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1323: +yy1808: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1324; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1809; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1324: +yy1809: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1325; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1810; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1325: +yy1810: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1326; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1811; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1326: +yy1811: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1327; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1812; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1327: +yy1812: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1328; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1813; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1328: +yy1813: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1329; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1814; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1329: +yy1814: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1330; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1815; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= '{') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= '{') goto yy1781; } } -yy1330: +yy1815: yych = *++p; - if (yych == ';') goto yy1299; - goto yy1296; -yy1331: + if (yych == ';') goto yy1784; + goto yy1781; +yy1816: 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: + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1824; + goto yy1781; + } else { + if (yych <= 'F') goto yy1824; + if (yych <= '`') goto yy1781; + if (yych <= 'f') goto yy1824; + goto yy1781; + } +yy1817: + yych = *++p; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1818; + if (yych == ';') goto yy1784; + goto yy1781; +yy1818: + yych = *++p; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1819; + if (yych == ';') goto yy1784; + goto yy1781; +yy1819: + yych = *++p; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1820; + if (yych == ';') goto yy1784; + goto yy1781; +yy1820: + yych = *++p; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1821; + if (yych == ';') goto yy1784; + goto yy1781; +yy1821: + yych = *++p; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1822; + if (yych == ';') goto yy1784; + goto yy1781; +yy1822: + yych = *++p; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1823; + if (yych == ';') goto yy1784; + goto yy1781; +yy1823: + yych = *++p; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1815; + if (yych == ';') goto yy1784; + goto yy1781; +yy1824: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1340; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1825; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= 'g') goto yy1781; } } -yy1340: +yy1825: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1341; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1826; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= 'g') goto yy1781; } } -yy1341: +yy1826: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1342; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1827; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= 'g') goto yy1781; } } -yy1342: +yy1827: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1343; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1828; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= 'g') goto yy1781; } } -yy1343: +yy1828: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1344; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1829; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= 'g') goto yy1781; } } -yy1344: +yy1829: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1345; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1830; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1296; + if (yych <= '@') goto yy1781; } else { - if (yych <= '`') goto yy1296; - if (yych >= 'g') goto yy1296; + if (yych <= '`') goto yy1781; + if (yych >= 'g') goto yy1781; } } -yy1345: +yy1830: ++p; if ((yych = *p) <= ';') { - if (yych <= '/') goto yy1296; - if (yych <= '9') goto yy1330; - if (yych <= ':') goto yy1296; - goto yy1299; + if (yych <= '/') goto yy1781; + if (yych <= '9') goto yy1815; + if (yych <= ':') goto yy1781; + goto yy1784; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1296; - goto yy1330; + if (yych <= '@') goto yy1781; + goto yy1815; } else { - if (yych <= '`') goto yy1296; - if (yych <= 'f') goto yy1330; - goto yy1296; + if (yych <= '`') goto yy1781; + if (yych <= 'f') goto yy1815; + goto yy1781; } } } diff --git a/scanners.h b/scanners.h index f360505..1353f3b 100644 --- a/scanners.h +++ b/scanners.h @@ -6,6 +6,7 @@ extern "C" { #endif int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset); +int _scan_scheme(const unsigned char *p); int _scan_autolink_uri(const unsigned char *p); int _scan_autolink_email(const unsigned char *p); int _scan_html_tag(const unsigned char *p); @@ -20,6 +21,7 @@ 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_scheme(c, n) _scan_at(&_scan_scheme, c, n) #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) diff --git a/scanners.re b/scanners.re index 28a6991..31cdb4f 100644 --- a/scanners.re +++ b/scanners.re @@ -24,7 +24,7 @@ int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset) wordchar = [^\x00-\x20]; - spacechar = [ \t\n]; + spacechar = [ \t\v\f\r\n]; reg_char = [^\\()\x00-\x20]; @@ -69,6 +69,17 @@ int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset) scheme = 'coap'|'doi'|'javascript'|'aaa'|'aaas'|'about'|'acap'|'cap'|'cid'|'crid'|'data'|'dav'|'dict'|'dns'|'file'|'ftp'|'geo'|'go'|'gopher'|'h323'|'http'|'https'|'iax'|'icap'|'im'|'imap'|'info'|'ipp'|'iris'|'iris.beep'|'iris.xpc'|'iris.xpcs'|'iris.lwz'|'ldap'|'mailto'|'mid'|'msrp'|'msrps'|'mtqp'|'mupdate'|'news'|'nfs'|'ni'|'nih'|'nntp'|'opaquelocktoken'|'pop'|'pres'|'rtsp'|'service'|'session'|'shttp'|'sieve'|'sip'|'sips'|'sms'|'snmp'|'soap.beep'|'soap.beeps'|'tag'|'tel'|'telnet'|'tftp'|'thismessage'|'tn3270'|'tip'|'tv'|'urn'|'vemmi'|'ws'|'wss'|'xcon'|'xcon-userid'|'xmlrpc.beep'|'xmlrpc.beeps'|'xmpp'|'z39.50r'|'z39.50s'|'adiumxtra'|'afp'|'afs'|'aim'|'apt'|'attachment'|'aw'|'beshare'|'bitcoin'|'bolo'|'callto'|'chrome'|'chrome-extension'|'com-eventbrite-attendee'|'content'|'cvs'|'dlna-playsingle'|'dlna-playcontainer'|'dtn'|'dvb'|'ed2k'|'facetime'|'feed'|'finger'|'fish'|'gg'|'git'|'gizmoproject'|'gtalk'|'hcp'|'icon'|'ipn'|'irc'|'irc6'|'ircs'|'itms'|'jar'|'jms'|'keyparc'|'lastfm'|'ldaps'|'magnet'|'maps'|'market'|'message'|'mms'|'ms-help'|'msnim'|'mumble'|'mvn'|'notes'|'oid'|'palm'|'paparazzi'|'platform'|'proxy'|'psyc'|'query'|'res'|'resource'|'rmi'|'rsync'|'rtmp'|'secondlife'|'sftp'|'sgn'|'skype'|'smb'|'soldat'|'spotify'|'ssh'|'steam'|'svn'|'teamspeak'|'things'|'udp'|'unreal'|'ut2004'|'ventrilo'|'view-source'|'webcal'|'wtai'|'wyciwyg'|'xfire'|'xri'|'ymsgr'; */ +// Try to match a scheme including colon. +int _scan_scheme(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + scheme [:] { return (p - start); } + .? { return 0; } +*/ +} + // Try to match URI autolink after first <, returning number of chars matched. int _scan_autolink_uri(const unsigned char *p) { @@ -155,7 +166,7 @@ int _scan_spacechars(const unsigned char *p) { const unsigned char *start = p; \ /*!re2c - [ \t\n]* { return (p - start); } + [ \t\v\f\r\n]* { return (p - start); } . { return 0; } */ } From 49686ff701b8de6deddca405a50fb04c7db1f623 Mon Sep 17 00:00:00 2001 From: James Adam Date: Mon, 6 Apr 2015 19:49:43 -0400 Subject: [PATCH 10/26] incorporate cmark 0.18.3 --- commonmark.c | 16 +++++++++------- inlines.c | 4 ++-- 2 files changed, 11 insertions(+), 9 deletions(-) diff --git a/commonmark.c b/commonmark.c index 23faa7c..bef92f6 100644 --- a/commonmark.c +++ b/commonmark.c @@ -284,7 +284,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, bool entering = (ev_type == CMARK_EVENT_ENTER); const char *info; const char *title; - char listmarker[64]; + cmark_strbuf listmarker = GH_BUF_INIT; char *emph_delim; int marker_width; @@ -347,11 +347,12 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, // we ensure a width of at least 4 so // we get nice transition from single digits // to double - snprintf(listmarker, 63, "%d%s%s", list_number, - list_delim == CMARK_PAREN_DELIM ? - ")" : ".", - list_number < 10 ? " " : " "); - marker_width = strlen(listmarker); + cmark_strbuf_printf(&listmarker, + "%d%s%s", list_number, + list_delim == CMARK_PAREN_DELIM ? + ")" : ".", + list_number < 10 ? " " : " "); + marker_width = listmarker.size; } if (entering) { if (cmark_node_get_list_type(node->parent) == @@ -359,7 +360,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, lit(state, "* ", false); cmark_strbuf_puts(state->prefix, " "); } else { - lit(state, listmarker, false); + lit(state, (char *)listmarker.ptr, false); for (i=marker_width; i--;) { cmark_strbuf_putc(state->prefix, ' '); } @@ -370,6 +371,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, marker_width); cr(state); } + cmark_strbuf_free(&listmarker); break; case CMARK_NODE_HEADER: diff --git a/inlines.c b/inlines.c index e2641a7..3e298de 100644 --- a/inlines.c +++ b/inlines.c @@ -636,7 +636,7 @@ unsigned char *cmark_clean_url(cmark_chunk *url) } cmark_strbuf_unescape(&buf); - return cmark_strbuf_detach(&buf); + return buf.size == 0 ? NULL : cmark_strbuf_detach(&buf); } unsigned char *cmark_clean_title(cmark_chunk *title) @@ -660,7 +660,7 @@ unsigned char *cmark_clean_title(cmark_chunk *title) } cmark_strbuf_unescape(&buf); - return cmark_strbuf_detach(&buf); + return buf.size == 0 ? NULL : cmark_strbuf_detach(&buf); } // Parse an autolink or HTML tag. From 0d388ea967968484044f7b529ae5e34e4b33c1f1 Mon Sep 17 00:00:00 2001 From: James Adam Date: Thu, 30 Apr 2015 05:48:27 -0400 Subject: [PATCH 11/26] updated to cmark 0.19.0 --- commonmark.c | 92 +++++++++++++++++++++++++++------------------------- inlines.c | 6 ++-- man.c | 3 ++ utf8.c | 5 ++- 4 files changed, 57 insertions(+), 49 deletions(-) diff --git a/commonmark.c b/commonmark.c index bef92f6..805f139 100644 --- a/commonmark.c +++ b/commonmark.c @@ -49,35 +49,35 @@ typedef enum { static inline bool needs_escaping(escaping escape, - int32_t c, - unsigned char next_c, - struct render_state *state) + int32_t c, + unsigned char next_c, + struct render_state *state) { if (escape == NORMAL) { return (c == '*' || c == '_' || c == '[' || c == ']' || - c == '<' || c == '>' || c == '\\' || c == '`' || - (c == '&' && isalpha(next_c)) || - (c == '!' && next_c == '[') || - (state->begin_line && - (c == '-' || c == '+' || c == '#' || c == '=')) || - (c == '#' && (isspace(next_c) || next_c == '\0')) || - ((c == '.' || c == ')') && - isdigit(state->buffer->ptr[state->buffer->size - 1]))); + c == '<' || c == '>' || c == '\\' || c == '`' || + (c == '&' && isalpha(next_c)) || + (c == '!' && next_c == '[') || + (state->begin_line && + (c == '-' || c == '+' || c == '#' || c == '=')) || + (c == '#' && (isspace(next_c) || next_c == '\0')) || + ((c == '.' || c == ')') && + isdigit(state->buffer->ptr[state->buffer->size - 1]))); } else if (escape == TITLE) { return (c == '`' || c == '<' || c == '>' || c == '"' || - c == '\\'); + c == '\\'); } else if (escape == URL) { return (c == '`' || c == '<' || c == '>' || isspace(c) || - c == '\\' || c == ')' || c == '('); + c == '\\' || c == ')' || c == '('); } else { return false; } } static inline void out(struct render_state *state, - cmark_chunk str, - bool wrap, - escaping escape) + cmark_chunk str, + bool wrap, + escaping escape) { unsigned char* source = str.data; int length = str.len; @@ -100,7 +100,7 @@ static inline void out(struct render_state *state, cmark_strbuf_putc(state->buffer, '\n'); if (state->need_cr > 1) { cmark_strbuf_put(state->buffer, state->prefix->ptr, - state->prefix->size); + state->prefix->size); } } state->column = 0; @@ -111,12 +111,15 @@ static inline void out(struct render_state *state, while (i < length) { if (state->begin_line) { cmark_strbuf_put(state->buffer, state->prefix->ptr, - state->prefix->size); + state->prefix->size); // note: this assumes prefix is ascii: state->column = state->prefix->size; } len = utf8proc_iterate(source + i, length - i, &c); + if (len == -1) { // error condition + return; // return without rendering rest of string + } nextc = source[i + len]; if (c == 32 && wrap) { if (!state->begin_line) { @@ -124,7 +127,7 @@ static inline void out(struct render_state *state, state->column += 1; state->begin_line = false; state->last_breakable = state->buffer->size - - 1; + 1; // skip following spaces while (source[i + 1] == ' ') { i++; @@ -167,7 +170,7 @@ static inline void out(struct render_state *state, // add newline, prefix, and remainder cmark_strbuf_putc(state->buffer, '\n'); cmark_strbuf_put(state->buffer, state->prefix->ptr, - state->prefix->size); + state->prefix->size); cmark_strbuf_put(state->buffer, remainder.data, remainder.len); state->column = state->prefix->size + remainder.len; cmark_chunk_free(&remainder); @@ -254,8 +257,8 @@ is_autolink(cmark_node *node) } cmark_consolidate_text_nodes(node); return (strncmp(url, - (char*)node->as.literal.data, - node->as.literal.len) == 0); + (char*)node->as.literal.data, + node->as.literal.len) == 0); } // if node is a block node, returns node. @@ -265,7 +268,7 @@ get_containing_block(cmark_node *node) { while (node && (node->type < CMARK_NODE_FIRST_BLOCK || - node->type > CMARK_NODE_LAST_BLOCK)) { + node->type > CMARK_NODE_LAST_BLOCK)) { node = node->parent; } return node; @@ -293,14 +296,14 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, // a following list. if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && entering)) { - tmp = get_containing_block(node); - state->in_tight_list_item = - (tmp->type == CMARK_NODE_ITEM && - cmark_node_get_list_tight(tmp->parent)) || - (tmp && - tmp->parent && - tmp->parent->type == CMARK_NODE_ITEM && - cmark_node_get_list_tight(tmp->parent->parent)); + tmp = get_containing_block(node); + state->in_tight_list_item = + (tmp->type == CMARK_NODE_ITEM && + cmark_node_get_list_tight(tmp->parent)) || + (tmp && + tmp->parent && + tmp->parent->type == CMARK_NODE_ITEM && + cmark_node_get_list_tight(tmp->parent->parent)); } switch (node->type) { @@ -316,7 +319,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, cmark_strbuf_puts(state->prefix, "> "); } else { cmark_strbuf_truncate(state->prefix, - state->prefix->size - 2); + state->prefix->size - 2); blankline(state); } break; @@ -348,10 +351,10 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, // we get nice transition from single digits // to double cmark_strbuf_printf(&listmarker, - "%d%s%s", list_number, - list_delim == CMARK_PAREN_DELIM ? - ")" : ".", - list_number < 10 ? " " : " "); + "%d%s%s", list_number, + list_delim == CMARK_PAREN_DELIM ? + ")" : ".", + list_number < 10 ? " " : " "); marker_width = listmarker.size; } if (entering) { @@ -361,14 +364,14 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, cmark_strbuf_puts(state->prefix, " "); } else { lit(state, (char *)listmarker.ptr, false); - for (i=marker_width; i--;) { + for (i = marker_width; i--;) { cmark_strbuf_putc(state->prefix, ' '); } } } else { cmark_strbuf_truncate(state->prefix, - state->prefix->size - - marker_width); + state->prefix->size - + marker_width); cr(state); } cmark_strbuf_free(&listmarker); @@ -405,7 +408,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, cmark_strbuf_puts(state->prefix, " "); out(state, node->as.code.literal, false, LITERAL); cmark_strbuf_truncate(state->prefix, - state->prefix->size - 4); + state->prefix->size - 4); } else { numticks = longest_backtick_sequence(code) + 1; if (numticks < 3) { @@ -514,7 +517,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, if (entering) { lit(state, "<", false); if (strncmp(cmark_node_get_url(node), - "mailto:", 7) == 0) { + "mailto:", 7) == 0) { lit(state, (char *)cmark_node_get_url(node) + 7, false); @@ -579,9 +582,10 @@ char *cmark_render_commonmark(cmark_node *root, int options, int width) if (CMARK_OPT_HARDBREAKS & options) { width = 0; } - struct render_state state = - { options, &commonmark, &prefix, 0, width, - 0, 0, true, false, false}; + struct render_state state = { + options, &commonmark, &prefix, 0, width, + 0, 0, true, false, false + }; cmark_node *cur; cmark_event_type ev_type; cmark_iter *iter = cmark_iter_new(root); diff --git a/inlines.c b/inlines.c index 3e298de..afe564c 100644 --- a/inlines.c +++ b/inlines.c @@ -301,8 +301,10 @@ scan_delims(subject* subj, unsigned char c, bool * can_open, bool * can_close) !utf8proc_is_space(after_char) && !utf8proc_is_punctuation(after_char)); if (c == '_') { - *can_open = left_flanking && !right_flanking; - *can_close = right_flanking && !left_flanking; + *can_open = left_flanking && + (!right_flanking || utf8proc_is_punctuation(before_char)); + *can_close = right_flanking && + (!left_flanking || utf8proc_is_punctuation(after_char)); } else if (c == '\'' || c == '"') { *can_open = left_flanking && !right_flanking; *can_close = right_flanking; diff --git a/man.c b/man.c index 27cd2e4..8ff4a9f 100644 --- a/man.c +++ b/man.c @@ -20,6 +20,9 @@ static void escape_man(cmark_strbuf *dest, const unsigned char *source, int leng while (i < length) { len = utf8proc_iterate(source + i, length - i, &c); + if (len == -1) { // error condition + return; // return without rendering anything + } switch(c) { case 46: if (beginLine) { diff --git a/utf8.c b/utf8.c index d77c5d1..b83c2a5 100644 --- a/utf8.c +++ b/utf8.c @@ -172,8 +172,7 @@ int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst) 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; + if (uc < 0x800 || (uc >= 0xD800 && uc < 0xE000)) uc = -1; break; case 4: uc = ((str[0] & 0x07) << 18) + ((str[1] & 0x3F) << 12) @@ -182,7 +181,7 @@ int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst) break; } - if (uc < 0 || ((uc & 0xFFFF) >= 0xFFFE)) + if (uc < 0) return -1; *dst = uc; From 9acde660827d0ae4953ed89ea4bd677f8cf55119 Mon Sep 17 00:00:00 2001 From: James Adam Date: Mon, 8 Jun 2015 18:24:25 -0400 Subject: [PATCH 12/26] Updated to cmark 0.20.0 --- blocks.c | 318 ++++++++++++++++++--------------- buffer.c | 217 +++++++++++------------ buffer.h | 94 ++++------ chunk.h | 33 ++-- cmark.c | 2 +- cmark.h | 2 +- commonmark.c | 52 +++--- commonmark.go | 2 +- config.h | 2 + houdini.h | 19 +- houdini_href_e.c | 4 +- houdini_html_e.c | 6 +- houdini_html_u.c | 53 +++--- html.c | 35 ++-- inlines.c | 147 ++++++++-------- inlines.h | 6 +- iterator.c | 8 +- node.c | 27 +-- node.h | 4 +- parser.h | 6 +- references.c | 4 +- references.h | 4 +- scanners.c | 444 +++++++++++++++++++++++++++++------------------ scanners.h | 30 ++-- scanners.re | 82 ++++----- utf8.c | 20 +-- utf8.h | 6 +- xml.c | 15 +- 28 files changed, 899 insertions(+), 743 deletions(-) diff --git a/blocks.c b/blocks.c index a15f819..a3ac712 100644 --- a/blocks.c +++ b/blocks.c @@ -18,13 +18,19 @@ #define CODE_INDENT 4 #define peek_at(i, n) (i)->data[n] +static inline bool +S_is_line_end_char(char c) +{ + return (c == '\n' || c == '\r'); +} + 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); + bufsize_t bytes); static cmark_node* make_block(cmark_node_type tag, int start_line, int start_column) { @@ -63,6 +69,10 @@ cmark_parser *cmark_parser_new(int options) parser->root = document; parser->current = document; parser->line_number = 0; + parser->offset = 0; + parser->first_nonspace = 0; + parser->indent = 0; + parser->blank = false; parser->curline = line; parser->last_line_length = 0; parser->linebuf = buf; @@ -85,10 +95,11 @@ 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) +static bool is_blank(cmark_strbuf *s, bufsize_t offset) { while (offset < s->size) { switch (s->ptr[offset]) { + case '\r': case '\n': return true; case ' ': @@ -117,7 +128,7 @@ static inline bool accepts_lines(cmark_node_type block_type) block_type == NODE_CODE_BLOCK); } -static void add_line(cmark_node* node, cmark_chunk *ch, int offset) +static void add_line(cmark_node* node, cmark_chunk *ch, bufsize_t offset) { assert(node->open); cmark_strbuf_put(&node->string_content, ch->data + offset, ch->len - offset); @@ -125,12 +136,13 @@ static void add_line(cmark_node* node, cmark_chunk *ch, int offset) static void remove_trailing_blank_lines(cmark_strbuf *ln) { - int i; + bufsize_t i; + unsigned char c; for (i = ln->size - 1; i >= 0; --i) { - unsigned char c = ln->ptr[i]; + c = ln->ptr[i]; - if (c != ' ' && c != '\t' && c != '\r' && c != '\n') + if (c != ' ' && c != '\t' && !S_is_line_end_char(c)) break; } @@ -139,9 +151,16 @@ static void remove_trailing_blank_lines(cmark_strbuf *ln) return; } - i = cmark_strbuf_strchr(ln, '\n', i); - if (i >= 0) + + for(; i < ln->size; ++i) { + c = ln->ptr[i]; + + if (!S_is_line_end_char(c)) + continue; + cmark_strbuf_truncate(ln, i); + break; + } } // Check to see if a node ends with a blank line, descending @@ -185,8 +204,7 @@ static int break_out_of_lists(cmark_parser *parser, cmark_node ** bptr) static cmark_node* finalize(cmark_parser *parser, cmark_node* b) { - int firstlinelen; - int pos; + bufsize_t pos; cmark_node* item; cmark_node* subitem; cmark_node* parent; @@ -204,9 +222,11 @@ finalize(cmark_parser *parser, cmark_node* b) (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); + b->end_column = parser->curline->size; + if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\n') + b->end_column -= 1; + if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\r') + b->end_column -= 1; } else { b->end_line = parser->line_number - 1; b->end_column = parser->last_line_length; @@ -232,19 +252,27 @@ finalize(cmark_parser *parser, cmark_node* b) } else { // first line of contents becomes info - firstlinelen = cmark_strbuf_strchr(&b->string_content, '\n', 0); + for (pos = 0; pos < b->string_content.size; ++pos) { + if (S_is_line_end_char(b->string_content.ptr[pos])) + break; + } + assert(pos < b->string_content.size); cmark_strbuf tmp = GH_BUF_INIT; houdini_unescape_html_f( &tmp, b->string_content.ptr, - firstlinelen + pos ); 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); + if (b->string_content.ptr[pos] == '\r') + pos += 1; + if (b->string_content.ptr[pos] == '\n') + pos += 1; + cmark_strbuf_drop(&b->string_content, pos); } b->as.code.literal = cmark_chunk_buf_detach(&b->string_content); break; @@ -339,10 +367,10 @@ static void process_inlines(cmark_node* root, cmark_reference_map *refmap, int o // 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) +static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos, cmark_list **dataptr) { unsigned char c; - int startpos; + bufsize_t startpos; cmark_list *data; startpos = pos; @@ -467,27 +495,39 @@ S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len, const unsigned char *end = buffer + len; while (buffer < end) { - const unsigned char *eol - = (const unsigned char *)memchr(buffer, '\n', - end - buffer); + const unsigned char *eol; size_t line_len; + bufsize_t bufsize; + + for (eol = buffer; eol < end; ++eol) { + if (S_is_line_end_char(*eol)) + break; + } + if (eol >= end) + eol = NULL; if (eol) { - line_len = eol + 1 - buffer; + if (eol < end && *eol == '\r') + eol++; + if (eol < end && *eol == '\n') + eol++; + line_len = eol - buffer; } else if (eof) { line_len = end - buffer; } else { - cmark_strbuf_put(parser->linebuf, buffer, end - buffer); + bufsize = cmark_strbuf_check_bufsize(end - buffer); + cmark_strbuf_put(parser->linebuf, buffer, bufsize); break; } + bufsize = cmark_strbuf_check_bufsize(line_len); if (parser->linebuf->size > 0) { - cmark_strbuf_put(parser->linebuf, buffer, line_len); + cmark_strbuf_put(parser->linebuf, buffer, bufsize); S_process_line(parser, parser->linebuf->ptr, parser->linebuf->size); cmark_strbuf_clear(parser->linebuf); } else { - S_process_line(parser, buffer, line_len); + S_process_line(parser, buffer, bufsize); } buffer += line_len; @@ -496,7 +536,7 @@ S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len, static void chop_trailing_hashtags(cmark_chunk *ch) { - int n, orig_n; + bufsize_t n, orig_n; cmark_chunk_rtrim(ch); orig_n = n = ch->len - 1; @@ -513,29 +553,42 @@ static void chop_trailing_hashtags(cmark_chunk *ch) } static void -S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) +S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input) +{ + parser->first_nonspace = parser->offset; + while (peek_at(input, parser->first_nonspace) == ' ') { + parser->first_nonspace++; + } + + parser->indent = parser->first_nonspace - parser->offset; + parser->blank = S_is_line_end_char(peek_at(input, parser->first_nonspace)); +} + +static void +S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t bytes) { cmark_node* last_matched_container; - int offset = 0; - int matched = 0; + bufsize_t 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; + bool indented; cmark_chunk input; bool maybe_lazy; utf8proc_detab(parser->curline, buffer, bytes); + parser->offset = 0; + parser->blank = false; // Add a newline to the end if not present: // TODO this breaks abstraction: - if (parser->curline->ptr[parser->curline->size - 1] != '\n') { + if (parser->curline->size > 0 && + !S_is_line_end_char(parser->curline->ptr[parser->curline->size - 1])) { cmark_strbuf_putc(parser->curline, '\n'); } + input.data = parser->curline->ptr; input.len = parser->curline->size; @@ -550,32 +603,26 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) 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'; + S_find_first_nonspace(parser, &input); if (container->type == NODE_BLOCK_QUOTE) { - matched = indent <= 3 && peek_at(&input, first_nonspace) == '>'; + matched = parser->indent <= 3 && peek_at(&input, parser->first_nonspace) == '>'; if (matched) { - offset = first_nonspace + 1; - if (peek_at(&input, offset) == ' ') - offset++; + parser->offset = parser->first_nonspace + 1; + if (peek_at(&input, parser->offset) == ' ') + parser->offset++; } else { all_matched = false; } } else if (container->type == NODE_ITEM) { - if (indent >= container->as.list.marker_offset + + if (parser->indent >= container->as.list.marker_offset + container->as.list.padding) { - offset += container->as.list.marker_offset + + parser->offset += container->as.list.marker_offset + container->as.list.padding; - } else if (blank) { - offset = first_nonspace; + } else if (parser->blank) { + parser->offset = parser->first_nonspace; } else { all_matched = false; } @@ -583,34 +630,34 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) } 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; + if (parser->indent >= CODE_INDENT) { + parser->offset += CODE_INDENT; + } else if (parser->blank) { + parser->offset = parser->first_nonspace; } else { all_matched = false; } } else { // fenced matched = 0; - if (indent <= 3 && - (peek_at(&input, first_nonspace) == + if (parser->indent <= 3 && + (peek_at(&input, parser->first_nonspace) == container->as.code.fence_char)) { matched = scan_close_code_fence(&input, - first_nonspace); + parser->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->offset += matched; parser->current = finalize(parser, container); goto finished; } else { - // skip opt. spaces of fence offset + // skip opt. spaces of fence parser->offset i = container->as.code.fence_offset; while (i > 0 && - peek_at(&input, offset) == ' ') { - offset++; + peek_at(&input, parser->offset) == ' ') { + parser->offset++; i--; } } @@ -622,13 +669,13 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) } else if (container->type == NODE_HTML) { - if (blank) { + if (parser->blank) { all_matched = false; } } else if (container->type == NODE_PARAGRAPH) { - if (blank) { + if (parser->blank) { all_matched = false; } @@ -643,7 +690,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) last_matched_container = container; // check to see if we've hit 2nd blank line, break out of list: - if (blank && container->last_line_blank) { + if (parser->blank && container->last_line_blank) { break_out_of_lists(parser, &container); } @@ -652,40 +699,23 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) 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; - } + S_find_first_nonspace(parser, &input); + indented = parser->indent >= CODE_INDENT; - } else if (peek_at(&input, first_nonspace) == '>') { + if (!indented && peek_at(&input, parser->first_nonspace) == '>') { - offset = first_nonspace + 1; + parser->offset = parser->first_nonspace + 1; // optional following character - if (peek_at(&input, offset) == ' ') - offset++; - container = add_child(parser, container, NODE_BLOCK_QUOTE, offset + 1); + if (peek_at(&input, parser->offset) == ' ') + parser->offset++; + container = add_child(parser, container, NODE_BLOCK_QUOTE, parser->offset + 1); - } else if ((matched = scan_atx_header_start(&input, first_nonspace))) { + } else if (!indented && (matched = scan_atx_header_start(&input, parser->first_nonspace))) { - offset = first_nonspace + matched; - container = add_child(parser, container, NODE_HEADER, offset + 1); + parser->offset = parser->first_nonspace + matched; + container = add_child(parser, container, NODE_HEADER, parser->offset + 1); - int hashpos = cmark_chunk_strchr(&input, '#', first_nonspace); + bufsize_t hashpos = cmark_chunk_strchr(&input, '#', parser->first_nonspace); int level = 0; while (peek_at(&input, hashpos) == '#') { @@ -695,78 +725,95 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) container->as.header.level = level; container->as.header.setext = false; - } else if ((matched = scan_open_code_fence(&input, first_nonspace))) { + } else if (!indented && (matched = scan_open_code_fence(&input, parser->first_nonspace))) { - container = add_child(parser, container, NODE_CODE_BLOCK, first_nonspace + 1); + container = add_child(parser, container, NODE_CODE_BLOCK, parser->first_nonspace + 1); container->as.code.fenced = true; - container->as.code.fence_char = peek_at(&input, first_nonspace); + container->as.code.fence_char = peek_at(&input, parser->first_nonspace); container->as.code.fence_length = matched; - container->as.code.fence_offset = first_nonspace - offset; + container->as.code.fence_offset = parser->first_nonspace - parser->offset; container->as.code.info = cmark_chunk_literal(""); - offset = first_nonspace + matched; + parser->offset = parser->first_nonspace + matched; - } else if ((matched = scan_html_block_tag(&input, first_nonspace))) { + } else if (!indented && (matched = scan_html_block_tag(&input, parser->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 + container = add_child(parser, container, NODE_HTML, parser->first_nonspace + 1); + // note, we don't adjust parser->offset because the tag is part of the text - } else if (container->type == NODE_PARAGRAPH && - (lev = scan_setext_header_line(&input, first_nonspace)) && + } else if (!indented && + container->type == NODE_PARAGRAPH && + (lev = scan_setext_header_line(&input, parser->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) { + (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; + parser->offset = input.len - 1; - } else if (!(container->type == NODE_PARAGRAPH && !all_matched) && - (matched = scan_hrule(&input, first_nonspace))) { + } else if (!indented && + !(container->type == NODE_PARAGRAPH && + !all_matched) && + (matched = scan_hrule(&input, parser->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 = add_child(parser, container, NODE_HRULE, parser->first_nonspace + 1); container = finalize(parser, container); - offset = input.len - 1; + parser->offset = input.len - 1; - } else if ((matched = parse_list_marker(&input, first_nonspace, &data))) { + } else if ((matched = parse_list_marker(&input, parser->first_nonspace, &data)) && + (!indented || container->type == NODE_LIST)) { + // Note that we can have new list items starting with >= 4 + // spaces indent, as long as the list container is still open. // compute padding: - offset = first_nonspace + matched; + parser->offset = parser->first_nonspace + matched; i = 0; - while (i <= 5 && peek_at(&input, offset + i) == ' ') { + while (i <= 5 && peek_at(&input, parser->offset + i) == ' ') { i++; } // i = number of spaces after marker, up to 5 - if (i >= 5 || i < 1 || peek_at(&input, offset) == '\n') { + if (i >= 5 || i < 1 || + S_is_line_end_char(peek_at(&input, parser->offset))) { data->padding = matched + 1; if (i > 0) { - offset += 1; + parser->offset += 1; } } else { data->padding = matched + i; - offset += i; + parser->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; + data->marker_offset = parser->indent; if (container->type != NODE_LIST || !lists_match(&container->as.list, data)) { container = add_child(parser, container, NODE_LIST, - first_nonspace + 1); + parser->first_nonspace + 1); memcpy(&container->as.list, data, sizeof(*data)); } // add the list item container = add_child(parser, container, NODE_ITEM, - first_nonspace + 1); + parser->first_nonspace + 1); /* TODO: static */ memcpy(&container->as.list, data, sizeof(*data)); free(data); + + } else if (indented && !maybe_lazy && !parser->blank) { + parser->offset += CODE_INDENT; + container = add_child(parser, container, NODE_CODE_BLOCK, parser->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 { break; } @@ -778,17 +825,12 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) maybe_lazy = false; } - // what remains at offset is a text line. add the text to the + // what remains at parser->offset is a text line. add the text to the // appropriate container. - first_nonspace = offset; - while (peek_at(&input, first_nonspace) == ' ') - first_nonspace++; + S_find_first_nonspace(parser, &input); - indent = first_nonspace - offset; - blank = peek_at(&input, first_nonspace) == '\n'; - - if (blank && container->last_child) { + if (parser->blank && container->last_child) { container->last_child->last_line_blank = true; } @@ -796,7 +838,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) // 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->last_line_blank = (parser->blank && container->type != NODE_BLOCK_QUOTE && container->type != NODE_HEADER && !(container->type == NODE_CODE_BLOCK && @@ -813,11 +855,11 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) if (parser->current != last_matched_container && container == last_matched_container && - !blank && + !parser->blank && parser->current->type == NODE_PARAGRAPH && cmark_strbuf_len(&parser->current->string_content) > 0) { - add_line(parser->current, &input, offset); + add_line(parser->current, &input, parser->offset); } else { // not a lazy continuation @@ -830,9 +872,9 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) if (container->type == NODE_CODE_BLOCK || container->type == NODE_HTML) { - add_line(container, &input, offset); + add_line(container, &input, parser->offset); - } else if (blank) { + } else if (parser->blank) { // ??? do nothing @@ -842,22 +884,26 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) container->as.header.setext == false) { chop_trailing_hashtags(&input); } - add_line(container, &input, first_nonspace); + add_line(container, &input, parser->first_nonspace); } else { // create paragraph container for line - container = add_child(parser, container, NODE_PARAGRAPH, first_nonspace + 1); - add_line(container, &input, first_nonspace); + container = add_child(parser, container, NODE_PARAGRAPH, parser->first_nonspace + 1); + add_line(container, &input, parser->first_nonspace); } parser->current = container; } finished: - parser->last_line_length = parser->curline->size - - (parser->curline->ptr[parser->curline->size - 1] == '\n' ? - 1 : 0); - ; + parser->last_line_length = parser->curline->size; + if (parser->last_line_length && + parser->curline->ptr[parser->last_line_length - 1] == '\n') + parser->last_line_length -= 1; + if (parser->last_line_length && + parser->curline->ptr[parser->last_line_length - 1] == '\r') + parser->last_line_length -= 1; + cmark_strbuf_clear(parser->curline); } diff --git a/buffer.c b/buffer.c index 5ec8b49..7d16af8 100644 --- a/buffer.c +++ b/buffer.c @@ -4,6 +4,7 @@ #include #include #include +#include #include "config.h" #include "cmark_ctype.h" @@ -13,83 +14,88 @@ * 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) + if (initial_size > 0) cmark_strbuf_grow(buf, initial_size); } -int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom) +void cmark_strbuf_overflow_err() { + fprintf(stderr, "String buffer overflow"); + abort(); +} + +static inline void +S_strbuf_grow_by(cmark_strbuf *buf, size_t add) { + size_t target_size = (size_t)buf->size + add; + + if (target_size < add /* Integer overflow. */ + || target_size > BUFSIZE_MAX /* Truncation overflow. */ + ) { + cmark_strbuf_overflow_err(); + return; /* unreachable */ + } + + if ((bufsize_t)target_size >= buf->asize) + cmark_strbuf_grow(buf, (bufsize_t)target_size); +} + +void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) { unsigned char *new_ptr; - int new_size; - - if (buf->ptr == cmark_strbuf__oom) - return -1; - if (target_size <= buf->asize) - return 0; + if (target_size < buf->asize) + return; 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); + /* Oversize the buffer by 50% to guarantee amortized linear time + * complexity on append operations. */ + size_t new_size = (size_t)target_size + (size_t)target_size / 2; + + /* Account for terminating null byte. */ + new_size += 1; /* round allocation up to multiple of 8 */ new_size = (new_size + 7) & ~7; + if (new_size < (size_t)target_size /* Integer overflow. */ + || new_size > BUFSIZE_MAX /* Truncation overflow. */ + ) { + if (target_size >= BUFSIZE_MAX) { + /* No space for terminating null byte. */ + cmark_strbuf_overflow_err(); + return; /* unreachable */ + } + /* Oversize by the maximum possible amount. */ + new_size = BUFSIZE_MAX; + } + new_ptr = (unsigned char *)realloc(new_ptr, new_size); if (!new_ptr) { - if (mark_oom) - buf->ptr = cmark_strbuf__oom; - return -1; + perror("realloc in cmark_strbuf_grow"); + abort(); } - buf->asize = new_size; + buf->asize = (bufsize_t)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) +bufsize_t cmark_strbuf_len(const cmark_strbuf *buf) { return buf->size; } @@ -98,7 +104,7 @@ void cmark_strbuf_free(cmark_strbuf *buf) { if (!buf) return; - if (buf->ptr != cmark_strbuf__initbuf && buf->ptr != cmark_strbuf__oom) + if (buf->ptr != cmark_strbuf__initbuf) free(buf->ptr); cmark_strbuf_init(buf, 0); @@ -112,106 +118,106 @@ void cmark_strbuf_clear(cmark_strbuf *buf) buf->ptr[0] = '\0'; } -int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len) +void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, bufsize_t len) { if (len <= 0 || data == NULL) { cmark_strbuf_clear(buf); } else { if (data != buf->ptr) { - ENSURE_SIZE(buf, len + 1); + if (len >= buf->asize) + cmark_strbuf_grow(buf, len); 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) +void cmark_strbuf_sets(cmark_strbuf *buf, const char *string) { - return cmark_strbuf_set(buf, - (const unsigned char *)string, - string ? strlen(string) : 0); + cmark_strbuf_set(buf, (const unsigned char *)string, + string ? cmark_strbuf_safe_strlen(string) : 0); } -int cmark_strbuf_putc(cmark_strbuf *buf, int c) +void cmark_strbuf_putc(cmark_strbuf *buf, int c) { - ENSURE_SIZE(buf, buf->size + 2); + S_strbuf_grow_by(buf, 1); 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) +void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, bufsize_t len) { if (len <= 0) - return 0; + return; - ENSURE_SIZE(buf, buf->size + len + 1); + S_strbuf_grow_by(buf, len); 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) +void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) { - return cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string)); + cmark_strbuf_put(buf, (const unsigned char *)string, + cmark_strbuf_safe_strlen(string)); } -int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap) +void 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); + size_t expected_size = strlen(format); + if (expected_size <= SIZE_MAX / 2) + expected_size *= 2; + S_strbuf_grow_by(buf, expected_size); while (1) { va_list args; va_copy(args, ap); - len = vsnprintf( + int len = vsnprintf( (char *)buf->ptr + buf->size, buf->asize - buf->size, format, args ); +#ifndef HAVE_C99_SNPRINTF + // Assume we're on Windows. + if (len < 0) { + len = _vscprintf(format, args); + } +#endif va_end(args); if (len < 0) { - free(buf->ptr); - buf->ptr = cmark_strbuf__oom; - return -1; + perror("vsnprintf in cmark_strbuf_vprintf"); + abort(); } - if (len + 1 <= buf->asize - buf->size) { + if ((size_t)len < (size_t)(buf->asize - buf->size)) { buf->size += len; break; } - ENSURE_SIZE(buf, buf->size + len + 1); + S_strbuf_grow_by(buf, len); } - - return 0; } -int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) +void 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); + cmark_strbuf_vprintf(buf, format, ap); va_end(ap); - - return r; } -void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf) +void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, const cmark_strbuf *buf) { - int copylen; + bufsize_t copylen; - assert(data && datasize && buf); + assert(buf); + if (!data || datasize <= 0) + return; data[0] = '\0'; @@ -236,7 +242,7 @@ unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) { unsigned char *data = buf->ptr; - if (buf->asize == 0 || buf->ptr == cmark_strbuf__oom) { + if (buf->asize == 0) { /* return an empty string */ return (unsigned char *)calloc(1, 1); } @@ -245,22 +251,6 @@ unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) 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)); @@ -268,20 +258,28 @@ int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b) (a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0; } -int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos) +bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos) { + if (pos >= buf->size) + return -1; + if (pos < 0) + pos = 0; + 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); + return (bufsize_t)(p - (const unsigned char *)buf->ptr); } -int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos) +bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos) { - int i; + if (pos < 0 || buf->size == 0) + return -1; + if (pos >= buf->size) + pos = buf->size - 1; - for (i = pos; i >= 0; i--) { + for (bufsize_t i = pos; i >= 0; i--) { if (buf->ptr[i] == (unsigned char) c) return i; } @@ -289,17 +287,22 @@ int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos) return -1; } -void cmark_strbuf_truncate(cmark_strbuf *buf, int len) +void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len) { + if (len < 0) + len = 0; + if (len < buf->size) { buf->size = len; buf->ptr[buf->size] = '\0'; } } -void cmark_strbuf_drop(cmark_strbuf *buf, int n) +void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n) { if (n > 0) { + if (n > buf->size) + n = buf->size; buf->size = buf->size - n; if (buf->size) memmove(buf->ptr, buf->ptr + n, buf->size); @@ -325,7 +328,7 @@ void cmark_strbuf_rtrim(cmark_strbuf *buf) void cmark_strbuf_trim(cmark_strbuf *buf) { - int i = 0; + bufsize_t i = 0; if (!buf->size) return; @@ -343,7 +346,7 @@ void cmark_strbuf_trim(cmark_strbuf *buf) void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) { bool last_char_was_space = false; - int r, w; + bufsize_t r, w; for (r = 0, w = 0; r < s->size; ++r) { switch (s->ptr[r]) { @@ -368,7 +371,7 @@ void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) // Destructively unescape a string: remove backslashes before punctuation chars. extern void cmark_strbuf_unescape(cmark_strbuf *buf) { - int r, w; + bufsize_t r, w; for (r = 0, w = 0; r < buf->size; ++r) { if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1])) diff --git a/buffer.h b/buffer.h index fb9f910..babd051 100644 --- a/buffer.h +++ b/buffer.h @@ -3,22 +3,25 @@ #include #include +#include +#include #include "config.h" #ifdef __cplusplus extern "C" { #endif +typedef int bufsize_t; + typedef struct { unsigned char *ptr; - int asize, size; + bufsize_t 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 } +#define BUFSIZE_MAX INT_MAX /** * Initialize a cmark_strbuf structure. @@ -26,51 +29,22 @@ extern unsigned char cmark_strbuf__oom[]; * 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); +void cmark_strbuf_init(cmark_strbuf *buf, bufsize_t initial_size); /** * 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_grow(cmark_strbuf *buf, bufsize_t 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); +bufsize_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); +void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, const cmark_strbuf *buf); static inline const char *cmark_strbuf_cstr(const cmark_strbuf *buf) { @@ -79,33 +53,41 @@ static inline const char *cmark_strbuf_cstr(const cmark_strbuf *buf) #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_set(cmark_strbuf *buf, const unsigned char *data, bufsize_t len); +void cmark_strbuf_sets(cmark_strbuf *buf, const char *string); +void cmark_strbuf_putc(cmark_strbuf *buf, int c); +void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, bufsize_t len); +void cmark_strbuf_puts(cmark_strbuf *buf, const char *string); +void cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) + CMARK_ATTRIBUTE((format (printf, 2, 3))); +void 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); +bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos); +bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos); +void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n); +void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t 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); +/* Print error and abort. */ +void cmark_strbuf_overflow_err(void); + +static inline bufsize_t +cmark_strbuf_check_bufsize(size_t size) { + if (size > BUFSIZE_MAX) { + cmark_strbuf_overflow_err(); + } + return (bufsize_t)size; +} + +static inline bufsize_t +cmark_strbuf_safe_strlen(const char *str) { + return cmark_strbuf_check_bufsize(strlen(str)); +} + #ifdef __cplusplus } #endif diff --git a/chunk.h b/chunk.h index 54c4b16..f23a02d 100644 --- a/chunk.h +++ b/chunk.h @@ -7,10 +7,12 @@ #include "cmark_ctype.h" #include "buffer.h" +#define CMARK_CHUNK_EMPTY { NULL, 0, 0 } + typedef struct { unsigned char *data; - int len; - int alloc; // also implies a NULL-terminated string + bufsize_t len; + bufsize_t alloc; // also implies a NULL-terminated string } cmark_chunk; static inline void cmark_chunk_free(cmark_chunk *c) @@ -49,10 +51,10 @@ static inline void cmark_chunk_trim(cmark_chunk *c) cmark_chunk_rtrim(c); } -static inline int cmark_chunk_strchr(cmark_chunk *ch, int c, int offset) +static inline bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c, bufsize_t offset) { const unsigned char *p = (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); - return p ? (int)(p - ch->data) : ch->len; + return p ? (bufsize_t)(p - ch->data) : ch->len; } static inline const char *cmark_chunk_to_cstr(cmark_chunk *c) @@ -64,7 +66,9 @@ static inline const char *cmark_chunk_to_cstr(cmark_chunk *c) } str = (unsigned char *)malloc(c->len + 1); if(str != NULL) { - memcpy(str, c->data, c->len); + if(c->len > 0) { + memcpy(str, c->data, c->len); + } str[c->len] = 0; } c->data = str; @@ -78,19 +82,26 @@ 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); + if (str == NULL) { + c->len = 0; + c->data = NULL; + c->alloc = 0; + } else { + c->len = cmark_strbuf_safe_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}; + bufsize_t len = data ? cmark_strbuf_safe_strlen(data) : 0; + cmark_chunk c = {(unsigned char *)data, len, 0}; return c; } -static inline cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, int pos, int len) +static inline cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, bufsize_t pos, bufsize_t len) { cmark_chunk c = {ch->data + pos, len, 0}; return c; diff --git a/cmark.c b/cmark.c index 79ceabf..35765b1 100644 --- a/cmark.c +++ b/cmark.c @@ -9,7 +9,7 @@ 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) +char *cmark_markdown_to_html(const char *text, size_t len, int options) { cmark_node *doc; char *result; diff --git a/cmark.h b/cmark.h index e41d995..a7670e9 100644 --- a/cmark.h +++ b/cmark.h @@ -24,7 +24,7 @@ extern "C" { * UTF-8-encoded string. */ CMARK_EXPORT -char *cmark_markdown_to_html(const char *text, int len, int options); +char *cmark_markdown_to_html(const char *text, size_t len, int options); /** ## Node Structure */ diff --git a/commonmark.c b/commonmark.c index 805f139..4594748 100644 --- a/commonmark.c +++ b/commonmark.c @@ -20,7 +20,7 @@ struct render_state { int column; int width; int need_cr; - int last_breakable; + bufsize_t last_breakable; bool begin_line; bool no_wrap; bool in_tight_list_item; @@ -237,28 +237,31 @@ shortest_unused_backtick_sequence(cmark_chunk *code) static bool is_autolink(cmark_node *node) { - const char *title; - const char *url; + cmark_chunk *title; + cmark_chunk *url; + cmark_node *link_text; if (node->type != CMARK_NODE_LINK) { return false; } - url = cmark_node_get_url(node); - if (url == NULL || - _scan_scheme((unsigned char *)url) == 0) { + url = &node->as.link.url; + if (url->len == 0 || scan_scheme(url, 0) == 0) { return false; } - title = cmark_node_get_title(node); + title = &node->as.link.title; // if it has a title, we can't treat it as an autolink: - if (title != NULL && strlen(title) > 0) { + if (title->len > 0) { return false; } - cmark_consolidate_text_nodes(node); - return (strncmp(url, - (char*)node->as.literal.data, - node->as.literal.len) == 0); + + link_text = node->first_child; + cmark_consolidate_text_nodes(link_text); + return (url->len == link_text->as.literal.len && + strncmp((char*)url->data, + (char*)link_text->as.literal.data, + link_text->as.literal.len) == 0); } // if node is a block node, returns node. @@ -285,11 +288,11 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, int numticks; int i; bool entering = (ev_type == CMARK_EVENT_ENTER); - const char *info; - const char *title; + cmark_chunk *info; + cmark_chunk *title; cmark_strbuf listmarker = GH_BUF_INIT; char *emph_delim; - int marker_width; + bufsize_t marker_width; // Don't adjust tight list status til we've started the list. // Otherwise we loose the blank line between a paragraph and @@ -392,12 +395,12 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_CODE_BLOCK: blankline(state); - info = cmark_node_get_fence_info(node); + info = &node->as.code.info; code = &node->as.code.literal; // use indented form if no info, and code doesn't // begin or end with a blank line, and code isn't // first thing in a list item - if ((info == NULL || strlen(info) == 0) && + if (info->len == 0 && (code->len > 2 && !isspace(code->data[0]) && !(isspace(code->data[code->len - 1]) && @@ -418,7 +421,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, lit(state, "`", false); } lit(state, " ", false); - out(state, cmark_chunk_literal(info), false, LITERAL); + out(state, *info, false, LITERAL); cr(state); out(state, node->as.code.literal, false, LITERAL); cr(state); @@ -538,11 +541,10 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, out(state, cmark_chunk_literal(cmark_node_get_url(node)), false, URL); - title = cmark_node_get_title(node); - if (title && strlen(title) > 0) { + title = &node->as.link.title; + if (title->len > 0) { lit(state, " \"", true); - out(state, cmark_chunk_literal(title), - false, TITLE); + out(state, *title, false, TITLE); lit(state, "\"", false); } lit(state, ")", false); @@ -556,10 +558,10 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, } else { lit(state, "](", false); out(state, cmark_chunk_literal(cmark_node_get_url(node)), false, URL); - title = cmark_node_get_title(node); - if (title && strlen(title) > 0) { + title = &node->as.link.title; + if (title->len > 0) { lit(state, " \"", true); - out(state, cmark_chunk_literal(title), false, TITLE); + out(state, *title, false, TITLE); lit(state, "\"", false); } lit(state, ")", false); diff --git a/commonmark.go b/commonmark.go index df479ed..aff8eb7 100644 --- a/commonmark.go +++ b/commonmark.go @@ -24,7 +24,7 @@ func Md2Html(mdtext string, options int) string { mdtext += "\n" } mdCstr := C.CString(mdtext) - strLen := C.int(len(mdtext)) + strLen := C.size_t(len(mdtext)) defer C.free(unsafe.Pointer(mdCstr)) htmlString := C.cmark_markdown_to_html(mdCstr, strLen, C.int(options)) defer C.free(unsafe.Pointer(htmlString)) diff --git a/config.h b/config.h index 3de8c11..8eb09a1 100644 --- a/config.h +++ b/config.h @@ -21,3 +21,5 @@ #ifndef HAVE_VA_COPY #define va_copy(dest, src) ((dest) = (src)) #endif + +#define HAVE_C99_SNPRINTF diff --git a/houdini.h b/houdini.h index 9f00f6d..b926cf3 100644 --- a/houdini.h +++ b/houdini.h @@ -31,19 +31,12 @@ extern "C" { #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); +extern bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, bufsize_t size); +extern int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size); +extern int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, bufsize_t size, int secure); +extern int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size); +extern void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, bufsize_t size); +extern int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, bufsize_t size); #ifdef __cplusplus } diff --git a/houdini_href_e.c b/houdini_href_e.c index 7527780..7fb958a 100644 --- a/houdini_href_e.c +++ b/houdini_href_e.c @@ -49,10 +49,10 @@ static const char HREF_SAFE[] = { }; int -houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, size_t size) +houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { static const uint8_t hex_chars[] = "0123456789ABCDEF"; - size_t i = 0, org; + bufsize_t i = 0, org; uint8_t hex_str[3]; hex_str[0] = '%'; diff --git a/houdini_html_e.c b/houdini_html_e.c index 1a4c3e1..7f4b91f 100644 --- a/houdini_html_e.c +++ b/houdini_html_e.c @@ -45,9 +45,9 @@ static const char *HTML_ESCAPES[] = { }; int -houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, size_t size, int secure) +houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, bufsize_t size, int secure) { - size_t i = 0, org, esc = 0; + bufsize_t i = 0, org, esc = 0; while (i < size) { org = i; @@ -75,7 +75,7 @@ houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, size_t size, int secu } int -houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, size_t size) +houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { return houdini_escape_html0(ob, src, size, 1); } diff --git a/houdini_html_u.c b/houdini_html_u.c index 2cb14b4..e57894d 100644 --- a/houdini_html_u.c +++ b/houdini_html_u.c @@ -7,37 +7,50 @@ #include "utf8.h" #include "html_unescape.h" -size_t -houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size) +bufsize_t +houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { - size_t i = 0; + bufsize_t i = 0; - if (size > 3 && src[0] == '#') { - int codepoint = 0; + if (size >= 3 && src[0] == '#') { + int codepoint = 0; + int num_digits = 0; if (_isdigit(src[1])) { for (i = 1; i < size && _isdigit(src[i]); ++i) { - int cp = (codepoint * 10) + (src[i] - '0'); + codepoint = (codepoint * 10) + (src[i] - '0'); - if (cp < codepoint) - return 0; - - codepoint = cp; + if (codepoint >= 0x110000) { + // Keep counting digits but + // avoid integer overflow. + codepoint = 0x110000; + } } + + num_digits = i - 1; } 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); + codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9); - if (cp < codepoint) - return 0; - - codepoint = cp; + if (codepoint >= 0x110000) { + // Keep counting digits but + // avoid integer overflow. + codepoint = 0x110000; + } } + + num_digits = i - 2; } - if (i < size && src[i] == ';' && codepoint) { + if (num_digits >= 1 && num_digits <= 8 && + i < size && src[i] == ';') { + if (codepoint == 0 || + (codepoint >= 0xD800 && codepoint < 0xE000) || + codepoint >= 0x110000) { + codepoint = 0xFFFD; + } utf8proc_encode_char(codepoint, ob); return i + 1; } @@ -55,7 +68,7 @@ houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size) const struct html_ent *entity = find_entity((char *)src, i); if (entity != NULL) { - int len = 0; + bufsize_t len = 0; while (len < 4 && entity->utf8[len] != '\0') { ++len; } @@ -72,9 +85,9 @@ houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size) } int -houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, size_t size) +houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { - size_t i = 0, org, ent; + bufsize_t i = 0, org, ent; while (i < size) { org = i; @@ -109,7 +122,7 @@ houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, size_t size) return 1; } -void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, size_t size) +void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { if (!houdini_unescape_html(ob, src, size)) cmark_strbuf_put(ob, src, size); diff --git a/html.c b/html.c index f1b88fa..a30bbca 100644 --- a/html.c +++ b/html.c @@ -11,20 +11,9 @@ // Functions to convert cmark_nodes to HTML strings. -static void escape_html(cmark_strbuf *dest, const unsigned char *source, int length) +static void escape_html(cmark_strbuf *dest, const unsigned char *source, bufsize_t 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); + houdini_escape_html0(dest, source, length, 0); } static inline void cr(cmark_strbuf *html) @@ -165,7 +154,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, S_render_sourcepos(node, html, options); cmark_strbuf_puts(html, ">"); } else { - int first_tag = 0; + bufsize_t first_tag = 0; while (first_tag < node->as.code.info.len && node->as.code.info.data[first_tag] != ' ') { first_tag += 1; @@ -261,12 +250,13 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_LINK: if (entering) { cmark_strbuf_puts(html, "as.link.url) - escape_href(html, node->as.link.url, -1); + houdini_escape_href(html, node->as.link.url.data, + node->as.link.url.len); - if (node->as.link.title) { + if (node->as.link.title.len) { cmark_strbuf_puts(html, "\" title=\""); - escape_html(html, node->as.link.title, -1); + escape_html(html, node->as.link.title.data, + node->as.link.title.len); } cmark_strbuf_puts(html, "\">"); @@ -278,15 +268,16 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_IMAGE: if (entering) { cmark_strbuf_puts(html, "as.link.url) - escape_href(html, node->as.link.url, -1); + houdini_escape_href(html, node->as.link.url.data, + node->as.link.url.len); cmark_strbuf_puts(html, "\" alt=\""); state->plain = node; } else { - if (node->as.link.title) { + if (node->as.link.title.len) { cmark_strbuf_puts(html, "\" title=\""); - escape_html(html, node->as.link.title, -1); + escape_html(html, node->as.link.title.data, + node->as.link.title.len); } cmark_strbuf_puts(html, "\" />"); diff --git a/inlines.c b/inlines.c index afe564c..7e8f806 100644 --- a/inlines.c +++ b/inlines.c @@ -36,7 +36,7 @@ typedef struct delimiter { struct delimiter *previous; struct delimiter *next; cmark_node *inl_text; - int position; + bufsize_t position; unsigned char delim_char; bool can_open; bool can_close; @@ -45,7 +45,7 @@ typedef struct delimiter { typedef struct { cmark_chunk input; - int pos; + bufsize_t pos; cmark_reference_map *refmap; delimiter *last_delim; } subject; @@ -57,33 +57,35 @@ 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 bufsize_t subject_find_special_char(subject *subj, int options); -static unsigned char *cmark_clean_autolink(cmark_chunk *url, int is_email) +static cmark_chunk 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 (url->len == 0) { + cmark_chunk result = CMARK_CHUNK_EMPTY; + return result; + } if (is_email) cmark_strbuf_puts(&buf, "mailto:"); houdini_unescape_html_f(&buf, url->data, url->len); - return cmark_strbuf_detach(&buf); + return cmark_chunk_buf_detach(&buf); } -static inline cmark_node *make_link(cmark_node *label, unsigned char *url, unsigned char *title) +static inline cmark_node *make_link(cmark_node *label, cmark_chunk *url, cmark_chunk *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->as.link.url = *url; + e->as.link.title = *title; e->next = NULL; label->parent = e; } @@ -92,7 +94,9 @@ static inline cmark_node *make_link(cmark_node *label, unsigned char *url, unsig 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); + cmark_chunk clean_url = cmark_clean_autolink(&url, is_email); + cmark_chunk title = CMARK_CHUNK_EMPTY; + return make_link(label, &clean_url, &title); } // Create an inline with a literal string value. @@ -134,19 +138,20 @@ static inline cmark_node* make_simple(cmark_node_type t) return e; } -static unsigned char *bufdup(const unsigned char *buf) +// Duplicate a chunk by creating a copy of the buffer not by reusing the +// buffer like cmark_chunk_dup does. +static cmark_chunk chunk_clone(cmark_chunk *src) { - unsigned char *new_buf = NULL; + cmark_chunk c; + bufsize_t len = src->len; - 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); - } - } + c.len = len; + c.data = (unsigned char *)malloc(len + 1); + c.alloc = 1; + memcpy(c.data, src->data, len); + c.data[len] = '\0'; - return new_buf; + return c; } static void subject_from_buf(subject *e, cmark_strbuf *buffer, @@ -172,7 +177,7 @@ 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) +static inline unsigned char peek_at(subject *subj, bufsize_t pos) { return subj->input.data[pos]; } @@ -190,8 +195,8 @@ static inline int is_eof(subject* subj) static inline cmark_chunk take_while(subject* subj, int (*f)(int)) { unsigned char c; - int startpos = subj->pos; - int len = 0; + bufsize_t startpos = subj->pos; + bufsize_t len = 0; while ((c = peek_char(subj)) && (*f)(c)) { advance(subj); @@ -206,7 +211,7 @@ static inline cmark_chunk take_while(subject* subj, int (*f)(int)) // 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) +static bufsize_t scan_to_closing_backticks(subject* subj, bufsize_t openticklength) { // read non backticks unsigned char c; @@ -216,7 +221,7 @@ static int scan_to_closing_backticks(subject* subj, int openticklength) if (is_eof(subj)) { return 0; // did not find closing ticks, return 0 } - int numticks = 0; + bufsize_t numticks = 0; while (peek_char(subj) == '`') { advance(subj); numticks++; @@ -232,8 +237,8 @@ static int scan_to_closing_backticks(subject* subj, int openticklength) 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); + bufsize_t startpos = subj->pos; + bufsize_t endpos = scan_to_closing_backticks(subj, openticks.len); if (endpos == 0) { // not found subj->pos = startpos; // rewind @@ -255,7 +260,7 @@ static int scan_delims(subject* subj, unsigned char c, bool * can_open, bool * can_close) { int numdelims = 0; - int before_char_pos; + bufsize_t before_char_pos; int32_t after_char = 0; int32_t before_char = 0; int len; @@ -302,9 +307,9 @@ scan_delims(subject* subj, unsigned char c, bool * can_open, bool * can_close) !utf8proc_is_punctuation(after_char)); if (c == '_') { *can_open = left_flanking && - (!right_flanking || utf8proc_is_punctuation(before_char)); + (!right_flanking || utf8proc_is_punctuation(before_char)); *can_close = right_flanking && - (!left_flanking || utf8proc_is_punctuation(after_char)); + (!left_flanking || utf8proc_is_punctuation(after_char)); } else if (c == '\'' || c == '"') { *can_open = left_flanking && !right_flanking; *can_close = right_flanking; @@ -371,7 +376,7 @@ static void push_delimiter(subject *subj, unsigned char c, bool can_open, // Assumes the subject has a c at the current position. static cmark_node* handle_delim(subject* subj, unsigned char c, bool smart) { - int numdelims; + bufsize_t numdelims; cmark_node * inl_text; bool can_open, can_close; cmark_chunk contents; @@ -495,11 +500,11 @@ static delimiter* S_insert_emph(subject *subj, delimiter *opener, delimiter *closer) { delimiter *delim, *tmp_delim; - int use_delims; + bufsize_t 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; + bufsize_t opener_num_chars = opener_inl->as.literal.len; + bufsize_t 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 @@ -578,7 +583,7 @@ static cmark_node* handle_backslash(subject *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') { + } else if (nextchar == '\r' || nextchar == '\n') { advance(subj); return make_linebreak(); } else { @@ -591,7 +596,7 @@ static cmark_node* handle_backslash(subject *subj) static cmark_node* handle_entity(subject* subj) { cmark_strbuf ent = GH_BUF_INIT; - size_t len; + bufsize_t len; advance(subj); @@ -613,7 +618,7 @@ 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)) { + if (houdini_unescape_html(&unescaped, content->data, content->len)) { return make_str(cmark_chunk_buf_detach(&unescaped)); } else { return make_str(*content); @@ -622,14 +627,16 @@ static cmark_node *make_str_with_entities(cmark_chunk *content) // Clean a URL: remove surrounding whitespace and surrounding <>, // and remove \ that escape punctuation. -unsigned char *cmark_clean_url(cmark_chunk *url) +cmark_chunk cmark_clean_url(cmark_chunk *url) { cmark_strbuf buf = GH_BUF_INIT; cmark_chunk_trim(url); - if (url->len == 0) - return NULL; + if (url->len == 0) { + cmark_chunk result = CMARK_CHUNK_EMPTY; + return result; + } if (url->data[0] == '<' && url->data[url->len - 1] == '>') { houdini_unescape_html_f(&buf, url->data + 1, url->len - 2); @@ -638,16 +645,18 @@ unsigned char *cmark_clean_url(cmark_chunk *url) } cmark_strbuf_unescape(&buf); - return buf.size == 0 ? NULL : cmark_strbuf_detach(&buf); + return cmark_chunk_buf_detach(&buf); } -unsigned char *cmark_clean_title(cmark_chunk *title) +cmark_chunk cmark_clean_title(cmark_chunk *title) { cmark_strbuf buf = GH_BUF_INIT; unsigned char first, last; - if (title->len == 0) - return NULL; + if (title->len == 0) { + cmark_chunk result = CMARK_CHUNK_EMPTY; + return result; + } first = title->data[0]; last = title->data[title->len - 1]; @@ -662,14 +671,14 @@ unsigned char *cmark_clean_title(cmark_chunk *title) } cmark_strbuf_unescape(&buf); - return buf.size == 0 ? NULL : cmark_strbuf_detach(&buf); + return cmark_chunk_buf_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; + bufsize_t matchlen = 0; cmark_chunk contents; advance(subj); // advance past first < @@ -716,7 +725,7 @@ static cmark_node* handle_pointy_brace(subject* subj) // encountered. Backticks in labels do not start code spans. static int link_label(subject* subj, cmark_chunk *raw_label) { - int startpos = subj->pos; + bufsize_t startpos = subj->pos; int length = 0; unsigned char c; @@ -746,6 +755,7 @@ static int link_label(subject* subj, cmark_chunk *raw_label) if (c == ']') { // match found *raw_label = cmark_chunk_dup(&subj->input, startpos + 1, subj->pos - (startpos + 1)); + cmark_chunk_trim(raw_label); advance(subj); // advance past ] return 1; } @@ -759,14 +769,14 @@ static int link_label(subject* subj, cmark_chunk *raw_label) // 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; + bufsize_t initial_pos; + bufsize_t starturl, endurl, starttitle, endtitle, endall; + bufsize_t n; + bufsize_t sps; cmark_reference *ref; bool is_image = false; cmark_chunk url_chunk, title_chunk; - unsigned char *url, *title; + cmark_chunk url, title; delimiter *opener; cmark_node *link_text; cmark_node *inl; @@ -854,8 +864,8 @@ static cmark_node* handle_close_bracket(subject* subj, cmark_node *parent) cmark_chunk_free(&raw_label); if (ref != NULL) { // found - url = bufdup(ref->url); - title = bufdup(ref->title); + url = chunk_clone(&ref->url); + title = chunk_clone(&ref->title); goto match; } else { goto noMatch; @@ -912,7 +922,7 @@ static cmark_node* handle_close_bracket(subject* subj, cmark_node *parent) // Assumes the subject has a newline at the current position. static cmark_node* handle_newline(subject *subj) { - int nlpos = subj->pos; + bufsize_t nlpos = subj->pos; // skip over newline advance(subj); // skip spaces at beginning of line @@ -928,11 +938,11 @@ static cmark_node* handle_newline(subject *subj) } } -static int subject_find_special_char(subject *subj, int options) +static bufsize_t subject_find_special_char(subject *subj, int options) { - // "\n\\`&_*[]pos + 1; + bufsize_t n = subj->pos + 1; while (n < subj->input.len) { if (SPECIAL_CHARS[subj->input.data[n]]) @@ -991,12 +1001,13 @@ static int parse_inline(subject* subj, cmark_node * parent, int options) cmark_node* new_inl = NULL; cmark_chunk contents; unsigned char c; - int endpos; + bufsize_t endpos; c = peek_char(subj); if (c == 0) { return 0; } switch(c) { + case '\r': case '\n': new_inl = handle_newline(subj); break; @@ -1048,7 +1059,7 @@ static int parse_inline(subject* subj, cmark_node * parent, int options) subj->pos = endpos; // if we're at a newline, strip trailing spaces. - if (peek_char(subj) == '\n') { + if (peek_char(subj) == '\r' || peek_char(subj) == '\n') { cmark_chunk_rtrim(&contents); } @@ -1078,7 +1089,7 @@ static void spnl(subject* subj) bool seen_newline = false; while (peek_char(subj) == ' ' || (!seen_newline && - (seen_newline = peek_char(subj) == '\n'))) { + (seen_newline = peek_char(subj) == '\r' || peek_char(subj) == '\n'))) { advance(subj); } } @@ -1087,7 +1098,7 @@ static void spnl(subject* subj) // 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) +bufsize_t cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap) { subject subj; @@ -1095,13 +1106,13 @@ int cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refma cmark_chunk url; cmark_chunk title; - int matchlen = 0; - int beforetitle; + bufsize_t matchlen = 0; + bufsize_t beforetitle; subject_from_buf(&subj, input, NULL); // parse label: - if (!link_label(&subj, &lab)) + if (!link_label(&subj, &lab) || lab.len == 0) return 0; // colon: @@ -1136,7 +1147,7 @@ int cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refma while (peek_char(&subj) == ' ') { advance(&subj); } - if (peek_char(&subj) == '\n') { + if (peek_char(&subj) == '\r' || peek_char(&subj) == '\n') { advance(&subj); } else if (peek_char(&subj) != 0) { return 0; diff --git a/inlines.h b/inlines.h index 9e56790..f8847fc 100644 --- a/inlines.h +++ b/inlines.h @@ -5,12 +5,12 @@ extern "C" { #endif -unsigned char *cmark_clean_url(cmark_chunk *url); -unsigned char *cmark_clean_title(cmark_chunk *title); +cmark_chunk cmark_clean_url(cmark_chunk *url); +cmark_chunk 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); +bufsize_t cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap); #ifdef __cplusplus } diff --git a/iterator.c b/iterator.c index c6faf99..f18e3bf 100644 --- a/iterator.c +++ b/iterator.c @@ -129,18 +129,20 @@ void cmark_consolidate_text_nodes(cmark_node *root) cur->next && cur->next->type == CMARK_NODE_TEXT) { cmark_strbuf_clear(&buf); - cmark_strbuf_puts(&buf, cmark_node_get_literal(cur)); + cmark_strbuf_put(&buf, cur->as.literal.data, cur->as.literal.len); 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)); + cmark_strbuf_put(&buf, tmp->as.literal.data, tmp->as.literal.len); next = tmp->next; cmark_node_free(tmp); tmp = next; } - cmark_node_set_literal(cur, (char *)cmark_strbuf_detach(&buf)); + cmark_chunk_free(&cur->as.literal); + cur->as.literal = cmark_chunk_buf_detach(&buf); } } + cmark_strbuf_free(&buf); cmark_iter_free(iter); } diff --git a/node.c b/node.c index 466b0a1..7b1bb10 100644 --- a/node.c +++ b/node.c @@ -122,12 +122,8 @@ void S_free_nodes(cmark_node *e) 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); - } + cmark_chunk_free(&e->as.link.url); + cmark_chunk_free(&e->as.link.title); break; default: break; @@ -282,15 +278,6 @@ cmark_node_set_user_data(cmark_node *node, void *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) { @@ -541,7 +528,7 @@ cmark_node_get_url(cmark_node *node) switch (node->type) { case NODE_LINK: case NODE_IMAGE: - return (char *)node->as.link.url; + return cmark_chunk_to_cstr(&node->as.link.url); default: break; } @@ -559,8 +546,7 @@ cmark_node_set_url(cmark_node *node, const char *url) switch (node->type) { case NODE_LINK: case NODE_IMAGE: - free(node->as.link.url); - node->as.link.url = (unsigned char *)S_strdup(url); + cmark_chunk_set_cstr(&node->as.link.url, url); return 1; default: break; @@ -579,7 +565,7 @@ cmark_node_get_title(cmark_node *node) switch (node->type) { case NODE_LINK: case NODE_IMAGE: - return (char *)node->as.link.title; + return cmark_chunk_to_cstr(&node->as.link.title); default: break; } @@ -597,8 +583,7 @@ cmark_node_set_title(cmark_node *node, const char *title) switch (node->type) { case NODE_LINK: case NODE_IMAGE: - free(node->as.link.title); - node->as.link.title = (unsigned char *)S_strdup(title); + cmark_chunk_set_cstr(&node->as.link.title, title); return 1; default: break; diff --git a/node.h b/node.h index 7a45d42..911a18f 100644 --- a/node.h +++ b/node.h @@ -38,8 +38,8 @@ typedef struct { } cmark_header; typedef struct { - unsigned char *url; - unsigned char *title; + cmark_chunk url; + cmark_chunk title; } cmark_link; struct cmark_node { diff --git a/parser.h b/parser.h index cbccae3..6e18c67 100644 --- a/parser.h +++ b/parser.h @@ -16,8 +16,12 @@ struct cmark_parser { struct cmark_node* root; struct cmark_node* current; int line_number; + bufsize_t offset; + bufsize_t first_nonspace; + int indent; + bool blank; cmark_strbuf *curline; - int last_line_length; + bufsize_t last_line_length; cmark_strbuf *linebuf; int options; }; diff --git a/references.c b/references.c index 37bf4cb..1d3d56d 100644 --- a/references.c +++ b/references.c @@ -20,8 +20,8 @@ static void reference_free(cmark_reference *ref) { if(ref != NULL) { free(ref->label); - free(ref->url); - free(ref->title); + cmark_chunk_free(&ref->url); + cmark_chunk_free(&ref->title); free(ref); } } diff --git a/references.h b/references.h index 69325bb..a360cd5 100644 --- a/references.h +++ b/references.h @@ -12,8 +12,8 @@ extern "C" { struct cmark_reference { struct cmark_reference *next; unsigned char *label; - unsigned char *url; - unsigned char *title; + cmark_chunk url; + cmark_chunk title; unsigned int hash; }; diff --git a/scanners.c b/scanners.c index 42b9275..3f4ddac 100644 --- a/scanners.c +++ b/scanners.c @@ -1,11 +1,11 @@ -/* Generated by re2c 0.13.6 */ +/* Generated by re2c 0.13.5 */ #include #include "chunk.h" #include "scanners.h" -int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset) +bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, bufsize_t offset) { - int res; + bufsize_t res; unsigned char *ptr = (unsigned char *)c->data; unsigned char lim = ptr[c->len]; @@ -19,7 +19,7 @@ int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset) // Try to match a scheme including colon. -int _scan_scheme(const unsigned char *p) +bufsize_t _scan_scheme(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -578,7 +578,7 @@ int _scan_scheme(const unsigned char *p) if (yych != ':') goto yy31; yy35: ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } yy37: yych = *++p; if (yych == 'E') goto yy38; @@ -2919,7 +2919,7 @@ int _scan_scheme(const unsigned char *p) } // Try to match URI autolink after first <, returning number of chars matched. -int _scan_autolink_uri(const unsigned char *p) +bufsize_t _scan_autolink_uri(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -3517,7 +3517,7 @@ int _scan_autolink_uri(const unsigned char *p) } if (yych <= '=') goto yy516; ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } yy524: yych = *++p; if (yych == 'E') goto yy525; @@ -5858,7 +5858,7 @@ int _scan_autolink_uri(const unsigned char *p) } // Try to match email autolink after first <, returning num of chars matched. -int _scan_autolink_email(const unsigned char *p) +bufsize_t _scan_autolink_email(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -6060,7 +6060,7 @@ int _scan_autolink_email(const unsigned char *p) } yy985: ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } yy987: ++p; yych = *p; @@ -10803,7 +10803,7 @@ int _scan_autolink_email(const unsigned char *p) } // Try to match an HTML tag after first <, returning num of chars matched. -int _scan_html_tag(const unsigned char *p) +bufsize_t _scan_html_tag(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -10964,7 +10964,7 @@ int _scan_html_tag(const unsigned char *p) if (yych != '>') goto yy1239; yy1243: ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } yy1245: yych = *++p; if (yych == 'C') goto yy1260; @@ -11455,7 +11455,7 @@ int _scan_html_tag(const unsigned char *p) // Try to match an HTML block tag including first <, // returning num of chars matched. -int _scan_html_block_tag(const unsigned char *p) +bufsize_t _scan_html_block_tag(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -11513,7 +11513,7 @@ int _scan_html_block_tag(const unsigned char *p) goto yy1301; yy1304: ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } yy1306: yych = *++p; if (yych <= '/') { @@ -12022,7 +12022,7 @@ int _scan_html_block_tag(const unsigned char *p) } yy1344: ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } yy1346: yych = *++p; if (yych <= 'R') { @@ -12639,7 +12639,7 @@ int _scan_html_block_tag(const unsigned char *p) } yy1467: ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } yy1469: yych = *++p; if (yych <= 'R') { @@ -13243,7 +13243,7 @@ int _scan_html_block_tag(const unsigned char *p) // 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) +bufsize_t _scan_link_url(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -13253,7 +13253,7 @@ int _scan_link_url(const unsigned char *p) 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, 8, 64, 64, 8, 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, @@ -13286,27 +13286,29 @@ int _scan_link_url(const unsigned char *p) 112, 112, 112, 112, 112, 112, 112, 112, }; yych = *p; - if (yych <= '(') { - if (yych <= 0x1F) { + if (yych <= '\'') { + if (yych <= '\f') { if (yych == '\n') goto yy1589; goto yy1597; } else { + if (yych <= '\r') goto yy1591; + if (yych <= 0x1F) goto yy1597; if (yych <= ' ') goto yy1591; - if (yych <= '\'') goto yy1593; - goto yy1596; + goto yy1593; } } else { - if (yych <= '<') { + if (yych <= ';') { + if (yych <= '(') goto yy1596; if (yych <= ')') goto yy1597; - if (yych <= ';') goto yy1593; - goto yy1592; + goto yy1593; } else { + if (yych <= '<') goto yy1592; if (yych == '\\') goto yy1594; goto yy1593; } } yy1588: - { return (p - start); } + { return (bufsize_t)(p - start); } yy1589: yyaccept = 0; marker = ++p; @@ -13339,13 +13341,18 @@ int _scan_link_url(const unsigned char *p) if (yybm[0+yych] & 32) { goto yy1605; } - if (yych <= '\'') { - if (yych <= 0x00) goto yy1588; - if (yych == '\n') goto yy1588; - goto yy1612; + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1588; + goto yy1612; + } else { + if (yych <= '\n') goto yy1588; + if (yych <= '\f') goto yy1612; + goto yy1588; + } } else { if (yych <= ')') { - if (yych <= '(') goto yy1610; + if (yych == '(') goto yy1610; goto yy1612; } else { if (yych <= '=') goto yy1602; @@ -13395,7 +13402,7 @@ int _scan_link_url(const unsigned char *p) yy1600: p = marker; if (yyaccept <= 1) { - if (yyaccept == 0) { + if (yyaccept <= 0) { goto yy1588; } else { goto yy1595; @@ -13459,13 +13466,18 @@ int _scan_link_url(const unsigned char *p) if (yybm[0+yych] & 32) { goto yy1605; } - if (yych <= '\'') { - if (yych <= 0x00) goto yy1588; - if (yych == '\n') goto yy1588; - goto yy1612; + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1588; + goto yy1612; + } else { + if (yych <= '\n') goto yy1588; + if (yych <= '\f') goto yy1612; + goto yy1588; + } } else { if (yych <= ')') { - if (yych <= '(') goto yy1610; + if (yych == '(') goto yy1610; goto yy1612; } else { if (yych <= '=') goto yy1602; @@ -13478,48 +13490,57 @@ int _scan_link_url(const unsigned char *p) if (yych <= ' ') goto yy1608; if (yych != ')') goto yy1603; yy1608: - { return (p - start); } + { return (bufsize_t)(p - start); } yy1609: ++p; yych = *p; - if (yych <= '>') { - if (yych <= ' ') { + if (yych <= '=') { + if (yych <= '\f') { if (yych <= 0x00) goto yy1600; if (yych == '\n') goto yy1600; goto yy1612; } else { - if (yych <= '/') goto yy1605; - if (yych <= '9') goto yy1612; - if (yych <= '=') goto yy1605; - goto yy1622; + if (yych <= ' ') { + if (yych <= '\r') goto yy1600; + goto yy1612; + } else { + if (yych <= '/') goto yy1605; + if (yych <= '9') goto yy1612; + goto yy1605; + } } } else { - if (yych <= '\\') { + if (yych <= '[') { + if (yych <= '>') goto yy1622; if (yych <= '@') goto yy1605; if (yych <= 'Z') goto yy1612; - if (yych <= '[') goto yy1605; - goto yy1623; + goto yy1605; } else { - if (yych <= '`') goto yy1605; - if (yych <= 'z') goto yy1612; - if (yych <= '~') goto yy1605; - goto yy1612; + if (yych <= '`') { + if (yych <= '\\') goto yy1623; + goto yy1605; + } else { + if (yych <= 'z') goto yy1612; + if (yych <= '~') goto yy1605; + goto yy1612; + } } } yy1610: ++p; yych = *p; - if (yych <= ')') { - if (yych <= '\n') { + if (yych <= '(') { + if (yych <= '\f') { if (yych <= 0x00) goto yy1600; - if (yych >= '\n') goto yy1600; + if (yych == '\n') goto yy1600; } else { + if (yych <= '\r') goto yy1600; if (yych <= ' ') goto yy1612; if (yych <= '\'') goto yy1610; - if (yych >= ')') goto yy1605; } } else { if (yych <= '=') { + if (yych <= ')') goto yy1605; if (yych == '<') goto yy1598; goto yy1610; } else { @@ -13545,11 +13566,12 @@ int _scan_link_url(const unsigned char *p) if (yybm[0+yych] & 128) { goto yy1615; } - if (yych <= '\n') { + if (yych <= '\f') { if (yych <= 0x00) goto yy1600; - if (yych <= '\t') goto yy1612; - goto yy1600; + if (yych == '\n') goto yy1600; + goto yy1612; } else { + if (yych <= '\r') goto yy1600; if (yych != '>') goto yy1612; } yyaccept = 2; @@ -13570,46 +13592,56 @@ int _scan_link_url(const unsigned char *p) yy1619: ++p; yych = *p; - if (yych <= '>') { - if (yych <= ' ') { + if (yych <= '=') { + if (yych <= '\f') { if (yych <= 0x00) goto yy1600; if (yych == '\n') goto yy1600; goto yy1612; } else { - if (yych <= '/') goto yy1610; - if (yych <= '9') goto yy1612; - if (yych <= '=') goto yy1610; + if (yych <= ' ') { + if (yych <= '\r') goto yy1600; + goto yy1612; + } else { + if (yych <= '/') goto yy1610; + if (yych <= '9') goto yy1612; + goto yy1610; + } } } else { - if (yych <= '\\') { + if (yych <= '[') { + if (yych <= '>') goto yy1620; if (yych <= '@') goto yy1610; if (yych <= 'Z') goto yy1612; - if (yych <= '[') goto yy1610; - goto yy1621; + goto yy1610; } else { - if (yych <= '`') goto yy1610; - if (yych <= 'z') goto yy1612; - if (yych <= '~') goto yy1610; - goto yy1612; + if (yych <= '`') { + if (yych <= '\\') goto yy1621; + goto yy1610; + } else { + if (yych <= 'z') goto yy1612; + if (yych <= '~') goto yy1610; + goto yy1612; + } } } yy1620: yyaccept = 2; marker = ++p; yych = *p; - if (yych <= ')') { - if (yych <= '\n') { + if (yych <= '(') { + if (yych <= '\f') { if (yych <= 0x00) goto yy1608; - if (yych <= '\t') goto yy1612; - goto yy1608; + if (yych == '\n') goto yy1608; + goto yy1612; } else { + if (yych <= '\r') goto yy1608; if (yych <= ' ') goto yy1612; if (yych <= '\'') goto yy1610; - if (yych <= '(') goto yy1612; - goto yy1605; + goto yy1612; } } else { if (yych <= '=') { + if (yych <= ')') goto yy1605; if (yych == '<') goto yy1598; goto yy1610; } else { @@ -13621,22 +13653,23 @@ int _scan_link_url(const unsigned char *p) yy1621: ++p; yych = *p; - if (yych <= '(') { + if (yych <= '\'') { if (yych <= '\n') { if (yych <= 0x00) goto yy1600; if (yych <= '\t') goto yy1612; goto yy1600; } else { + if (yych == '\r') goto yy1600; if (yych <= ' ') goto yy1612; - if (yych <= '\'') goto yy1610; - goto yy1612; + goto yy1610; } } else { - if (yych <= '>') { + if (yych <= '=') { + if (yych <= '(') goto yy1612; if (yych <= ')') goto yy1605; - if (yych <= '=') goto yy1610; - goto yy1620; + goto yy1610; } else { + if (yych <= '>') goto yy1620; if (yych == '\\') goto yy1619; goto yy1610; } @@ -13648,13 +13681,18 @@ int _scan_link_url(const unsigned char *p) if (yybm[0+yych] & 32) { goto yy1605; } - if (yych <= '\'') { - if (yych <= 0x00) goto yy1608; - if (yych == '\n') goto yy1608; - goto yy1612; + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1608; + goto yy1612; + } else { + if (yych <= '\n') goto yy1608; + if (yych <= '\f') goto yy1612; + goto yy1608; + } } else { if (yych <= ')') { - if (yych <= '(') goto yy1610; + if (yych == '(') goto yy1610; goto yy1612; } else { if (yych <= '=') goto yy1602; @@ -13666,22 +13704,23 @@ int _scan_link_url(const unsigned char *p) yyaccept = 0; marker = ++p; yych = *p; - if (yych <= '(') { + if (yych <= '\'') { if (yych <= '\n') { if (yych <= 0x00) goto yy1588; if (yych <= '\t') goto yy1612; goto yy1588; } else { + if (yych == '\r') goto yy1588; if (yych <= ' ') goto yy1612; - if (yych <= '\'') goto yy1605; - goto yy1610; + goto yy1605; } } else { - if (yych <= '>') { + if (yych <= '=') { + if (yych <= '(') goto yy1610; if (yych <= ')') goto yy1612; - if (yych <= '=') goto yy1605; - goto yy1622; + goto yy1605; } else { + if (yych <= '>') goto yy1622; if (yych == '\\') goto yy1609; goto yy1605; } @@ -13693,7 +13732,7 @@ int _scan_link_url(const unsigned char *p) // 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) +bufsize_t _scan_link_title(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -13779,13 +13818,13 @@ int _scan_link_title(const unsigned char *p) yy1633: p = marker; if (yyaccept <= 1) { - if (yyaccept == 0) { + if (yyaccept <= 0) { goto yy1626; } else { goto yy1637; } } else { - if (yyaccept == 2) { + if (yyaccept <= 2) { goto yy1644; } else { goto yy1651; @@ -13803,7 +13842,7 @@ int _scan_link_title(const unsigned char *p) yy1636: ++p; yy1637: - { return (p - start); } + { return (bufsize_t)(p - start); } yy1638: yyaccept = 1; marker = ++p; @@ -13835,7 +13874,7 @@ int _scan_link_title(const unsigned char *p) yy1643: ++p; yy1644: - { return (p - start); } + { return (bufsize_t)(p - start); } yy1645: yyaccept = 2; marker = ++p; @@ -13867,7 +13906,7 @@ int _scan_link_title(const unsigned char *p) yy1650: ++p; yy1651: - { return (p - start); } + { return (bufsize_t)(p - start); } yy1652: yyaccept = 3; marker = ++p; @@ -13883,7 +13922,7 @@ int _scan_link_title(const unsigned char *p) } // Match space characters, including newlines. -int _scan_spacechars(const unsigned char *p) +bufsize_t _scan_spacechars(const unsigned char *p) { const unsigned char *start = p; \ @@ -13934,7 +13973,7 @@ int _scan_spacechars(const unsigned char *p) goto yy1659; } yy1655: - { return (p - start); } + { return (bufsize_t)(p - start); } yy1656: yych = *++p; goto yy1658; @@ -13954,7 +13993,7 @@ int _scan_spacechars(const unsigned char *p) } // Match ATX header start. -int _scan_atx_header_start(const unsigned char *p) +bufsize_t _scan_atx_header_start(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -14006,16 +14045,21 @@ int _scan_atx_header_start(const unsigned char *p) if (yybm[0+yych] & 128) { goto yy1668; } - if (yych == '\n') goto yy1666; - if (yych == '#') goto yy1670; - goto yy1663; + if (yych <= '\f') { + if (yych == '\n') goto yy1666; + goto yy1663; + } else { + if (yych <= '\r') goto yy1666; + if (yych == '#') goto yy1670; + goto yy1663; + } yy1665: yych = *++p; goto yy1663; yy1666: ++p; yy1667: - { return (p - start); } + { return (bufsize_t)(p - start); } yy1668: ++p; yych = *p; @@ -14028,8 +14072,12 @@ int _scan_atx_header_start(const unsigned char *p) if (yybm[0+yych] & 128) { goto yy1668; } - if (yych == '\n') goto yy1666; - if (yych == '#') goto yy1672; + if (yych <= '\f') { + if (yych == '\n') goto yy1666; + } else { + if (yych <= '\r') goto yy1666; + if (yych == '#') goto yy1672; + } yy1671: p = marker; goto yy1663; @@ -14038,33 +14086,49 @@ int _scan_atx_header_start(const unsigned char *p) if (yybm[0+yych] & 128) { goto yy1668; } - if (yych == '\n') goto yy1666; - if (yych != '#') goto yy1671; + if (yych <= '\f') { + if (yych == '\n') goto yy1666; + goto yy1671; + } else { + if (yych <= '\r') goto yy1666; + if (yych != '#') goto yy1671; + } yych = *++p; if (yybm[0+yych] & 128) { goto yy1668; } - if (yych == '\n') goto yy1666; - if (yych != '#') goto yy1671; + if (yych <= '\f') { + if (yych == '\n') goto yy1666; + goto yy1671; + } else { + if (yych <= '\r') goto yy1666; + if (yych != '#') goto yy1671; + } yych = *++p; if (yybm[0+yych] & 128) { goto yy1668; } - if (yych == '\n') goto yy1666; - if (yych != '#') goto yy1671; + if (yych <= '\f') { + if (yych == '\n') goto yy1666; + goto yy1671; + } else { + if (yych <= '\r') goto yy1666; + if (yych != '#') goto yy1671; + } ++p; if (yybm[0+(yych = *p)] & 128) { goto yy1668; } if (yych == '\n') goto yy1666; + if (yych == '\r') goto yy1666; goto yy1671; } } -// Match sexext header line. Return 1 for level-1 header, +// Match setext 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) +bufsize_t _scan_setext_header_line(const unsigned char *p) { const unsigned char *marker = NULL; @@ -14119,17 +14183,27 @@ int _scan_setext_header_line(const unsigned char *p) if (yybm[0+yych] & 128) { goto yy1693; } - if (yych == '\n') goto yy1691; - if (yych == ' ') goto yy1689; - goto yy1678; + if (yych <= '\f') { + if (yych == '\n') goto yy1691; + goto yy1678; + } else { + if (yych <= '\r') goto yy1691; + if (yych == ' ') goto yy1689; + goto yy1678; + } yy1680: yych = *(marker = ++p); if (yybm[0+yych] & 32) { goto yy1682; } - if (yych == '\n') goto yy1685; - if (yych == '-') goto yy1687; - goto yy1678; + if (yych <= '\f') { + if (yych == '\n') goto yy1685; + goto yy1678; + } else { + if (yych <= '\r') goto yy1685; + if (yych == '-') goto yy1687; + goto yy1678; + } yy1681: yych = *++p; goto yy1678; @@ -14140,6 +14214,7 @@ int _scan_setext_header_line(const unsigned char *p) goto yy1682; } if (yych == '\n') goto yy1685; + if (yych == '\r') goto yy1685; yy1684: p = marker; goto yy1678; @@ -14152,15 +14227,24 @@ int _scan_setext_header_line(const unsigned char *p) if (yybm[0+yych] & 32) { goto yy1682; } - if (yych == '\n') goto yy1685; - if (yych == '-') goto yy1687; - goto yy1684; + if (yych <= '\f') { + if (yych == '\n') goto yy1685; + goto yy1684; + } else { + if (yych <= '\r') goto yy1685; + if (yych == '-') goto yy1687; + goto yy1684; + } yy1689: ++p; yych = *p; - if (yych == '\n') goto yy1691; - if (yych == ' ') goto yy1689; - goto yy1684; + if (yych <= '\f') { + if (yych != '\n') goto yy1684; + } else { + if (yych <= '\r') goto yy1691; + if (yych == ' ') goto yy1689; + goto yy1684; + } yy1691: ++p; { return 1; } @@ -14170,9 +14254,14 @@ int _scan_setext_header_line(const unsigned char *p) if (yybm[0+yych] & 128) { goto yy1693; } - if (yych == '\n') goto yy1691; - if (yych == ' ') goto yy1689; - goto yy1684; + if (yych <= '\f') { + if (yych == '\n') goto yy1691; + goto yy1684; + } else { + if (yych <= '\r') goto yy1691; + if (yych == ' ') goto yy1689; + goto yy1684; + } } } @@ -14180,7 +14269,7 @@ int _scan_setext_header_line(const unsigned char *p) // 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) +bufsize_t _scan_hrule(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -14278,20 +14367,24 @@ int _scan_hrule(const unsigned char *p) if (yybm[0+yych] & 16) { goto yy1707; } - if (yych <= 0x08) goto yy1704; - if (yych <= '\t') goto yy1709; - if (yych <= '\n') goto yy1711; - goto yy1704; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1704; + if (yych >= '\n') goto yy1711; + } else { + if (yych == '\r') goto yy1711; + goto yy1704; + } yy1709: ++p; yych = *p; if (yybm[0+yych] & 32) { goto yy1709; } - if (yych != '\n') goto yy1704; + if (yych == '\n') goto yy1711; + if (yych != '\r') goto yy1704; yy1711: ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } yy1713: ++p; yych = *p; @@ -14308,23 +14401,28 @@ int _scan_hrule(const unsigned char *p) if (yybm[0+yych] & 64) { goto yy1717; } - if (yych <= 0x08) goto yy1704; - if (yych <= '\t') goto yy1719; - if (yych <= '\n') goto yy1721; - goto yy1704; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1704; + if (yych >= '\n') goto yy1721; + } else { + if (yych == '\r') goto yy1721; + goto yy1704; + } yy1719: ++p; yych = *p; - if (yych <= '\n') { + if (yych <= '\f') { if (yych <= 0x08) goto yy1704; if (yych <= '\t') goto yy1719; + if (yych >= '\v') goto yy1704; } else { + if (yych <= '\r') goto yy1721; if (yych == ' ') goto yy1719; goto yy1704; } yy1721: ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } yy1723: ++p; yych = *p; @@ -14341,29 +14439,34 @@ int _scan_hrule(const unsigned char *p) if (yybm[0+yych] & 128) { goto yy1727; } - if (yych <= 0x08) goto yy1704; - if (yych <= '\t') goto yy1729; - if (yych <= '\n') goto yy1731; - goto yy1704; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1704; + if (yych >= '\n') goto yy1731; + } else { + if (yych == '\r') goto yy1731; + goto yy1704; + } yy1729: ++p; yych = *p; - if (yych <= '\n') { + if (yych <= '\f') { if (yych <= 0x08) goto yy1704; if (yych <= '\t') goto yy1729; + if (yych >= '\v') goto yy1704; } else { + if (yych <= '\r') goto yy1731; if (yych == ' ') goto yy1729; goto yy1704; } yy1731: ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } } } // Scan an opening code fence. -int _scan_open_code_fence(const unsigned char *p) +bufsize_t _scan_open_code_fence(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -14372,7 +14475,7 @@ int _scan_open_code_fence(const unsigned char *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, 0, 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, @@ -14454,7 +14557,7 @@ int _scan_open_code_fence(const unsigned char *p) yy1745: ++p; p = marker; - { return (p - start); } + { return (bufsize_t)(p - start); } yy1747: yych = *++p; if (yybm[0+yych] & 64) { @@ -14482,13 +14585,13 @@ int _scan_open_code_fence(const unsigned char *p) yy1752: ++p; p = marker; - { return (p - start); } + { return (bufsize_t)(p - start); } } } // Scan a closing code fence with length at least len. -int _scan_close_code_fence(const unsigned char *p) +bufsize_t _scan_close_code_fence(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -14565,20 +14668,26 @@ int _scan_close_code_fence(const unsigned char *p) if (yybm[0+yych] & 64) { goto yy1764; } - if (yych == '\n') goto yy1766; - if (yych == '~') goto yy1762; - goto yy1761; + if (yych <= '\f') { + if (yych == '\n') goto yy1766; + goto yy1761; + } else { + if (yych <= '\r') goto yy1766; + if (yych == '~') goto yy1762; + goto yy1761; + } yy1764: ++p; yych = *p; if (yybm[0+yych] & 64) { goto yy1764; } - if (yych != '\n') goto yy1761; + if (yych == '\n') goto yy1766; + if (yych != '\r') goto yy1761; yy1766: ++p; p = marker; - { return (p - start); } + { return (bufsize_t)(p - start); } yy1768: yych = *++p; if (yybm[0+yych] & 128) { @@ -14592,33 +14701,38 @@ int _scan_close_code_fence(const unsigned char *p) if (yybm[0+yych] & 128) { goto yy1769; } - if (yych <= '\n') { + if (yych <= '\f') { if (yych <= 0x08) goto yy1761; - if (yych >= '\n') goto yy1773; + if (yych <= '\t') goto yy1771; + if (yych <= '\n') goto yy1773; + goto yy1761; } else { + if (yych <= '\r') goto yy1773; if (yych != ' ') goto yy1761; } yy1771: ++p; yych = *p; - if (yych <= '\n') { + if (yych <= '\f') { if (yych <= 0x08) goto yy1761; if (yych <= '\t') goto yy1771; + if (yych >= '\v') goto yy1761; } else { + if (yych <= '\r') goto yy1773; if (yych == ' ') goto yy1771; goto yy1761; } yy1773: ++p; p = marker; - { return (p - start); } + { return (bufsize_t)(p - start); } } } // Scans an entity. // Returns number of chars matched. -int _scan_entity(const unsigned char *p) +bufsize_t _scan_entity(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -14685,7 +14799,7 @@ int _scan_entity(const unsigned char *p) } yy1784: ++p; - { return (p - start); } + { return (bufsize_t)(p - start); } yy1786: yych = *++p; if (yych <= ';') { diff --git a/scanners.h b/scanners.h index 1353f3b..bc5134e 100644 --- a/scanners.h +++ b/scanners.h @@ -5,21 +5,21 @@ extern "C" { #endif -int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset); -int _scan_scheme(const unsigned char *p); -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); +bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, bufsize_t offset); +bufsize_t _scan_scheme(const unsigned char *p); +bufsize_t _scan_autolink_uri(const unsigned char *p); +bufsize_t _scan_autolink_email(const unsigned char *p); +bufsize_t _scan_html_tag(const unsigned char *p); +bufsize_t _scan_html_block_tag(const unsigned char *p); +bufsize_t _scan_link_url(const unsigned char *p); +bufsize_t _scan_link_title(const unsigned char *p); +bufsize_t _scan_spacechars(const unsigned char *p); +bufsize_t _scan_atx_header_start(const unsigned char *p); +bufsize_t _scan_setext_header_line(const unsigned char *p); +bufsize_t _scan_hrule(const unsigned char *p); +bufsize_t _scan_open_code_fence(const unsigned char *p); +bufsize_t _scan_close_code_fence(const unsigned char *p); +bufsize_t _scan_entity(const unsigned char *p); #define scan_scheme(c, n) _scan_at(&_scan_scheme, c, n) #define scan_autolink_uri(c, n) _scan_at(&_scan_autolink_uri, c, n) diff --git a/scanners.re b/scanners.re index 31cdb4f..3722a99 100644 --- a/scanners.re +++ b/scanners.re @@ -2,9 +2,9 @@ #include "chunk.h" #include "scanners.h" -int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset) +bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, bufsize_t offset) { - int res; + bufsize_t res; unsigned char *ptr = (unsigned char *)c->data; unsigned char lim = ptr[c->len]; @@ -70,29 +70,29 @@ int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset) */ // Try to match a scheme including colon. -int _scan_scheme(const unsigned char *p) +bufsize_t _scan_scheme(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - scheme [:] { return (p - start); } + scheme [:] { return (bufsize_t)(p - start); } .? { return 0; } */ } // Try to match URI autolink after first <, returning number of chars matched. -int _scan_autolink_uri(const unsigned char *p) +bufsize_t _scan_autolink_uri(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - scheme [:][^\x00-\x20<>]*[>] { return (p - start); } + scheme [:][^\x00-\x20<>]*[>] { return (bufsize_t)(p - start); } .? { return 0; } */ } // Try to match email autolink after first <, returning num of chars matched. -int _scan_autolink_email(const unsigned char *p) +bufsize_t _scan_autolink_email(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -101,32 +101,32 @@ int _scan_autolink_email(const unsigned char *p) [@] [a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])? ([.][a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)* - [>] { return (p - start); } + [>] { return (bufsize_t)(p - start); } .? { return 0; } */ } // Try to match an HTML tag after first <, returning num of chars matched. -int _scan_html_tag(const unsigned char *p) +bufsize_t _scan_html_tag(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - htmltag { return (p - start); } + htmltag { return (bufsize_t)(p - start); } .? { return 0; } */ } // Try to match an HTML block tag including first <, // returning num of chars matched. -int _scan_html_block_tag(const unsigned char *p) +bufsize_t _scan_html_block_tag(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - [<] [/] blocktagname (spacechar | [>]) { return (p - start); } - [<] blocktagname (spacechar | [/>]) { return (p - start); } - [<] [!?] { return (p - start); } + [<] [/] blocktagname (spacechar | [>]) { return (bufsize_t)(p - start); } + [<] blocktagname (spacechar | [/>]) { return (bufsize_t)(p - start); } + [<] [!?] { return (bufsize_t)(p - start); } .? { return 0; } */ } @@ -135,13 +135,13 @@ int _scan_html_block_tag(const unsigned char *p) // 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) +bufsize_t _scan_link_url(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - [ \n]* [<] ([^<>\n\\\x00] | escaped_char | [\\])* [>] { return (p - start); } - [ \n]* (reg_char+ | escaped_char | in_parens_nosp)* { return (p - start); } + [ \r\n]* [<] ([^<>\r\n\\\x00] | escaped_char | [\\])* [>] { return (bufsize_t)(p - start); } + [ \r\n]* (reg_char+ | escaped_char | in_parens_nosp)* { return (bufsize_t)(p - start); } .? { return 0; } */ } @@ -149,47 +149,47 @@ int _scan_link_url(const unsigned char *p) // 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) +bufsize_t _scan_link_title(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - ["] (escaped_char|[^"\x00])* ["] { return (p - start); } - ['] (escaped_char|[^'\x00])* ['] { return (p - start); } - [(] (escaped_char|[^)\x00])* [)] { return (p - start); } + ["] (escaped_char|[^"\x00])* ["] { return (bufsize_t)(p - start); } + ['] (escaped_char|[^'\x00])* ['] { return (bufsize_t)(p - start); } + [(] (escaped_char|[^)\x00])* [)] { return (bufsize_t)(p - start); } .? { return 0; } */ } // Match space characters, including newlines. -int _scan_spacechars(const unsigned char *p) +bufsize_t _scan_spacechars(const unsigned char *p) { const unsigned char *start = p; \ /*!re2c - [ \t\v\f\r\n]* { return (p - start); } + [ \t\v\f\r\n]* { return (bufsize_t)(p - start); } . { return 0; } */ } // Match ATX header start. -int _scan_atx_header_start(const unsigned char *p) +bufsize_t _scan_atx_header_start(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - [#]{1,6} ([ ]+|[\n]) { return (p - start); } + [#]{1,6} ([ ]+|[\r\n]) { return (bufsize_t)(p - start); } .? { return 0; } */ } -// Match sexext header line. Return 1 for level-1 header, +// Match setext 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) +bufsize_t _scan_setext_header_line(const unsigned char *p) { const unsigned char *marker = NULL; /*!re2c - [=]+ [ ]* [\n] { return 1; } - [-]+ [ ]* [\n] { return 2; } + [=]+ [ ]* [\r\n] { return 1; } + [-]+ [ ]* [\r\n] { return 2; } .? { return 0; } */ } @@ -197,51 +197,51 @@ int _scan_setext_header_line(const unsigned char *p) // 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) +bufsize_t _scan_hrule(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - ([*][ ]*){3,} [ \t]* [\n] { return (p - start); } - ([_][ ]*){3,} [ \t]* [\n] { return (p - start); } - ([-][ ]*){3,} [ \t]* [\n] { return (p - start); } + ([*][ ]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } + ([_][ ]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } + ([-][ ]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } .? { return 0; } */ } // Scan an opening code fence. -int _scan_open_code_fence(const unsigned char *p) +bufsize_t _scan_open_code_fence(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - [`]{3,} / [^`\n\x00]*[\n] { return (p - start); } - [~]{3,} / [^~\n\x00]*[\n] { return (p - start); } + [`]{3,} / [^`\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); } + [~]{3,} / [^~\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); } .? { return 0; } */ } // Scan a closing code fence with length at least len. -int _scan_close_code_fence(const unsigned char *p) +bufsize_t _scan_close_code_fence(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - [`]{3,} / [ \t]*[\n] { return (p - start); } - [~]{3,} / [ \t]*[\n] { return (p - start); } + [`]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); } + [~]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); } .? { return 0; } */ } // Scans an entity. // Returns number of chars matched. -int _scan_entity(const unsigned char *p) +bufsize_t _scan_entity(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c [&] ([#] ([Xx][A-Fa-f0-9]{1,8}|[0-9]{1,8}) |[A-Za-z][A-Za-z0-9]{1,31} ) [;] - { return (p - start); } + { return (bufsize_t)(p - start); } .? { return 0; } */ } diff --git a/utf8.c b/utf8.c index b83c2a5..ba1d873 100644 --- a/utf8.c +++ b/utf8.c @@ -30,7 +30,7 @@ static void encode_unknown(cmark_strbuf *buf) cmark_strbuf_put(buf, repl, 3); } -static int utf8proc_charlen(const uint8_t *str, int str_len) +static int utf8proc_charlen(const uint8_t *str, bufsize_t str_len) { int length, i; @@ -42,7 +42,7 @@ static int utf8proc_charlen(const uint8_t *str, int str_len) if (!length) return -1; - if (str_len >= 0 && length > str_len) + if (str_len >= 0 && (bufsize_t)length > str_len) return -str_len; for (i = 1; i < length; i++) { @@ -54,7 +54,7 @@ static int utf8proc_charlen(const uint8_t *str, int str_len) } // Validate a single UTF-8 character according to RFC 3629. -static int utf8proc_valid(const uint8_t *str, int str_len) +static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) { int length = utf8proc_charlen(str, str_len); @@ -109,14 +109,14 @@ static int utf8proc_valid(const uint8_t *str, int str_len) return length; } -void utf8proc_detab(cmark_strbuf *ob, const uint8_t *line, size_t size) +void utf8proc_detab(cmark_strbuf *ob, const uint8_t *line, bufsize_t size) { static const uint8_t whitespace[] = " "; - size_t i = 0, tab = 0; + bufsize_t i = 0, tab = 0; while (i < size) { - size_t org = i; + bufsize_t org = i; while (i < size && line[i] != '\t' && line[i] != '\0' && line[i] < 0x80) { @@ -151,7 +151,7 @@ void utf8proc_detab(cmark_strbuf *ob, const uint8_t *line, size_t size) } } -int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst) +int utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst) { int length; int32_t uc = -1; @@ -191,7 +191,7 @@ int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst) void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) { uint8_t dst[4]; - int len = 0; + bufsize_t len = 0; assert(uc >= 0); @@ -227,7 +227,7 @@ void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) cmark_strbuf_put(buf, dst, len); } -void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len) +void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, bufsize_t len) { int32_t c; @@ -235,7 +235,7 @@ void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len) utf8proc_encode_char(x, dest) while (len > 0) { - int char_len = utf8proc_iterate(str, len, &c); + bufsize_t char_len = utf8proc_iterate(str, len, &c); if (char_len >= 0) { #include "case_fold_switch.inc" diff --git a/utf8.h b/utf8.h index 7df1573..ed1d7ee 100644 --- a/utf8.h +++ b/utf8.h @@ -8,10 +8,10 @@ extern "C" { #endif -void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len); +void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, bufsize_t 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_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst); +void utf8proc_detab(cmark_strbuf *dest, const uint8_t *line, bufsize_t size); int utf8proc_is_space(int32_t uc); int utf8proc_is_punctuation(int32_t uc); diff --git a/xml.c b/xml.c index 845e553..7eec5a6 100644 --- a/xml.c +++ b/xml.c @@ -11,14 +11,9 @@ // Functions to convert cmark_nodes to XML strings. -static void escape_xml(cmark_strbuf *dest, const unsigned char *source, int length) +static void escape_xml(cmark_strbuf *dest, const unsigned char *source, bufsize_t length) { - if (source != NULL) { - if (length < 0) - length = strlen((char *)source); - - houdini_escape_html0(dest, source, (size_t)length, 0); - } + houdini_escape_html0(dest, source, length, 0); } struct render_state { @@ -118,10 +113,12 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_LINK: case CMARK_NODE_IMAGE: cmark_strbuf_puts(xml, " destination=\""); - escape_xml(xml, node->as.link.url, -1); + escape_xml(xml, node->as.link.url.data, + node->as.link.url.len); cmark_strbuf_putc(xml, '"'); cmark_strbuf_puts(xml, " title=\""); - escape_xml(xml, node->as.link.title, -1); + escape_xml(xml, node->as.link.title.data, + node->as.link.title.len); cmark_strbuf_putc(xml, '"'); break; default: From 97176b8046f93e83c4f1088ce7e187ebe325b0f3 Mon Sep 17 00:00:00 2001 From: James Adam Date: Tue, 14 Jul 2015 21:37:57 -0400 Subject: [PATCH 13/26] Updated to cmark 0.21.0 --- .travis.yml | 1 - CMakeLists.txt | 175 + blocks.c | 248 +- buffer.c | 20 +- cmark.c | 11 +- cmark.h | 28 +- commonmark.c | 471 +- commonmark.go | 2 +- commonmark_test.go | 4 +- config.h.in | 25 + entities.inc | 2138 ++++ houdini_html_u.c | 44 +- html.c | 40 +- inlines.c | 168 +- latex.c | 430 + man.c | 274 +- node.go | 13 +- node.h | 1 + parser.h | 2 + render.c | 186 + render.h | 66 + scanners.c | 23566 +++++++++++++++++++++++++++---------------- scanners.h | 18 +- scanners.re | 104 +- utf8.c | 81 +- utf8.h | 2 +- 26 files changed, 18493 insertions(+), 9625 deletions(-) create mode 100644 CMakeLists.txt create mode 100644 config.h.in create mode 100644 entities.inc create mode 100644 latex.c create mode 100644 render.c create mode 100644 render.h diff --git a/.travis.yml b/.travis.yml index 114b357..fd5ad9e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,6 @@ # Travis build settings for go-commonmark language: go go: - - 1.3 - 1.4 before_install: - echo "yes" | sudo add-apt-repository ppa:kalakris/cmake diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..eee9316 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,175 @@ +cmake_minimum_required(VERSION 2.8) +set(LIBRARY "libcmark") +set(STATICLIBRARY "libcmark_static") +set(HEADERS + cmark.h + parser.h + buffer.h + node.h + iterator.h + chunk.h + references.h + bench.h + utf8.h + scanners.h + inlines.h + houdini.h + cmark_ctype.h + render.h + ) +set(LIBRARY_SOURCES + cmark.c + node.c + iterator.c + blocks.c + inlines.c + scanners.c + scanners.re + utf8.c + buffer.c + references.c + render.c + man.c + xml.c + html.c + commonmark.c + latex.c + houdini_href_e.c + houdini_html_e.c + houdini_html_u.c + cmark_ctype.c + ${HEADERS} + ) + +set(PROGRAM "cmark") +set(PROGRAM_SOURCES + ${LIBRARY_SOURCES} + main.c + ) + +include_directories(. ${CMAKE_CURRENT_BINARY_DIR}) + +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmark_version.h.in + ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h) + +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc @ONLY) +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc + DESTINATION lib/pkgconfig) + +include (GenerateExportHeader) + +add_executable(${PROGRAM} ${PROGRAM_SOURCES}) +add_compiler_export_flags() + +# Disable the PUBLIC declarations when compiling the executable: +set_target_properties(${PROGRAM} PROPERTIES + COMPILE_FLAGS -DCMARK_STATIC_DEFINE) + +# Check integrity of node structure when compiled as debug: +set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DCMARK_DEBUG_NODES") +set(CMAKE_LINKER_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG}") + +set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -pg") +set(CMAKE_LINKER_PROFILE "${CMAKE_LINKER_FLAGS_RELEASE} -pg") + +if (${CMAKE_MAJOR_VERSION} GREATER 1 AND ${CMAKE_MINOR_VERSION} GREATER 8) + set(CMAKE_C_VISIBILITY_PRESET hidden) + set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) +elseif(CMAKE_COMPILER_IS_GNUCC OR ${CMAKE_C_COMPILER_ID} STREQUAL "Clang") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") +endif () + +add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES}) +add_library(${STATICLIBRARY} STATIC ${LIBRARY_SOURCES}) +# Include minor version and patch level in soname for now. +set_target_properties(${LIBRARY} PROPERTIES + OUTPUT_NAME "cmark" + SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH} + VERSION ${PROJECT_VERSION}) +set_target_properties(${STATICLIBRARY} PROPERTIES + COMPILE_FLAGS -DCMARK_STATIC_DEFINE) + +if (MSVC) + set_target_properties(${STATICLIBRARY} PROPERTIES + OUTPUT_NAME "cmark_static" + VERSION ${PROJECT_VERSION}) +else() + set_target_properties(${STATICLIBRARY} PROPERTIES + OUTPUT_NAME "cmark" + VERSION ${PROJECT_VERSION}) +endif(MSVC) + +set_property(TARGET ${LIBRARY} + APPEND PROPERTY MACOSX_RPATH true) + +generate_export_header(${LIBRARY} + BASE_NAME ${PROJECT_NAME}) + +if (MSVC) + set_property(TARGET ${PROGRAM} + APPEND PROPERTY LINK_FLAGS /INCREMENTAL:NO) +endif(MSVC) + +set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON) +include (InstallRequiredSystemLibraries) +install(TARGETS ${PROGRAM} ${LIBRARY} + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ) + +install(FILES + cmark.h + ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h + ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h + DESTINATION include + ) + +# Feature tests +include(CheckIncludeFile) +include(CheckCSourceCompiles) +include(CheckCSourceRuns) +include(CheckSymbolExists) +CHECK_INCLUDE_FILE(stdbool.h HAVE_STDBOOL_H) +CHECK_C_SOURCE_COMPILES( + "int main() { __builtin_expect(0,0); return 0; }" + HAVE___BUILTIN_EXPECT) +CHECK_C_SOURCE_COMPILES(" + int f(void) __attribute__ (()); + int main() { return 0; } +" HAVE___ATTRIBUTE__) +CHECK_C_SOURCE_RUNS(" + #include + int main() { return snprintf(NULL, 0, \"123\") == 3 ? 0 : 1; } +" HAVE_C99_SNPRINTF) +CHECK_SYMBOL_EXISTS(va_copy stdarg.h HAVE_VA_COPY) + +CONFIGURE_FILE( + ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in + ${CMAKE_CURRENT_BINARY_DIR}/config.h) + +# Always compile with warnings +if(MSVC) + # Force to always compile with W4 + if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") + else() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4") + endif() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127 /wd4244 /wd4267 /wd4706 /wd4800 /D_CRT_SECURE_NO_WARNINGS") +elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=c99 -pedantic") +endif() + +# Compile as C++ under MSVC +if(MSVC) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /TP") +endif() + +if($ENV{TIMER}) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DTIMER=1") +endif($ENV{TIMER}) + +if(CMAKE_BUILD_TYPE STREQUAL "Ubsan") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined") +endif() diff --git a/blocks.c b/blocks.c index a3ac712..f8b7495 100644 --- a/blocks.c +++ b/blocks.c @@ -13,9 +13,10 @@ #include "inlines.h" #include "houdini.h" #include "buffer.h" -#include "debug.h" #define CODE_INDENT 4 +#define TAB_STOP 4 + #define peek_at(i, n) (i)->data[n] static inline bool @@ -70,7 +71,9 @@ cmark_parser *cmark_parser_new(int options) parser->current = document; parser->line_number = 0; parser->offset = 0; + parser->column = 0; parser->first_nonspace = 0; + parser->first_nonspace_column = 0; parser->indent = 0; parser->blank = false; parser->curline = line; @@ -105,6 +108,9 @@ static bool is_blank(cmark_strbuf *s, bufsize_t offset) case ' ': offset++; break; + case '\t': + offset++; + break; default: return false; } @@ -394,11 +400,16 @@ static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos, cmark_list } } else if (cmark_isdigit(c)) { int start = 0; + int digits = 0; do { start = (10 * start) + (peek_at(input, pos) - '0'); pos++; - } while (cmark_isdigit(peek_at(input, pos))); + digits++; + // We limit to 9 digits to avoid overflow, + // assuming max int is 2^31 - 1 + // This also seems to be the limit for 'start' in some browsers. + } while (digits < 9 && cmark_isdigit(peek_at(input, pos))); c = peek_at(input, pos); if (c == '.' || c == ')') { @@ -493,44 +504,52 @@ S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len, bool eof) { const unsigned char *end = buffer + len; + static const uint8_t repl[] = {239, 191, 189}; while (buffer < end) { const unsigned char *eol; - size_t line_len; - bufsize_t bufsize; - + bufsize_t chunk_len; + bool process = false; for (eol = buffer; eol < end; ++eol) { - if (S_is_line_end_char(*eol)) + if (S_is_line_end_char(*eol)) { + if (eol < end && *eol == '\r') + eol++; + if (eol < end && *eol == '\n') + eol++; + process = true; break; + } + if (*eol == '\0' && eol < end) { + break; + } } - if (eol >= end) - eol = NULL; - - if (eol) { - if (eol < end && *eol == '\r') - eol++; - if (eol < end && *eol == '\n') - eol++; - line_len = eol - buffer; - } else if (eof) { - line_len = end - buffer; - } else { - bufsize = cmark_strbuf_check_bufsize(end - buffer); - cmark_strbuf_put(parser->linebuf, buffer, bufsize); - break; + if (eol >= end && eof) { + process = true; } - bufsize = cmark_strbuf_check_bufsize(line_len); - if (parser->linebuf->size > 0) { - cmark_strbuf_put(parser->linebuf, buffer, bufsize); - S_process_line(parser, parser->linebuf->ptr, - parser->linebuf->size); - cmark_strbuf_clear(parser->linebuf); + chunk_len = cmark_strbuf_check_bufsize(eol - buffer); + if (process) { + if (parser->linebuf->size > 0) { + cmark_strbuf_put(parser->linebuf, buffer, chunk_len); + S_process_line(parser, parser->linebuf->ptr, + parser->linebuf->size); + cmark_strbuf_clear(parser->linebuf); + } else { + S_process_line(parser, buffer, chunk_len); + } } else { - S_process_line(parser, buffer, bufsize); + if (eol < end && *eol == '\0') { + // omit NULL byte + cmark_strbuf_put(parser->linebuf, buffer, chunk_len); + // add replacement character + cmark_strbuf_put(parser->linebuf, repl, 3); + chunk_len += 1; // so we advance the buffer past NULL + } else { + cmark_strbuf_put(parser->linebuf, buffer, chunk_len); + } } - buffer += line_len; + buffer += chunk_len; } } @@ -555,15 +574,52 @@ static void chop_trailing_hashtags(cmark_chunk *ch) static void S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input) { + char c; + int chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); + parser->first_nonspace = parser->offset; - while (peek_at(input, parser->first_nonspace) == ' ') { - parser->first_nonspace++; + parser->first_nonspace_column = parser->column; + while ((c = peek_at(input, parser->first_nonspace))) { + if (c == ' ') { + parser->first_nonspace += 1; + parser->first_nonspace_column += 1; + chars_to_tab = chars_to_tab - 1; + if (chars_to_tab == 0) { + chars_to_tab = TAB_STOP; + } + } else if (c == '\t') { + parser->first_nonspace += 1; + parser->first_nonspace_column += chars_to_tab; + chars_to_tab = TAB_STOP; + } else { + break; + } } - parser->indent = parser->first_nonspace - parser->offset; + parser->indent = parser->first_nonspace_column - parser->column; parser->blank = S_is_line_end_char(peek_at(input, parser->first_nonspace)); } +static void +S_advance_offset(cmark_parser *parser, cmark_chunk *input, bufsize_t count, bool columns) +{ + char c; + int chars_to_tab; + while (count > 0 && (c = peek_at(input, parser->offset))) { + if (c == '\t') { + chars_to_tab = 4 - (parser->column % TAB_STOP); + parser->column += chars_to_tab; + parser->offset += 1; + count -= (columns ? chars_to_tab : 1); + } else { + parser->offset += 1; + parser->column += 1; // assume ascii; block starts are ascii + count -= 1; + } + } +} + + static void S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t bytes) { @@ -578,17 +634,15 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte cmark_chunk input; bool maybe_lazy; - utf8proc_detab(parser->curline, buffer, bytes); + if (parser->options & CMARK_OPT_VALIDATE_UTF8) { + utf8proc_check(parser->curline, buffer, bytes); + } else { + cmark_strbuf_put(parser->curline, buffer, bytes); + } parser->offset = 0; + parser->column = 0; parser->blank = false; - // Add a newline to the end if not present: - // TODO this breaks abstraction: - if (parser->curline->size > 0 && - !S_is_line_end_char(parser->curline->ptr[parser->curline->size - 1])) { - cmark_strbuf_putc(parser->curline, '\n'); - } - input.data = parser->curline->ptr; input.len = parser->curline->size; @@ -608,7 +662,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte if (container->type == NODE_BLOCK_QUOTE) { matched = parser->indent <= 3 && peek_at(&input, parser->first_nonspace) == '>'; if (matched) { - parser->offset = parser->first_nonspace + 1; + S_advance_offset(parser, &input, parser->indent + 1, true); if (peek_at(&input, parser->offset) == ' ') parser->offset++; } else { @@ -616,13 +670,14 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte } } else if (container->type == NODE_ITEM) { - if (parser->indent >= container->as.list.marker_offset + container->as.list.padding) { - parser->offset += container->as.list.marker_offset + - container->as.list.padding; + S_advance_offset(parser, &input, + container->as.list.marker_offset + + container->as.list.padding, true); } else if (parser->blank) { - parser->offset = parser->first_nonspace; + S_advance_offset(parser, &input, + parser->first_nonspace - parser->offset, false); } else { all_matched = false; } @@ -631,9 +686,11 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte if (!container->as.code.fenced) { // indented if (parser->indent >= CODE_INDENT) { - parser->offset += CODE_INDENT; + S_advance_offset(parser, &input, CODE_INDENT, true); } else if (parser->blank) { - parser->offset = parser->first_nonspace; + S_advance_offset(parser, &input, + parser->first_nonspace - parser->offset, + false); } else { all_matched = false; } @@ -649,7 +706,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte // closing fence - and since we're at // the end of a line, we can return: all_matched = false; - parser->offset += matched; + S_advance_offset(parser, &input, matched, false); parser->current = finalize(parser, container); goto finished; } else { @@ -657,7 +714,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte i = container->as.code.fence_offset; while (i > 0 && peek_at(&input, parser->offset) == ' ') { - parser->offset++; + S_advance_offset(parser, &input, 1, false); i--; } } @@ -669,8 +726,26 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte } else if (container->type == NODE_HTML) { - if (parser->blank) { - all_matched = false; + switch (container->as.html_block_type) { + case 1: + case 2: + case 3: + case 4: + case 5: + // these types of blocks can accept blanks + break; + case 6: + case 7: + if (parser->blank) { + all_matched = false; + } + break; + default: + fprintf(stderr, + "Error (%s:%d): Unknown HTML block type %d\n", + __FILE__, __LINE__, + container->as.html_block_type); + exit(1); } } else if (container->type == NODE_PARAGRAPH) { @@ -704,15 +779,16 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte if (!indented && peek_at(&input, parser->first_nonspace) == '>') { - parser->offset = parser->first_nonspace + 1; + S_advance_offset(parser, &input, parser->first_nonspace + 1 - parser->offset, false); // optional following character if (peek_at(&input, parser->offset) == ' ') - parser->offset++; + S_advance_offset(parser, &input, 1, false); container = add_child(parser, container, NODE_BLOCK_QUOTE, parser->offset + 1); } else if (!indented && (matched = scan_atx_header_start(&input, parser->first_nonspace))) { - parser->offset = parser->first_nonspace + matched; + S_advance_offset(parser, &input, + parser->first_nonspace + matched - parser->offset, false); container = add_child(parser, container, NODE_HEADER, parser->offset + 1); bufsize_t hashpos = cmark_chunk_strchr(&input, '#', parser->first_nonspace); @@ -733,11 +809,15 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte container->as.code.fence_length = matched; container->as.code.fence_offset = parser->first_nonspace - parser->offset; container->as.code.info = cmark_chunk_literal(""); - parser->offset = parser->first_nonspace + matched; + S_advance_offset(parser, &input, parser->first_nonspace + matched - parser->offset, false); - } else if (!indented && (matched = scan_html_block_tag(&input, parser->first_nonspace))) { + } else if (!indented && + ((matched = scan_html_block_start(&input, parser->first_nonspace)) || + (container->type != NODE_PARAGRAPH && + (matched = scan_html_block_start_7(&input, parser->first_nonspace))))) { container = add_child(parser, container, NODE_HTML, parser->first_nonspace + 1); + container->as.html_block_type = matched; // note, we don't adjust parser->offset because the tag is part of the text } else if (!indented && @@ -750,7 +830,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte container->type = NODE_HEADER; container->as.header.level = lev; container->as.header.setext = true; - parser->offset = input.len - 1; + S_advance_offset(parser, &input, input.len - 1 - parser->offset, false); } else if (!indented && !(container->type == NODE_PARAGRAPH && @@ -760,7 +840,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte // it's only now that we know the line is not part of a setext header: container = add_child(parser, container, NODE_HRULE, parser->first_nonspace + 1); container = finalize(parser, container); - parser->offset = input.len - 1; + S_advance_offset(parser, &input, input.len - 1 - parser->offset, false); } else if ((matched = parse_list_marker(&input, parser->first_nonspace, &data)) && (!indented || container->type == NODE_LIST)) { @@ -768,7 +848,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte // spaces indent, as long as the list container is still open. // compute padding: - parser->offset = parser->first_nonspace + matched; + S_advance_offset(parser, &input, parser->first_nonspace + matched - parser->offset, false); i = 0; while (i <= 5 && peek_at(&input, parser->offset + i) == ' ') { i++; @@ -778,11 +858,11 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte S_is_line_end_char(peek_at(&input, parser->offset))) { data->padding = matched + 1; if (i > 0) { - parser->offset += 1; + S_advance_offset(parser, &input, 1, false); } } else { data->padding = matched + i; - parser->offset += i; + S_advance_offset(parser, &input, i, true); } // check container; if it's a list, see if this list item @@ -806,7 +886,7 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte free(data); } else if (indented && !maybe_lazy && !parser->blank) { - parser->offset += CODE_INDENT; + S_advance_offset(parser, &input, CODE_INDENT, true); container = add_child(parser, container, NODE_CODE_BLOCK, parser->offset + 1); container->as.code.fenced = false; container->as.code.fence_char = 0; @@ -869,11 +949,51 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte assert(parser->current != NULL); } - if (container->type == NODE_CODE_BLOCK || - container->type == NODE_HTML) { + if (container->type == NODE_CODE_BLOCK) { + + add_line(container, &input, parser->offset); + + } else if (container->type == NODE_HTML) { add_line(container, &input, parser->offset); + int matches_end_condition; + switch (container->as.html_block_type) { + case 1: + // , , + matches_end_condition = + scan_html_block_end_1(&input, parser->first_nonspace); + break; + case 2: + // --> + matches_end_condition = + scan_html_block_end_2(&input, parser->first_nonspace); + break; + case 3: + // ?> + matches_end_condition = + scan_html_block_end_3(&input, parser->first_nonspace); + break; + case 4: + // > + matches_end_condition = + scan_html_block_end_4(&input, parser->first_nonspace); + break; + case 5: + // ]]> + matches_end_condition = + scan_html_block_end_5(&input, parser->first_nonspace); + break; + default: + matches_end_condition = 0; + break; + } + + if (matches_end_condition) { + container = finalize(parser, container); + assert(parser->current != NULL); + } + } else if (parser->blank) { // ??? do nothing diff --git a/buffer.c b/buffer.c index 7d16af8..e07fba6 100644 --- a/buffer.c +++ b/buffer.c @@ -29,18 +29,20 @@ void cmark_strbuf_init(cmark_strbuf *buf, bufsize_t initial_size) cmark_strbuf_grow(buf, initial_size); } -void cmark_strbuf_overflow_err() { +void cmark_strbuf_overflow_err() +{ fprintf(stderr, "String buffer overflow"); abort(); } static inline void -S_strbuf_grow_by(cmark_strbuf *buf, size_t add) { +S_strbuf_grow_by(cmark_strbuf *buf, size_t add) +{ size_t target_size = (size_t)buf->size + add; if (target_size < add /* Integer overflow. */ || target_size > BUFSIZE_MAX /* Truncation overflow. */ - ) { + ) { cmark_strbuf_overflow_err(); return; /* unreachable */ } @@ -74,7 +76,7 @@ void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) if (new_size < (size_t)target_size /* Integer overflow. */ || new_size > BUFSIZE_MAX /* Truncation overflow. */ - ) { + ) { if (target_size >= BUFSIZE_MAX) { /* No space for terminating null byte. */ cmark_strbuf_overflow_err(); @@ -160,7 +162,7 @@ void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, bufsize_t le void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) { cmark_strbuf_put(buf, (const unsigned char *)string, - cmark_strbuf_safe_strlen(string)); + cmark_strbuf_safe_strlen(string)); } void cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap) @@ -175,10 +177,10 @@ void cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap) va_copy(args, ap); int len = vsnprintf( - (char *)buf->ptr + buf->size, - buf->asize - buf->size, - format, args - ); + (char *)buf->ptr + buf->size, + buf->asize - buf->size, + format, args + ); #ifndef HAVE_C99_SNPRINTF // Assume we're on Windows. if (len < 0) { diff --git a/cmark.c b/cmark.c index 35765b1..ca9807b 100644 --- a/cmark.c +++ b/cmark.c @@ -6,8 +6,15 @@ #include "cmark.h" #include "buffer.h" -const int cmark_version = CMARK_VERSION; -const char cmark_version_string[] = CMARK_VERSION_STRING; +int cmark_version() +{ + return CMARK_VERSION; +} + +const char *cmark_version_string() +{ + return CMARK_VERSION_STRING; +} char *cmark_markdown_to_html(const char *text, size_t len, int options) { diff --git a/cmark.h b/cmark.h index a7670e9..4a85f26 100644 --- a/cmark.h +++ b/cmark.h @@ -2,8 +2,8 @@ #define CMARK_H #include -#include "cmark_export.h" -#include "cmark_version.h" +#include +#include #ifdef __cplusplus extern "C" { @@ -479,13 +479,18 @@ 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); +char *cmark_render_man(cmark_node *root, int options, int width); /** Render a 'node' tree as a commonmark document. */ CMARK_EXPORT char *cmark_render_commonmark(cmark_node *root, int options, int width); +/** Render a 'node' tree as a LaTeX document. + */ +CMARK_EXPORT +char *cmark_render_latex(cmark_node *root, int options, int width); + /** Default writer options. */ #define CMARK_OPT_DEFAULT 0 @@ -506,6 +511,19 @@ char *cmark_render_commonmark(cmark_node *root, int options, int width); */ #define CMARK_OPT_SMART 8 +/** Validate UTF-8 in the input before parsing, replacing illegal + * sequences with the replacement character U+FFFD. + */ +#define CMARK_OPT_VALIDATE_UTF8 16 + +/** Suppress raw HTML and unsafe links (`javascript:`, `vbscript:`, + * `file:`, and `data:`, except for `image/png`, `image/gif`, + * `image/jpeg`, or `image/webp` mime types). Raw HTML is replaced + * by a placeholder HTML comment. Unsafe links are replaced by + * empty strings. + */ +#define CMARK_OPT_SAFE 32 + /** * ## Version information */ @@ -520,13 +538,13 @@ char *cmark_render_commonmark(cmark_node *root, int options, int width); * In hexadecimal format, the number 0x010203 represents version 1.2.3. */ CMARK_EXPORT -extern const int cmark_version; +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[]; +const char *cmark_version_string(); /** # AUTHORS * diff --git a/commonmark.c b/commonmark.c index 4594748..0f4c2bc 100644 --- a/commonmark.c +++ b/commonmark.c @@ -10,192 +10,63 @@ #include "buffer.h" #include "utf8.h" #include "scanners.h" +#include "render.h" -// Functions to convert cmark_nodes to commonmark strings. - -struct render_state { - int options; - cmark_strbuf* buffer; - cmark_strbuf* prefix; - int column; - int width; - int need_cr; - bufsize_t last_breakable; - bool begin_line; - bool no_wrap; - bool in_tight_list_item; -}; - -static inline void cr(struct render_state *state) -{ - if (state->need_cr < 1) { - state->need_cr = 1; - } -} +#define safe_strlen(s) cmark_strbuf_safe_strlen(s) +#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping) +#define LIT(s) renderer->out(renderer, s, false, LITERAL) +#define CR() renderer->cr(renderer) +#define BLANKLINE() renderer->blankline(renderer) -static inline void blankline(struct render_state *state) -{ - if (state->need_cr < 2) { - state->need_cr = 2; - } -} - -typedef enum { - LITERAL, - NORMAL, - TITLE, - URL -} escaping; - -static inline bool -needs_escaping(escaping escape, - int32_t c, - unsigned char next_c, - struct render_state *state) -{ - if (escape == NORMAL) { - return (c == '*' || c == '_' || c == '[' || c == ']' || - c == '<' || c == '>' || c == '\\' || c == '`' || - (c == '&' && isalpha(next_c)) || - (c == '!' && next_c == '[') || - (state->begin_line && - (c == '-' || c == '+' || c == '#' || c == '=')) || - (c == '#' && (isspace(next_c) || next_c == '\0')) || - ((c == '.' || c == ')') && - isdigit(state->buffer->ptr[state->buffer->size - 1]))); - } else if (escape == TITLE) { - return (c == '`' || c == '<' || c == '>' || c == '"' || - c == '\\'); - } else if (escape == URL) { - return (c == '`' || c == '<' || c == '>' || isspace(c) || - c == '\\' || c == ')' || c == '('); - } else { - return false; - } -} +// Functions to convert cmark_nodes to commonmark strings. -static inline void out(struct render_state *state, - cmark_chunk str, - bool wrap, - escaping escape) +static inline void outc(cmark_renderer *renderer, + cmark_escaping escape, + int32_t c, + unsigned char nextc) { - unsigned char* source = str.data; - int length = str.len; - unsigned char nextc; - int32_t c; - int i = 0; - int len; - cmark_chunk remainder = cmark_chunk_literal(""); - int k = state->buffer->size - 1; - - wrap = wrap && !state->no_wrap; - - if (state->in_tight_list_item && state->need_cr > 1) { - state->need_cr = 1; - } - while (state->need_cr) { - if (k < 0 || state->buffer->ptr[k] == '\n') { - k -= 1; + bool needs_escaping = false; + needs_escaping = + escape != LITERAL && + ((escape == NORMAL && + (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || + c == '<' || c == '>' || c == '\\' || c == '`' || c == '!' || + (c == '&' && isalpha(nextc)) || + (c == '!' && nextc == '[') || + (renderer->begin_line && + (c == '-' || c == '+' || c == '=')) || + ((c == '.' || c == ')') && + isdigit(renderer->buffer->ptr[renderer->buffer->size - 1])))) || + (escape == URL && + (c == '`' || c == '<' || c == '>' || isspace(c) || + c == '\\' || c == ')' || c == '(')) || + (escape == TITLE && + (c == '`' || c == '<' || c == '>' || c == '"' || + c == '\\'))); + + if (needs_escaping) { + if (isspace(c)) { + // use percent encoding for spaces + cmark_strbuf_printf(renderer->buffer, "%%%2x", c); + renderer->column += 3; } else { - cmark_strbuf_putc(state->buffer, '\n'); - if (state->need_cr > 1) { - cmark_strbuf_put(state->buffer, state->prefix->ptr, - state->prefix->size); - } - } - state->column = 0; - state->begin_line = true; - state->need_cr -= 1; - } - - while (i < length) { - if (state->begin_line) { - cmark_strbuf_put(state->buffer, state->prefix->ptr, - state->prefix->size); - // note: this assumes prefix is ascii: - state->column = state->prefix->size; - } - - len = utf8proc_iterate(source + i, length - i, &c); - if (len == -1) { // error condition - return; // return without rendering rest of string + cmark_render_ascii(renderer, "\\"); + cmark_render_code_point(renderer, c); } - nextc = source[i + len]; - if (c == 32 && wrap) { - if (!state->begin_line) { - cmark_strbuf_putc(state->buffer, ' '); - state->column += 1; - state->begin_line = false; - state->last_breakable = state->buffer->size - - 1; - // skip following spaces - while (source[i + 1] == ' ') { - i++; - } - } - - } else if (c == 10) { - cmark_strbuf_putc(state->buffer, '\n'); - state->column = 0; - state->begin_line = true; - state->last_breakable = 0; - } else if (needs_escaping(escape, c, nextc, state)) { - if (isspace(c)) { - // use percent encoding for spaces - cmark_strbuf_printf(state->buffer, "%%%2x", c); - state->column += 3; - } else { - cmark_strbuf_putc(state->buffer, '\\'); - utf8proc_encode_char(c, state->buffer); - state->column += 2; - } - state->begin_line = false; - } else { - utf8proc_encode_char(c, state->buffer); - state->column += 1; - state->begin_line = false; - } - - // If adding the character went beyond width, look for an - // earlier place where the line could be broken: - if (state->width > 0 && - state->column > state->width && - !state->begin_line && - state->last_breakable > 0) { - - // copy from last_breakable to remainder - cmark_chunk_set_cstr(&remainder, (char *) state->buffer->ptr + state->last_breakable + 1); - // truncate at last_breakable - cmark_strbuf_truncate(state->buffer, state->last_breakable); - // add newline, prefix, and remainder - cmark_strbuf_putc(state->buffer, '\n'); - cmark_strbuf_put(state->buffer, state->prefix->ptr, - state->prefix->size); - cmark_strbuf_put(state->buffer, remainder.data, remainder.len); - state->column = state->prefix->size + remainder.len; - cmark_chunk_free(&remainder); - state->last_breakable = 0; - state->begin_line = false; - } - - i += len; + } else { + cmark_render_code_point(renderer, c); } } -static void lit(struct render_state *state, char *s, bool wrap) -{ - cmark_chunk str = cmark_chunk_literal(s); - out(state, str, wrap, LITERAL); -} - static int -longest_backtick_sequence(cmark_chunk *code) +longest_backtick_sequence(const char *code) { int longest = 0; int current = 0; - int i = 0; - while (i <= code->len) { - if (code->data[i] == '`') { + size_t i = 0; + size_t code_len = safe_strlen(code); + while (i <= code_len) { + if (code[i] == '`') { current++; } else { if (current > longest) { @@ -209,13 +80,14 @@ longest_backtick_sequence(cmark_chunk *code) } static int -shortest_unused_backtick_sequence(cmark_chunk *code) +shortest_unused_backtick_sequence(const char *code) { int32_t used = 1; int current = 0; - int i = 0; - while (i <= code->len) { - if (code->data[i] == '`') { + size_t i = 0; + size_t code_len = safe_strlen(code); + while (i <= code_len) { + if (code[i] == '`') { current++; } else { if (current) { @@ -240,6 +112,8 @@ is_autolink(cmark_node *node) cmark_chunk *title; cmark_chunk *url; cmark_node *link_text; + char *realurl; + int realurllen; if (node->type != CMARK_NODE_LINK) { return false; @@ -258,8 +132,14 @@ is_autolink(cmark_node *node) link_text = node->first_child; cmark_consolidate_text_nodes(link_text); - return (url->len == link_text->as.literal.len && - strncmp((char*)url->data, + realurl = (char*)url->data; + realurllen = url->len; + if (strncmp(realurl, "mailto:", 7) == 0) { + realurl += 7; + realurllen -= 7; + } + return (realurllen == link_text->as.literal.len && + strncmp(realurl, (char*)link_text->as.literal.data, link_text->as.literal.len) == 0); } @@ -278,18 +158,19 @@ get_containing_block(cmark_node *node) } static int -S_render_node(cmark_node *node, cmark_event_type ev_type, - struct render_state *state) +S_render_node(cmark_renderer *renderer, + cmark_node *node, + cmark_event_type ev_type, + int options) { cmark_node *tmp; - cmark_chunk *code; int list_number; cmark_delim_type list_delim; int numticks; int i; bool entering = (ev_type == CMARK_EVENT_ENTER); - cmark_chunk *info; - cmark_chunk *title; + const char *info, *code, *title; + size_t info_len, code_len; cmark_strbuf listmarker = GH_BUF_INIT; char *emph_delim; bufsize_t marker_width; @@ -300,7 +181,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && entering)) { tmp = get_containing_block(node); - state->in_tight_list_item = + renderer->in_tight_list_item = (tmp->type == CMARK_NODE_ITEM && cmark_node_get_list_tight(tmp->parent)) || (tmp && @@ -311,19 +192,16 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, switch (node->type) { case CMARK_NODE_DOCUMENT: - if (!entering) { - cmark_strbuf_putc(state->buffer, '\n'); - } break; case CMARK_NODE_BLOCK_QUOTE: if (entering) { - lit(state, "> ", false); - cmark_strbuf_puts(state->prefix, "> "); + LIT("> "); + cmark_strbuf_puts(renderer->prefix, "> "); } else { - cmark_strbuf_truncate(state->prefix, - state->prefix->size - 2); - blankline(state); + cmark_strbuf_truncate(renderer->prefix, + renderer->prefix->size - 2); + BLANKLINE(); } break; @@ -333,8 +211,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, node->next->type == CMARK_NODE_LIST)) { // this ensures 2 blank lines after list, // if before code block or list: - lit(state, "\n", false); - state->need_cr = 0; + LIT("\n"); } break; @@ -363,19 +240,19 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, if (entering) { if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { - lit(state, "* ", false); - cmark_strbuf_puts(state->prefix, " "); + LIT("* "); + cmark_strbuf_puts(renderer->prefix, " "); } else { - lit(state, (char *)listmarker.ptr, false); + LIT((char *)listmarker.ptr); for (i = marker_width; i--;) { - cmark_strbuf_putc(state->prefix, ' '); + cmark_strbuf_putc(renderer->prefix, ' '); } } } else { - cmark_strbuf_truncate(state->prefix, - state->prefix->size - + cmark_strbuf_truncate(renderer->prefix, + renderer->prefix->size - marker_width); - cr(state); + CR(); } cmark_strbuf_free(&listmarker); break; @@ -383,119 +260,123 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_HEADER: if (entering) { for (int i = cmark_node_get_header_level(node); i > 0; i--) { - lit(state, "#", false); + LIT("#"); } - lit(state, " ", false); - state->no_wrap = true; + LIT(" "); + renderer->no_wrap = true; } else { - state->no_wrap = false; - blankline(state); + renderer->no_wrap = false; + BLANKLINE(); } break; case CMARK_NODE_CODE_BLOCK: - blankline(state); - info = &node->as.code.info; - code = &node->as.code.literal; + BLANKLINE(); + info = cmark_node_get_fence_info(node); + info_len = safe_strlen(info); + code = cmark_node_get_literal(node); + code_len = safe_strlen(code); // use indented form if no info, and code doesn't // begin or end with a blank line, and code isn't // first thing in a list item - if (info->len == 0 && - (code->len > 2 && - !isspace(code->data[0]) && - !(isspace(code->data[code->len - 1]) && - isspace(code->data[code->len - 2]))) && + if (info_len == 0 && + (code_len > 2 && + !isspace(code[0]) && + !(isspace(code[code_len - 1]) && + isspace(code[code_len - 2]))) && !(node->prev == NULL && node->parent && node->parent->type == CMARK_NODE_ITEM)) { - lit(state, " ", false); - cmark_strbuf_puts(state->prefix, " "); - out(state, node->as.code.literal, false, LITERAL); - cmark_strbuf_truncate(state->prefix, - state->prefix->size - 4); + LIT(" "); + cmark_strbuf_puts(renderer->prefix, " "); + OUT(cmark_node_get_literal(node), false, LITERAL); + cmark_strbuf_truncate(renderer->prefix, + renderer->prefix->size - 4); } else { numticks = longest_backtick_sequence(code) + 1; if (numticks < 3) { numticks = 3; } for (i = 0; i < numticks; i++) { - lit(state, "`", false); + LIT("`"); } - lit(state, " ", false); - out(state, *info, false, LITERAL); - cr(state); - out(state, node->as.code.literal, false, LITERAL); - cr(state); + LIT(" "); + OUT(info, false, LITERAL); + CR(); + OUT(cmark_node_get_literal(node), false, LITERAL); + CR(); for (i = 0; i < numticks; i++) { - lit(state, "`", false); + LIT("`"); } } - blankline(state); + BLANKLINE(); break; case CMARK_NODE_HTML: - blankline(state); - out(state, node->as.literal, false, LITERAL); - blankline(state); + BLANKLINE(); + OUT(cmark_node_get_literal(node), false, LITERAL); + BLANKLINE(); break; case CMARK_NODE_HRULE: - blankline(state); - lit(state, "-----", false); - blankline(state); + BLANKLINE(); + LIT("-----"); + BLANKLINE(); break; case CMARK_NODE_PARAGRAPH: if (!entering) { - blankline(state); + BLANKLINE(); } break; case CMARK_NODE_TEXT: - out(state, node->as.literal, true, NORMAL); + OUT(cmark_node_get_literal(node), true, NORMAL); break; case CMARK_NODE_LINEBREAK: - if (!(CMARK_OPT_HARDBREAKS & state->options)) { - lit(state, "\\", false); + if (!(CMARK_OPT_HARDBREAKS & options)) { + LIT("\\"); } - cr(state); + CR(); break; case CMARK_NODE_SOFTBREAK: - if (state->width == 0) { - cr(state); + if (renderer->width == 0 && + !(CMARK_OPT_HARDBREAKS & options)) { + CR(); } else { - lit(state, " ", true); + OUT(" ", true, LITERAL); } break; case CMARK_NODE_CODE: - code = &node->as.literal; + code = cmark_node_get_literal(node); + code_len = safe_strlen(code); numticks = shortest_unused_backtick_sequence(code); for (i = 0; i < numticks; i++) { - lit(state, "`", false); + LIT("`"); } - if (code->len == 0 || code->data[0] == '`') { - lit(state, " ", false); + if (code_len == 0 || code[0] == '`') { + LIT(" "); } - out(state, node->as.literal, true, LITERAL); - if (code->len == 0 || code->data[code->len - 1] == '`') { - lit(state, " ", false); + OUT(cmark_node_get_literal(node), true, LITERAL); + if (code_len == 0 || code[code_len - 1] == '`') { + LIT(" "); } for (i = 0; i < numticks; i++) { - lit(state, "`", false); + LIT("`"); } break; case CMARK_NODE_INLINE_HTML: - out(state, node->as.literal, false, LITERAL); + OUT(cmark_node_get_literal(node), false, LITERAL); break; case CMARK_NODE_STRONG: if (entering) { - lit(state, "**", false); + LIT("**"); } else { - lit(state, "**", false); + LIT("**"); } break; @@ -509,62 +390,56 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, emph_delim = "*"; } if (entering) { - lit(state, emph_delim, false); + LIT(emph_delim); } else { - lit(state, emph_delim, false); + LIT(emph_delim); } break; case CMARK_NODE_LINK: if (is_autolink(node)) { if (entering) { - lit(state, "<", false); + LIT("<"); if (strncmp(cmark_node_get_url(node), "mailto:", 7) == 0) { - lit(state, - (char *)cmark_node_get_url(node) + 7, - false); + LIT((char *)cmark_node_get_url(node) + 7); } else { - lit(state, - (char *)cmark_node_get_url(node), - false); + LIT((char *)cmark_node_get_url(node)); } - lit(state, ">", false); + LIT(">"); // return signal to skip contents of node... return 0; } } else { if (entering) { - lit(state, "[", false); + LIT("["); } else { - lit(state, "](", false); - out(state, - cmark_chunk_literal(cmark_node_get_url(node)), - false, URL); - title = &node->as.link.title; - if (title->len > 0) { - lit(state, " \"", true); - out(state, *title, false, TITLE); - lit(state, "\"", false); + LIT("]("); + OUT(cmark_node_get_url(node), false, URL); + title = cmark_node_get_title(node); + if (safe_strlen(title) > 0) { + LIT(" \""); + OUT(title, false, TITLE); + LIT("\""); } - lit(state, ")", false); + LIT(")"); } } break; case CMARK_NODE_IMAGE: if (entering) { - lit(state, "![", false); + LIT("!["); } else { - lit(state, "](", false); - out(state, cmark_chunk_literal(cmark_node_get_url(node)), false, URL); - title = &node->as.link.title; - if (title->len > 0) { - lit(state, " \"", true); - out(state, *title, false, TITLE); - lit(state, "\"", false); + LIT("]("); + OUT(cmark_node_get_url(node), false, URL); + title = cmark_node_get_title(node); + if (safe_strlen(title) > 0) { + OUT(" \"", true, LITERAL); + OUT(title, false, TITLE); + LIT("\""); } - lit(state, ")", false); + LIT(")"); } break; @@ -578,32 +453,10 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, char *cmark_render_commonmark(cmark_node *root, int options, int width) { - char *result; - cmark_strbuf commonmark = GH_BUF_INIT; - cmark_strbuf prefix = GH_BUF_INIT; - if (CMARK_OPT_HARDBREAKS & options) { + if (options & CMARK_OPT_HARDBREAKS) { + // disable breaking on width, since it has + // a different meaning with OPT_HARDBREAKS width = 0; } - struct render_state state = { - options, &commonmark, &prefix, 0, width, - 0, 0, true, false, false - }; - cmark_node *cur; - cmark_event_type ev_type; - cmark_iter *iter = cmark_iter_new(root); - - while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { - cur = cmark_iter_get_node(iter); - if (!S_render_node(cur, ev_type, &state)) { - // a false value causes us to skip processing - // the node's contents. this is used for - // autolinks. - cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT); - } - } - result = (char *)cmark_strbuf_detach(&commonmark); - - cmark_strbuf_free(&prefix); - cmark_iter_free(iter); - return result; + return cmark_render(root, options, width, outc, S_render_node); } diff --git a/commonmark.go b/commonmark.go index aff8eb7..aeb0b5e 100644 --- a/commonmark.go +++ b/commonmark.go @@ -110,5 +110,5 @@ func ParseFile(filename string, options int) (*CMarkNode, error) { //Version information func CMarkVersion() int { - return int(C.cmark_version) + return int(C.cmark_version()) } diff --git a/commonmark_test.go b/commonmark_test.go index de7189d..c9a8728 100644 --- a/commonmark_test.go +++ b/commonmark_test.go @@ -135,7 +135,9 @@ func TestCMarkNodeOps(t *testing.T) { if htmlStr != "

I'm the main header!

\n" { t.Error("htmlStr is wrong!") } - manStr := root.RenderMan(commonmark.CMARK_OPT_DEFAULT) + latexStr := root.RenderLatex(commonmark.CMARK_OPT_DEFAULT, 80) + t.Logf("\nLatex: %v", latexStr) + manStr := root.RenderMan(commonmark.CMARK_OPT_DEFAULT, 80) t.Logf("\nMAN: %v", manStr) cmStr := root.RenderCMark(commonmark.CMARK_OPT_DEFAULT, 0) t.Logf("\nCMARK: %v", cmStr) diff --git a/config.h.in b/config.h.in new file mode 100644 index 0000000..5960928 --- /dev/null +++ b/config.h.in @@ -0,0 +1,25 @@ +#cmakedefine HAVE_STDBOOL_H + +#ifdef HAVE_STDBOOL_H + #include +#elif !defined(__cplusplus) + typedef char bool; +#endif + +#cmakedefine HAVE___BUILTIN_EXPECT + +#cmakedefine HAVE___ATTRIBUTE__ + +#ifdef HAVE___ATTRIBUTE__ + #define CMARK_ATTRIBUTE(list) __attribute__ (list) +#else + #define CMARK_ATTRIBUTE(list) +#endif + +#cmakedefine HAVE_VA_COPY + +#ifndef HAVE_VA_COPY + #define va_copy(dest, src) ((dest) = (src)) +#endif + +#cmakedefine HAVE_C99_SNPRINTF diff --git a/entities.inc b/entities.inc new file mode 100644 index 0000000..ec3d2a9 --- /dev/null +++ b/entities.inc @@ -0,0 +1,2138 @@ +/* Autogenerated by tools/make_headers_inc.py */ + +struct cmark_entity_node { + unsigned char *entity; + unsigned char bytes[8]; +}; + +#define CMARK_ENTITY_MIN_LENGTH 2 +#define CMARK_ENTITY_MAX_LENGTH 31 +#define CMARK_NUM_ENTITIES 2125 + +static const struct cmark_entity_node cmark_entities[] = { +{(unsigned char*)"AElig", {195, 134, 0}}, +{(unsigned char*)"AMP", {38, 0}}, +{(unsigned char*)"Aacute", {195, 129, 0}}, +{(unsigned char*)"Abreve", {196, 130, 0}}, +{(unsigned char*)"Acirc", {195, 130, 0}}, +{(unsigned char*)"Acy", {208, 144, 0}}, +{(unsigned char*)"Afr", {240, 157, 148, 132, 0}}, +{(unsigned char*)"Agrave", {195, 128, 0}}, +{(unsigned char*)"Alpha", {206, 145, 0}}, +{(unsigned char*)"Amacr", {196, 128, 0}}, +{(unsigned char*)"And", {226, 169, 147, 0}}, +{(unsigned char*)"Aogon", {196, 132, 0}}, +{(unsigned char*)"Aopf", {240, 157, 148, 184, 0}}, +{(unsigned char*)"ApplyFunction", {226, 129, 161, 0}}, +{(unsigned char*)"Aring", {195, 133, 0}}, +{(unsigned char*)"Ascr", {240, 157, 146, 156, 0}}, +{(unsigned char*)"Assign", {226, 137, 148, 0}}, +{(unsigned char*)"Atilde", {195, 131, 0}}, +{(unsigned char*)"Auml", {195, 132, 0}}, +{(unsigned char*)"Backslash", {226, 136, 150, 0}}, +{(unsigned char*)"Barv", {226, 171, 167, 0}}, +{(unsigned char*)"Barwed", {226, 140, 134, 0}}, +{(unsigned char*)"Bcy", {208, 145, 0}}, +{(unsigned char*)"Because", {226, 136, 181, 0}}, +{(unsigned char*)"Bernoullis", {226, 132, 172, 0}}, +{(unsigned char*)"Beta", {206, 146, 0}}, +{(unsigned char*)"Bfr", {240, 157, 148, 133, 0}}, +{(unsigned char*)"Bopf", {240, 157, 148, 185, 0}}, +{(unsigned char*)"Breve", {203, 152, 0}}, +{(unsigned char*)"Bscr", {226, 132, 172, 0}}, +{(unsigned char*)"Bumpeq", {226, 137, 142, 0}}, +{(unsigned char*)"CHcy", {208, 167, 0}}, +{(unsigned char*)"COPY", {194, 169, 0}}, +{(unsigned char*)"Cacute", {196, 134, 0}}, +{(unsigned char*)"Cap", {226, 139, 146, 0}}, +{(unsigned char*)"CapitalDifferentialD", {226, 133, 133, 0}}, +{(unsigned char*)"Cayleys", {226, 132, 173, 0}}, +{(unsigned char*)"Ccaron", {196, 140, 0}}, +{(unsigned char*)"Ccedil", {195, 135, 0}}, +{(unsigned char*)"Ccirc", {196, 136, 0}}, +{(unsigned char*)"Cconint", {226, 136, 176, 0}}, +{(unsigned char*)"Cdot", {196, 138, 0}}, +{(unsigned char*)"Cedilla", {194, 184, 0}}, +{(unsigned char*)"CenterDot", {194, 183, 0}}, +{(unsigned char*)"Cfr", {226, 132, 173, 0}}, +{(unsigned char*)"Chi", {206, 167, 0}}, +{(unsigned char*)"CircleDot", {226, 138, 153, 0}}, +{(unsigned char*)"CircleMinus", {226, 138, 150, 0}}, +{(unsigned char*)"CirclePlus", {226, 138, 149, 0}}, +{(unsigned char*)"CircleTimes", {226, 138, 151, 0}}, +{(unsigned char*)"ClockwiseContourIntegral", {226, 136, 178, 0}}, +{(unsigned char*)"CloseCurlyDoubleQuote", {226, 128, 157, 0}}, +{(unsigned char*)"CloseCurlyQuote", {226, 128, 153, 0}}, +{(unsigned char*)"Colon", {226, 136, 183, 0}}, +{(unsigned char*)"Colone", {226, 169, 180, 0}}, +{(unsigned char*)"Congruent", {226, 137, 161, 0}}, +{(unsigned char*)"Conint", {226, 136, 175, 0}}, +{(unsigned char*)"ContourIntegral", {226, 136, 174, 0}}, +{(unsigned char*)"Copf", {226, 132, 130, 0}}, +{(unsigned char*)"Coproduct", {226, 136, 144, 0}}, +{(unsigned char*)"CounterClockwiseContourIntegral", {226, 136, 179, 0}}, +{(unsigned char*)"Cross", {226, 168, 175, 0}}, +{(unsigned char*)"Cscr", {240, 157, 146, 158, 0}}, +{(unsigned char*)"Cup", {226, 139, 147, 0}}, +{(unsigned char*)"CupCap", {226, 137, 141, 0}}, +{(unsigned char*)"DD", {226, 133, 133, 0}}, +{(unsigned char*)"DDotrahd", {226, 164, 145, 0}}, +{(unsigned char*)"DJcy", {208, 130, 0}}, +{(unsigned char*)"DScy", {208, 133, 0}}, +{(unsigned char*)"DZcy", {208, 143, 0}}, +{(unsigned char*)"Dagger", {226, 128, 161, 0}}, +{(unsigned char*)"Darr", {226, 134, 161, 0}}, +{(unsigned char*)"Dashv", {226, 171, 164, 0}}, +{(unsigned char*)"Dcaron", {196, 142, 0}}, +{(unsigned char*)"Dcy", {208, 148, 0}}, +{(unsigned char*)"Del", {226, 136, 135, 0}}, +{(unsigned char*)"Delta", {206, 148, 0}}, +{(unsigned char*)"Dfr", {240, 157, 148, 135, 0}}, +{(unsigned char*)"DiacriticalAcute", {194, 180, 0}}, +{(unsigned char*)"DiacriticalDot", {203, 153, 0}}, +{(unsigned char*)"DiacriticalDoubleAcute", {203, 157, 0}}, +{(unsigned char*)"DiacriticalGrave", {96, 0}}, +{(unsigned char*)"DiacriticalTilde", {203, 156, 0}}, +{(unsigned char*)"Diamond", {226, 139, 132, 0}}, +{(unsigned char*)"DifferentialD", {226, 133, 134, 0}}, +{(unsigned char*)"Dopf", {240, 157, 148, 187, 0}}, +{(unsigned char*)"Dot", {194, 168, 0}}, +{(unsigned char*)"DotDot", {226, 131, 156, 0}}, +{(unsigned char*)"DotEqual", {226, 137, 144, 0}}, +{(unsigned char*)"DoubleContourIntegral", {226, 136, 175, 0}}, +{(unsigned char*)"DoubleDot", {194, 168, 0}}, +{(unsigned char*)"DoubleDownArrow", {226, 135, 147, 0}}, +{(unsigned char*)"DoubleLeftArrow", {226, 135, 144, 0}}, +{(unsigned char*)"DoubleLeftRightArrow", {226, 135, 148, 0}}, +{(unsigned char*)"DoubleLeftTee", {226, 171, 164, 0}}, +{(unsigned char*)"DoubleLongLeftArrow", {226, 159, 184, 0}}, +{(unsigned char*)"DoubleLongLeftRightArrow", {226, 159, 186, 0}}, +{(unsigned char*)"DoubleLongRightArrow", {226, 159, 185, 0}}, +{(unsigned char*)"DoubleRightArrow", {226, 135, 146, 0}}, +{(unsigned char*)"DoubleRightTee", {226, 138, 168, 0}}, +{(unsigned char*)"DoubleUpArrow", {226, 135, 145, 0}}, +{(unsigned char*)"DoubleUpDownArrow", {226, 135, 149, 0}}, +{(unsigned char*)"DoubleVerticalBar", {226, 136, 165, 0}}, +{(unsigned char*)"DownArrow", {226, 134, 147, 0}}, +{(unsigned char*)"DownArrowBar", {226, 164, 147, 0}}, +{(unsigned char*)"DownArrowUpArrow", {226, 135, 181, 0}}, +{(unsigned char*)"DownBreve", {204, 145, 0}}, +{(unsigned char*)"DownLeftRightVector", {226, 165, 144, 0}}, +{(unsigned char*)"DownLeftTeeVector", {226, 165, 158, 0}}, +{(unsigned char*)"DownLeftVector", {226, 134, 189, 0}}, +{(unsigned char*)"DownLeftVectorBar", {226, 165, 150, 0}}, +{(unsigned char*)"DownRightTeeVector", {226, 165, 159, 0}}, +{(unsigned char*)"DownRightVector", {226, 135, 129, 0}}, +{(unsigned char*)"DownRightVectorBar", {226, 165, 151, 0}}, +{(unsigned char*)"DownTee", {226, 138, 164, 0}}, +{(unsigned char*)"DownTeeArrow", {226, 134, 167, 0}}, +{(unsigned char*)"Downarrow", {226, 135, 147, 0}}, +{(unsigned char*)"Dscr", {240, 157, 146, 159, 0}}, +{(unsigned char*)"Dstrok", {196, 144, 0}}, +{(unsigned char*)"ENG", {197, 138, 0}}, +{(unsigned char*)"ETH", {195, 144, 0}}, +{(unsigned char*)"Eacute", {195, 137, 0}}, +{(unsigned char*)"Ecaron", {196, 154, 0}}, +{(unsigned char*)"Ecirc", {195, 138, 0}}, +{(unsigned char*)"Ecy", {208, 173, 0}}, +{(unsigned char*)"Edot", {196, 150, 0}}, +{(unsigned char*)"Efr", {240, 157, 148, 136, 0}}, +{(unsigned char*)"Egrave", {195, 136, 0}}, +{(unsigned char*)"Element", {226, 136, 136, 0}}, +{(unsigned char*)"Emacr", {196, 146, 0}}, +{(unsigned char*)"EmptySmallSquare", {226, 151, 187, 0}}, +{(unsigned char*)"EmptyVerySmallSquare", {226, 150, 171, 0}}, +{(unsigned char*)"Eogon", {196, 152, 0}}, +{(unsigned char*)"Eopf", {240, 157, 148, 188, 0}}, +{(unsigned char*)"Epsilon", {206, 149, 0}}, +{(unsigned char*)"Equal", {226, 169, 181, 0}}, +{(unsigned char*)"EqualTilde", {226, 137, 130, 0}}, +{(unsigned char*)"Equilibrium", {226, 135, 140, 0}}, +{(unsigned char*)"Escr", {226, 132, 176, 0}}, +{(unsigned char*)"Esim", {226, 169, 179, 0}}, +{(unsigned char*)"Eta", {206, 151, 0}}, +{(unsigned char*)"Euml", {195, 139, 0}}, +{(unsigned char*)"Exists", {226, 136, 131, 0}}, +{(unsigned char*)"ExponentialE", {226, 133, 135, 0}}, +{(unsigned char*)"Fcy", {208, 164, 0}}, +{(unsigned char*)"Ffr", {240, 157, 148, 137, 0}}, +{(unsigned char*)"FilledSmallSquare", {226, 151, 188, 0}}, +{(unsigned char*)"FilledVerySmallSquare", {226, 150, 170, 0}}, +{(unsigned char*)"Fopf", {240, 157, 148, 189, 0}}, +{(unsigned char*)"ForAll", {226, 136, 128, 0}}, +{(unsigned char*)"Fouriertrf", {226, 132, 177, 0}}, +{(unsigned char*)"Fscr", {226, 132, 177, 0}}, +{(unsigned char*)"GJcy", {208, 131, 0}}, +{(unsigned char*)"GT", {62, 0}}, +{(unsigned char*)"Gamma", {206, 147, 0}}, +{(unsigned char*)"Gammad", {207, 156, 0}}, +{(unsigned char*)"Gbreve", {196, 158, 0}}, +{(unsigned char*)"Gcedil", {196, 162, 0}}, +{(unsigned char*)"Gcirc", {196, 156, 0}}, +{(unsigned char*)"Gcy", {208, 147, 0}}, +{(unsigned char*)"Gdot", {196, 160, 0}}, +{(unsigned char*)"Gfr", {240, 157, 148, 138, 0}}, +{(unsigned char*)"Gg", {226, 139, 153, 0}}, +{(unsigned char*)"Gopf", {240, 157, 148, 190, 0}}, +{(unsigned char*)"GreaterEqual", {226, 137, 165, 0}}, +{(unsigned char*)"GreaterEqualLess", {226, 139, 155, 0}}, +{(unsigned char*)"GreaterFullEqual", {226, 137, 167, 0}}, +{(unsigned char*)"GreaterGreater", {226, 170, 162, 0}}, +{(unsigned char*)"GreaterLess", {226, 137, 183, 0}}, +{(unsigned char*)"GreaterSlantEqual", {226, 169, 190, 0}}, +{(unsigned char*)"GreaterTilde", {226, 137, 179, 0}}, +{(unsigned char*)"Gscr", {240, 157, 146, 162, 0}}, +{(unsigned char*)"Gt", {226, 137, 171, 0}}, +{(unsigned char*)"HARDcy", {208, 170, 0}}, +{(unsigned char*)"Hacek", {203, 135, 0}}, +{(unsigned char*)"Hat", {94, 0}}, +{(unsigned char*)"Hcirc", {196, 164, 0}}, +{(unsigned char*)"Hfr", {226, 132, 140, 0}}, +{(unsigned char*)"HilbertSpace", {226, 132, 139, 0}}, +{(unsigned char*)"Hopf", {226, 132, 141, 0}}, +{(unsigned char*)"HorizontalLine", {226, 148, 128, 0}}, +{(unsigned char*)"Hscr", {226, 132, 139, 0}}, +{(unsigned char*)"Hstrok", {196, 166, 0}}, +{(unsigned char*)"HumpDownHump", {226, 137, 142, 0}}, +{(unsigned char*)"HumpEqual", {226, 137, 143, 0}}, +{(unsigned char*)"IEcy", {208, 149, 0}}, +{(unsigned char*)"IJlig", {196, 178, 0}}, +{(unsigned char*)"IOcy", {208, 129, 0}}, +{(unsigned char*)"Iacute", {195, 141, 0}}, +{(unsigned char*)"Icirc", {195, 142, 0}}, +{(unsigned char*)"Icy", {208, 152, 0}}, +{(unsigned char*)"Idot", {196, 176, 0}}, +{(unsigned char*)"Ifr", {226, 132, 145, 0}}, +{(unsigned char*)"Igrave", {195, 140, 0}}, +{(unsigned char*)"Im", {226, 132, 145, 0}}, +{(unsigned char*)"Imacr", {196, 170, 0}}, +{(unsigned char*)"ImaginaryI", {226, 133, 136, 0}}, +{(unsigned char*)"Implies", {226, 135, 146, 0}}, +{(unsigned char*)"Int", {226, 136, 172, 0}}, +{(unsigned char*)"Integral", {226, 136, 171, 0}}, +{(unsigned char*)"Intersection", {226, 139, 130, 0}}, +{(unsigned char*)"InvisibleComma", {226, 129, 163, 0}}, +{(unsigned char*)"InvisibleTimes", {226, 129, 162, 0}}, +{(unsigned char*)"Iogon", {196, 174, 0}}, +{(unsigned char*)"Iopf", {240, 157, 149, 128, 0}}, +{(unsigned char*)"Iota", {206, 153, 0}}, +{(unsigned char*)"Iscr", {226, 132, 144, 0}}, +{(unsigned char*)"Itilde", {196, 168, 0}}, +{(unsigned char*)"Iukcy", {208, 134, 0}}, +{(unsigned char*)"Iuml", {195, 143, 0}}, +{(unsigned char*)"Jcirc", {196, 180, 0}}, +{(unsigned char*)"Jcy", {208, 153, 0}}, +{(unsigned char*)"Jfr", {240, 157, 148, 141, 0}}, +{(unsigned char*)"Jopf", {240, 157, 149, 129, 0}}, +{(unsigned char*)"Jscr", {240, 157, 146, 165, 0}}, +{(unsigned char*)"Jsercy", {208, 136, 0}}, +{(unsigned char*)"Jukcy", {208, 132, 0}}, +{(unsigned char*)"KHcy", {208, 165, 0}}, +{(unsigned char*)"KJcy", {208, 140, 0}}, +{(unsigned char*)"Kappa", {206, 154, 0}}, +{(unsigned char*)"Kcedil", {196, 182, 0}}, +{(unsigned char*)"Kcy", {208, 154, 0}}, +{(unsigned char*)"Kfr", {240, 157, 148, 142, 0}}, +{(unsigned char*)"Kopf", {240, 157, 149, 130, 0}}, +{(unsigned char*)"Kscr", {240, 157, 146, 166, 0}}, +{(unsigned char*)"LJcy", {208, 137, 0}}, +{(unsigned char*)"LT", {60, 0}}, +{(unsigned char*)"Lacute", {196, 185, 0}}, +{(unsigned char*)"Lambda", {206, 155, 0}}, +{(unsigned char*)"Lang", {226, 159, 170, 0}}, +{(unsigned char*)"Laplacetrf", {226, 132, 146, 0}}, +{(unsigned char*)"Larr", {226, 134, 158, 0}}, +{(unsigned char*)"Lcaron", {196, 189, 0}}, +{(unsigned char*)"Lcedil", {196, 187, 0}}, +{(unsigned char*)"Lcy", {208, 155, 0}}, +{(unsigned char*)"LeftAngleBracket", {226, 159, 168, 0}}, +{(unsigned char*)"LeftArrow", {226, 134, 144, 0}}, +{(unsigned char*)"LeftArrowBar", {226, 135, 164, 0}}, +{(unsigned char*)"LeftArrowRightArrow", {226, 135, 134, 0}}, +{(unsigned char*)"LeftCeiling", {226, 140, 136, 0}}, +{(unsigned char*)"LeftDoubleBracket", {226, 159, 166, 0}}, +{(unsigned char*)"LeftDownTeeVector", {226, 165, 161, 0}}, +{(unsigned char*)"LeftDownVector", {226, 135, 131, 0}}, +{(unsigned char*)"LeftDownVectorBar", {226, 165, 153, 0}}, +{(unsigned char*)"LeftFloor", {226, 140, 138, 0}}, +{(unsigned char*)"LeftRightArrow", {226, 134, 148, 0}}, +{(unsigned char*)"LeftRightVector", {226, 165, 142, 0}}, +{(unsigned char*)"LeftTee", {226, 138, 163, 0}}, +{(unsigned char*)"LeftTeeArrow", {226, 134, 164, 0}}, +{(unsigned char*)"LeftTeeVector", {226, 165, 154, 0}}, +{(unsigned char*)"LeftTriangle", {226, 138, 178, 0}}, +{(unsigned char*)"LeftTriangleBar", {226, 167, 143, 0}}, +{(unsigned char*)"LeftTriangleEqual", {226, 138, 180, 0}}, +{(unsigned char*)"LeftUpDownVector", {226, 165, 145, 0}}, +{(unsigned char*)"LeftUpTeeVector", {226, 165, 160, 0}}, +{(unsigned char*)"LeftUpVector", {226, 134, 191, 0}}, +{(unsigned char*)"LeftUpVectorBar", {226, 165, 152, 0}}, +{(unsigned char*)"LeftVector", {226, 134, 188, 0}}, +{(unsigned char*)"LeftVectorBar", {226, 165, 146, 0}}, +{(unsigned char*)"Leftarrow", {226, 135, 144, 0}}, +{(unsigned char*)"Leftrightarrow", {226, 135, 148, 0}}, +{(unsigned char*)"LessEqualGreater", {226, 139, 154, 0}}, +{(unsigned char*)"LessFullEqual", {226, 137, 166, 0}}, +{(unsigned char*)"LessGreater", {226, 137, 182, 0}}, +{(unsigned char*)"LessLess", {226, 170, 161, 0}}, +{(unsigned char*)"LessSlantEqual", {226, 169, 189, 0}}, +{(unsigned char*)"LessTilde", {226, 137, 178, 0}}, +{(unsigned char*)"Lfr", {240, 157, 148, 143, 0}}, +{(unsigned char*)"Ll", {226, 139, 152, 0}}, +{(unsigned char*)"Lleftarrow", {226, 135, 154, 0}}, +{(unsigned char*)"Lmidot", {196, 191, 0}}, +{(unsigned char*)"LongLeftArrow", {226, 159, 181, 0}}, +{(unsigned char*)"LongLeftRightArrow", {226, 159, 183, 0}}, +{(unsigned char*)"LongRightArrow", {226, 159, 182, 0}}, +{(unsigned char*)"Longleftarrow", {226, 159, 184, 0}}, +{(unsigned char*)"Longleftrightarrow", {226, 159, 186, 0}}, +{(unsigned char*)"Longrightarrow", {226, 159, 185, 0}}, +{(unsigned char*)"Lopf", {240, 157, 149, 131, 0}}, +{(unsigned char*)"LowerLeftArrow", {226, 134, 153, 0}}, +{(unsigned char*)"LowerRightArrow", {226, 134, 152, 0}}, +{(unsigned char*)"Lscr", {226, 132, 146, 0}}, +{(unsigned char*)"Lsh", {226, 134, 176, 0}}, +{(unsigned char*)"Lstrok", {197, 129, 0}}, +{(unsigned char*)"Lt", {226, 137, 170, 0}}, +{(unsigned char*)"Map", {226, 164, 133, 0}}, +{(unsigned char*)"Mcy", {208, 156, 0}}, +{(unsigned char*)"MediumSpace", {226, 129, 159, 0}}, +{(unsigned char*)"Mellintrf", {226, 132, 179, 0}}, +{(unsigned char*)"Mfr", {240, 157, 148, 144, 0}}, +{(unsigned char*)"MinusPlus", {226, 136, 147, 0}}, +{(unsigned char*)"Mopf", {240, 157, 149, 132, 0}}, +{(unsigned char*)"Mscr", {226, 132, 179, 0}}, +{(unsigned char*)"Mu", {206, 156, 0}}, +{(unsigned char*)"NJcy", {208, 138, 0}}, +{(unsigned char*)"Nacute", {197, 131, 0}}, +{(unsigned char*)"Ncaron", {197, 135, 0}}, +{(unsigned char*)"Ncedil", {197, 133, 0}}, +{(unsigned char*)"Ncy", {208, 157, 0}}, +{(unsigned char*)"NegativeMediumSpace", {226, 128, 139, 0}}, +{(unsigned char*)"NegativeThickSpace", {226, 128, 139, 0}}, +{(unsigned char*)"NegativeThinSpace", {226, 128, 139, 0}}, +{(unsigned char*)"NegativeVeryThinSpace", {226, 128, 139, 0}}, +{(unsigned char*)"NestedGreaterGreater", {226, 137, 171, 0}}, +{(unsigned char*)"NestedLessLess", {226, 137, 170, 0}}, +{(unsigned char*)"NewLine", {10, 0}}, +{(unsigned char*)"Nfr", {240, 157, 148, 145, 0}}, +{(unsigned char*)"NoBreak", {226, 129, 160, 0}}, +{(unsigned char*)"NonBreakingSpace", {194, 160, 0}}, +{(unsigned char*)"Nopf", {226, 132, 149, 0}}, +{(unsigned char*)"Not", {226, 171, 172, 0}}, +{(unsigned char*)"NotCongruent", {226, 137, 162, 0}}, +{(unsigned char*)"NotCupCap", {226, 137, 173, 0}}, +{(unsigned char*)"NotDoubleVerticalBar", {226, 136, 166, 0}}, +{(unsigned char*)"NotElement", {226, 136, 137, 0}}, +{(unsigned char*)"NotEqual", {226, 137, 160, 0}}, +{(unsigned char*)"NotEqualTilde", {226, 137, 130, 204, 184, 0}}, +{(unsigned char*)"NotExists", {226, 136, 132, 0}}, +{(unsigned char*)"NotGreater", {226, 137, 175, 0}}, +{(unsigned char*)"NotGreaterEqual", {226, 137, 177, 0}}, +{(unsigned char*)"NotGreaterFullEqual", {226, 137, 167, 204, 184, 0}}, +{(unsigned char*)"NotGreaterGreater", {226, 137, 171, 204, 184, 0}}, +{(unsigned char*)"NotGreaterLess", {226, 137, 185, 0}}, +{(unsigned char*)"NotGreaterSlantEqual", {226, 169, 190, 204, 184, 0}}, +{(unsigned char*)"NotGreaterTilde", {226, 137, 181, 0}}, +{(unsigned char*)"NotHumpDownHump", {226, 137, 142, 204, 184, 0}}, +{(unsigned char*)"NotHumpEqual", {226, 137, 143, 204, 184, 0}}, +{(unsigned char*)"NotLeftTriangle", {226, 139, 170, 0}}, +{(unsigned char*)"NotLeftTriangleBar", {226, 167, 143, 204, 184, 0}}, +{(unsigned char*)"NotLeftTriangleEqual", {226, 139, 172, 0}}, +{(unsigned char*)"NotLess", {226, 137, 174, 0}}, +{(unsigned char*)"NotLessEqual", {226, 137, 176, 0}}, +{(unsigned char*)"NotLessGreater", {226, 137, 184, 0}}, +{(unsigned char*)"NotLessLess", {226, 137, 170, 204, 184, 0}}, +{(unsigned char*)"NotLessSlantEqual", {226, 169, 189, 204, 184, 0}}, +{(unsigned char*)"NotLessTilde", {226, 137, 180, 0}}, +{(unsigned char*)"NotNestedGreaterGreater", {226, 170, 162, 204, 184, 0}}, +{(unsigned char*)"NotNestedLessLess", {226, 170, 161, 204, 184, 0}}, +{(unsigned char*)"NotPrecedes", {226, 138, 128, 0}}, +{(unsigned char*)"NotPrecedesEqual", {226, 170, 175, 204, 184, 0}}, +{(unsigned char*)"NotPrecedesSlantEqual", {226, 139, 160, 0}}, +{(unsigned char*)"NotReverseElement", {226, 136, 140, 0}}, +{(unsigned char*)"NotRightTriangle", {226, 139, 171, 0}}, +{(unsigned char*)"NotRightTriangleBar", {226, 167, 144, 204, 184, 0}}, +{(unsigned char*)"NotRightTriangleEqual", {226, 139, 173, 0}}, +{(unsigned char*)"NotSquareSubset", {226, 138, 143, 204, 184, 0}}, +{(unsigned char*)"NotSquareSubsetEqual", {226, 139, 162, 0}}, +{(unsigned char*)"NotSquareSuperset", {226, 138, 144, 204, 184, 0}}, +{(unsigned char*)"NotSquareSupersetEqual", {226, 139, 163, 0}}, +{(unsigned char*)"NotSubset", {226, 138, 130, 226, 131, 146, 0}}, +{(unsigned char*)"NotSubsetEqual", {226, 138, 136, 0}}, +{(unsigned char*)"NotSucceeds", {226, 138, 129, 0}}, +{(unsigned char*)"NotSucceedsEqual", {226, 170, 176, 204, 184, 0}}, +{(unsigned char*)"NotSucceedsSlantEqual", {226, 139, 161, 0}}, +{(unsigned char*)"NotSucceedsTilde", {226, 137, 191, 204, 184, 0}}, +{(unsigned char*)"NotSuperset", {226, 138, 131, 226, 131, 146, 0}}, +{(unsigned char*)"NotSupersetEqual", {226, 138, 137, 0}}, +{(unsigned char*)"NotTilde", {226, 137, 129, 0}}, +{(unsigned char*)"NotTildeEqual", {226, 137, 132, 0}}, +{(unsigned char*)"NotTildeFullEqual", {226, 137, 135, 0}}, +{(unsigned char*)"NotTildeTilde", {226, 137, 137, 0}}, +{(unsigned char*)"NotVerticalBar", {226, 136, 164, 0}}, +{(unsigned char*)"Nscr", {240, 157, 146, 169, 0}}, +{(unsigned char*)"Ntilde", {195, 145, 0}}, +{(unsigned char*)"Nu", {206, 157, 0}}, +{(unsigned char*)"OElig", {197, 146, 0}}, +{(unsigned char*)"Oacute", {195, 147, 0}}, +{(unsigned char*)"Ocirc", {195, 148, 0}}, +{(unsigned char*)"Ocy", {208, 158, 0}}, +{(unsigned char*)"Odblac", {197, 144, 0}}, +{(unsigned char*)"Ofr", {240, 157, 148, 146, 0}}, +{(unsigned char*)"Ograve", {195, 146, 0}}, +{(unsigned char*)"Omacr", {197, 140, 0}}, +{(unsigned char*)"Omega", {206, 169, 0}}, +{(unsigned char*)"Omicron", {206, 159, 0}}, +{(unsigned char*)"Oopf", {240, 157, 149, 134, 0}}, +{(unsigned char*)"OpenCurlyDoubleQuote", {226, 128, 156, 0}}, +{(unsigned char*)"OpenCurlyQuote", {226, 128, 152, 0}}, +{(unsigned char*)"Or", {226, 169, 148, 0}}, +{(unsigned char*)"Oscr", {240, 157, 146, 170, 0}}, +{(unsigned char*)"Oslash", {195, 152, 0}}, +{(unsigned char*)"Otilde", {195, 149, 0}}, +{(unsigned char*)"Otimes", {226, 168, 183, 0}}, +{(unsigned char*)"Ouml", {195, 150, 0}}, +{(unsigned char*)"OverBar", {226, 128, 190, 0}}, +{(unsigned char*)"OverBrace", {226, 143, 158, 0}}, +{(unsigned char*)"OverBracket", {226, 142, 180, 0}}, +{(unsigned char*)"OverParenthesis", {226, 143, 156, 0}}, +{(unsigned char*)"PartialD", {226, 136, 130, 0}}, +{(unsigned char*)"Pcy", {208, 159, 0}}, +{(unsigned char*)"Pfr", {240, 157, 148, 147, 0}}, +{(unsigned char*)"Phi", {206, 166, 0}}, +{(unsigned char*)"Pi", {206, 160, 0}}, +{(unsigned char*)"PlusMinus", {194, 177, 0}}, +{(unsigned char*)"Poincareplane", {226, 132, 140, 0}}, +{(unsigned char*)"Popf", {226, 132, 153, 0}}, +{(unsigned char*)"Pr", {226, 170, 187, 0}}, +{(unsigned char*)"Precedes", {226, 137, 186, 0}}, +{(unsigned char*)"PrecedesEqual", {226, 170, 175, 0}}, +{(unsigned char*)"PrecedesSlantEqual", {226, 137, 188, 0}}, +{(unsigned char*)"PrecedesTilde", {226, 137, 190, 0}}, +{(unsigned char*)"Prime", {226, 128, 179, 0}}, +{(unsigned char*)"Product", {226, 136, 143, 0}}, +{(unsigned char*)"Proportion", {226, 136, 183, 0}}, +{(unsigned char*)"Proportional", {226, 136, 157, 0}}, +{(unsigned char*)"Pscr", {240, 157, 146, 171, 0}}, +{(unsigned char*)"Psi", {206, 168, 0}}, +{(unsigned char*)"QUOT", {34, 0}}, +{(unsigned char*)"Qfr", {240, 157, 148, 148, 0}}, +{(unsigned char*)"Qopf", {226, 132, 154, 0}}, +{(unsigned char*)"Qscr", {240, 157, 146, 172, 0}}, +{(unsigned char*)"RBarr", {226, 164, 144, 0}}, +{(unsigned char*)"REG", {194, 174, 0}}, +{(unsigned char*)"Racute", {197, 148, 0}}, +{(unsigned char*)"Rang", {226, 159, 171, 0}}, +{(unsigned char*)"Rarr", {226, 134, 160, 0}}, +{(unsigned char*)"Rarrtl", {226, 164, 150, 0}}, +{(unsigned char*)"Rcaron", {197, 152, 0}}, +{(unsigned char*)"Rcedil", {197, 150, 0}}, +{(unsigned char*)"Rcy", {208, 160, 0}}, +{(unsigned char*)"Re", {226, 132, 156, 0}}, +{(unsigned char*)"ReverseElement", {226, 136, 139, 0}}, +{(unsigned char*)"ReverseEquilibrium", {226, 135, 139, 0}}, +{(unsigned char*)"ReverseUpEquilibrium", {226, 165, 175, 0}}, +{(unsigned char*)"Rfr", {226, 132, 156, 0}}, +{(unsigned char*)"Rho", {206, 161, 0}}, +{(unsigned char*)"RightAngleBracket", {226, 159, 169, 0}}, +{(unsigned char*)"RightArrow", {226, 134, 146, 0}}, +{(unsigned char*)"RightArrowBar", {226, 135, 165, 0}}, +{(unsigned char*)"RightArrowLeftArrow", {226, 135, 132, 0}}, +{(unsigned char*)"RightCeiling", {226, 140, 137, 0}}, +{(unsigned char*)"RightDoubleBracket", {226, 159, 167, 0}}, +{(unsigned char*)"RightDownTeeVector", {226, 165, 157, 0}}, +{(unsigned char*)"RightDownVector", {226, 135, 130, 0}}, +{(unsigned char*)"RightDownVectorBar", {226, 165, 149, 0}}, +{(unsigned char*)"RightFloor", {226, 140, 139, 0}}, +{(unsigned char*)"RightTee", {226, 138, 162, 0}}, +{(unsigned char*)"RightTeeArrow", {226, 134, 166, 0}}, +{(unsigned char*)"RightTeeVector", {226, 165, 155, 0}}, +{(unsigned char*)"RightTriangle", {226, 138, 179, 0}}, +{(unsigned char*)"RightTriangleBar", {226, 167, 144, 0}}, +{(unsigned char*)"RightTriangleEqual", {226, 138, 181, 0}}, +{(unsigned char*)"RightUpDownVector", {226, 165, 143, 0}}, +{(unsigned char*)"RightUpTeeVector", {226, 165, 156, 0}}, +{(unsigned char*)"RightUpVector", {226, 134, 190, 0}}, +{(unsigned char*)"RightUpVectorBar", {226, 165, 148, 0}}, +{(unsigned char*)"RightVector", {226, 135, 128, 0}}, +{(unsigned char*)"RightVectorBar", {226, 165, 147, 0}}, +{(unsigned char*)"Rightarrow", {226, 135, 146, 0}}, +{(unsigned char*)"Ropf", {226, 132, 157, 0}}, +{(unsigned char*)"RoundImplies", {226, 165, 176, 0}}, +{(unsigned char*)"Rrightarrow", {226, 135, 155, 0}}, +{(unsigned char*)"Rscr", {226, 132, 155, 0}}, +{(unsigned char*)"Rsh", {226, 134, 177, 0}}, +{(unsigned char*)"RuleDelayed", {226, 167, 180, 0}}, +{(unsigned char*)"SHCHcy", {208, 169, 0}}, +{(unsigned char*)"SHcy", {208, 168, 0}}, +{(unsigned char*)"SOFTcy", {208, 172, 0}}, +{(unsigned char*)"Sacute", {197, 154, 0}}, +{(unsigned char*)"Sc", {226, 170, 188, 0}}, +{(unsigned char*)"Scaron", {197, 160, 0}}, +{(unsigned char*)"Scedil", {197, 158, 0}}, +{(unsigned char*)"Scirc", {197, 156, 0}}, +{(unsigned char*)"Scy", {208, 161, 0}}, +{(unsigned char*)"Sfr", {240, 157, 148, 150, 0}}, +{(unsigned char*)"ShortDownArrow", {226, 134, 147, 0}}, +{(unsigned char*)"ShortLeftArrow", {226, 134, 144, 0}}, +{(unsigned char*)"ShortRightArrow", {226, 134, 146, 0}}, +{(unsigned char*)"ShortUpArrow", {226, 134, 145, 0}}, +{(unsigned char*)"Sigma", {206, 163, 0}}, +{(unsigned char*)"SmallCircle", {226, 136, 152, 0}}, +{(unsigned char*)"Sopf", {240, 157, 149, 138, 0}}, +{(unsigned char*)"Sqrt", {226, 136, 154, 0}}, +{(unsigned char*)"Square", {226, 150, 161, 0}}, +{(unsigned char*)"SquareIntersection", {226, 138, 147, 0}}, +{(unsigned char*)"SquareSubset", {226, 138, 143, 0}}, +{(unsigned char*)"SquareSubsetEqual", {226, 138, 145, 0}}, +{(unsigned char*)"SquareSuperset", {226, 138, 144, 0}}, +{(unsigned char*)"SquareSupersetEqual", {226, 138, 146, 0}}, +{(unsigned char*)"SquareUnion", {226, 138, 148, 0}}, +{(unsigned char*)"Sscr", {240, 157, 146, 174, 0}}, +{(unsigned char*)"Star", {226, 139, 134, 0}}, +{(unsigned char*)"Sub", {226, 139, 144, 0}}, +{(unsigned char*)"Subset", {226, 139, 144, 0}}, +{(unsigned char*)"SubsetEqual", {226, 138, 134, 0}}, +{(unsigned char*)"Succeeds", {226, 137, 187, 0}}, +{(unsigned char*)"SucceedsEqual", {226, 170, 176, 0}}, +{(unsigned char*)"SucceedsSlantEqual", {226, 137, 189, 0}}, +{(unsigned char*)"SucceedsTilde", {226, 137, 191, 0}}, +{(unsigned char*)"SuchThat", {226, 136, 139, 0}}, +{(unsigned char*)"Sum", {226, 136, 145, 0}}, +{(unsigned char*)"Sup", {226, 139, 145, 0}}, +{(unsigned char*)"Superset", {226, 138, 131, 0}}, +{(unsigned char*)"SupersetEqual", {226, 138, 135, 0}}, +{(unsigned char*)"Supset", {226, 139, 145, 0}}, +{(unsigned char*)"THORN", {195, 158, 0}}, +{(unsigned char*)"TRADE", {226, 132, 162, 0}}, +{(unsigned char*)"TSHcy", {208, 139, 0}}, +{(unsigned char*)"TScy", {208, 166, 0}}, +{(unsigned char*)"Tab", {9, 0}}, +{(unsigned char*)"Tau", {206, 164, 0}}, +{(unsigned char*)"Tcaron", {197, 164, 0}}, +{(unsigned char*)"Tcedil", {197, 162, 0}}, +{(unsigned char*)"Tcy", {208, 162, 0}}, +{(unsigned char*)"Tfr", {240, 157, 148, 151, 0}}, +{(unsigned char*)"Therefore", {226, 136, 180, 0}}, +{(unsigned char*)"Theta", {206, 152, 0}}, +{(unsigned char*)"ThickSpace", {226, 129, 159, 226, 128, 138, 0}}, +{(unsigned char*)"ThinSpace", {226, 128, 137, 0}}, +{(unsigned char*)"Tilde", {226, 136, 188, 0}}, +{(unsigned char*)"TildeEqual", {226, 137, 131, 0}}, +{(unsigned char*)"TildeFullEqual", {226, 137, 133, 0}}, +{(unsigned char*)"TildeTilde", {226, 137, 136, 0}}, +{(unsigned char*)"Topf", {240, 157, 149, 139, 0}}, +{(unsigned char*)"TripleDot", {226, 131, 155, 0}}, +{(unsigned char*)"Tscr", {240, 157, 146, 175, 0}}, +{(unsigned char*)"Tstrok", {197, 166, 0}}, +{(unsigned char*)"Uacute", {195, 154, 0}}, +{(unsigned char*)"Uarr", {226, 134, 159, 0}}, +{(unsigned char*)"Uarrocir", {226, 165, 137, 0}}, +{(unsigned char*)"Ubrcy", {208, 142, 0}}, +{(unsigned char*)"Ubreve", {197, 172, 0}}, +{(unsigned char*)"Ucirc", {195, 155, 0}}, +{(unsigned char*)"Ucy", {208, 163, 0}}, +{(unsigned char*)"Udblac", {197, 176, 0}}, +{(unsigned char*)"Ufr", {240, 157, 148, 152, 0}}, +{(unsigned char*)"Ugrave", {195, 153, 0}}, +{(unsigned char*)"Umacr", {197, 170, 0}}, +{(unsigned char*)"UnderBar", {95, 0}}, +{(unsigned char*)"UnderBrace", {226, 143, 159, 0}}, +{(unsigned char*)"UnderBracket", {226, 142, 181, 0}}, +{(unsigned char*)"UnderParenthesis", {226, 143, 157, 0}}, +{(unsigned char*)"Union", {226, 139, 131, 0}}, +{(unsigned char*)"UnionPlus", {226, 138, 142, 0}}, +{(unsigned char*)"Uogon", {197, 178, 0}}, +{(unsigned char*)"Uopf", {240, 157, 149, 140, 0}}, +{(unsigned char*)"UpArrow", {226, 134, 145, 0}}, +{(unsigned char*)"UpArrowBar", {226, 164, 146, 0}}, +{(unsigned char*)"UpArrowDownArrow", {226, 135, 133, 0}}, +{(unsigned char*)"UpDownArrow", {226, 134, 149, 0}}, +{(unsigned char*)"UpEquilibrium", {226, 165, 174, 0}}, +{(unsigned char*)"UpTee", {226, 138, 165, 0}}, +{(unsigned char*)"UpTeeArrow", {226, 134, 165, 0}}, +{(unsigned char*)"Uparrow", {226, 135, 145, 0}}, +{(unsigned char*)"Updownarrow", {226, 135, 149, 0}}, +{(unsigned char*)"UpperLeftArrow", {226, 134, 150, 0}}, +{(unsigned char*)"UpperRightArrow", {226, 134, 151, 0}}, +{(unsigned char*)"Upsi", {207, 146, 0}}, +{(unsigned char*)"Upsilon", {206, 165, 0}}, +{(unsigned char*)"Uring", {197, 174, 0}}, +{(unsigned char*)"Uscr", {240, 157, 146, 176, 0}}, +{(unsigned char*)"Utilde", {197, 168, 0}}, +{(unsigned char*)"Uuml", {195, 156, 0}}, +{(unsigned char*)"VDash", {226, 138, 171, 0}}, +{(unsigned char*)"Vbar", {226, 171, 171, 0}}, +{(unsigned char*)"Vcy", {208, 146, 0}}, +{(unsigned char*)"Vdash", {226, 138, 169, 0}}, +{(unsigned char*)"Vdashl", {226, 171, 166, 0}}, +{(unsigned char*)"Vee", {226, 139, 129, 0}}, +{(unsigned char*)"Verbar", {226, 128, 150, 0}}, +{(unsigned char*)"Vert", {226, 128, 150, 0}}, +{(unsigned char*)"VerticalBar", {226, 136, 163, 0}}, +{(unsigned char*)"VerticalLine", {124, 0}}, +{(unsigned char*)"VerticalSeparator", {226, 157, 152, 0}}, +{(unsigned char*)"VerticalTilde", {226, 137, 128, 0}}, +{(unsigned char*)"VeryThinSpace", {226, 128, 138, 0}}, +{(unsigned char*)"Vfr", {240, 157, 148, 153, 0}}, +{(unsigned char*)"Vopf", {240, 157, 149, 141, 0}}, +{(unsigned char*)"Vscr", {240, 157, 146, 177, 0}}, +{(unsigned char*)"Vvdash", {226, 138, 170, 0}}, +{(unsigned char*)"Wcirc", {197, 180, 0}}, +{(unsigned char*)"Wedge", {226, 139, 128, 0}}, +{(unsigned char*)"Wfr", {240, 157, 148, 154, 0}}, +{(unsigned char*)"Wopf", {240, 157, 149, 142, 0}}, +{(unsigned char*)"Wscr", {240, 157, 146, 178, 0}}, +{(unsigned char*)"Xfr", {240, 157, 148, 155, 0}}, +{(unsigned char*)"Xi", {206, 158, 0}}, +{(unsigned char*)"Xopf", {240, 157, 149, 143, 0}}, +{(unsigned char*)"Xscr", {240, 157, 146, 179, 0}}, +{(unsigned char*)"YAcy", {208, 175, 0}}, +{(unsigned char*)"YIcy", {208, 135, 0}}, +{(unsigned char*)"YUcy", {208, 174, 0}}, +{(unsigned char*)"Yacute", {195, 157, 0}}, +{(unsigned char*)"Ycirc", {197, 182, 0}}, +{(unsigned char*)"Ycy", {208, 171, 0}}, +{(unsigned char*)"Yfr", {240, 157, 148, 156, 0}}, +{(unsigned char*)"Yopf", {240, 157, 149, 144, 0}}, +{(unsigned char*)"Yscr", {240, 157, 146, 180, 0}}, +{(unsigned char*)"Yuml", {197, 184, 0}}, +{(unsigned char*)"ZHcy", {208, 150, 0}}, +{(unsigned char*)"Zacute", {197, 185, 0}}, +{(unsigned char*)"Zcaron", {197, 189, 0}}, +{(unsigned char*)"Zcy", {208, 151, 0}}, +{(unsigned char*)"Zdot", {197, 187, 0}}, +{(unsigned char*)"ZeroWidthSpace", {226, 128, 139, 0}}, +{(unsigned char*)"Zeta", {206, 150, 0}}, +{(unsigned char*)"Zfr", {226, 132, 168, 0}}, +{(unsigned char*)"Zopf", {226, 132, 164, 0}}, +{(unsigned char*)"Zscr", {240, 157, 146, 181, 0}}, +{(unsigned char*)"aacute", {195, 161, 0}}, +{(unsigned char*)"abreve", {196, 131, 0}}, +{(unsigned char*)"ac", {226, 136, 190, 0}}, +{(unsigned char*)"acE", {226, 136, 190, 204, 179, 0}}, +{(unsigned char*)"acd", {226, 136, 191, 0}}, +{(unsigned char*)"acirc", {195, 162, 0}}, +{(unsigned char*)"acute", {194, 180, 0}}, +{(unsigned char*)"acy", {208, 176, 0}}, +{(unsigned char*)"aelig", {195, 166, 0}}, +{(unsigned char*)"af", {226, 129, 161, 0}}, +{(unsigned char*)"afr", {240, 157, 148, 158, 0}}, +{(unsigned char*)"agrave", {195, 160, 0}}, +{(unsigned char*)"alefsym", {226, 132, 181, 0}}, +{(unsigned char*)"aleph", {226, 132, 181, 0}}, +{(unsigned char*)"alpha", {206, 177, 0}}, +{(unsigned char*)"amacr", {196, 129, 0}}, +{(unsigned char*)"amalg", {226, 168, 191, 0}}, +{(unsigned char*)"amp", {38, 0}}, +{(unsigned char*)"and", {226, 136, 167, 0}}, +{(unsigned char*)"andand", {226, 169, 149, 0}}, +{(unsigned char*)"andd", {226, 169, 156, 0}}, +{(unsigned char*)"andslope", {226, 169, 152, 0}}, +{(unsigned char*)"andv", {226, 169, 154, 0}}, +{(unsigned char*)"ang", {226, 136, 160, 0}}, +{(unsigned char*)"ange", {226, 166, 164, 0}}, +{(unsigned char*)"angle", {226, 136, 160, 0}}, +{(unsigned char*)"angmsd", {226, 136, 161, 0}}, +{(unsigned char*)"angmsdaa", {226, 166, 168, 0}}, +{(unsigned char*)"angmsdab", {226, 166, 169, 0}}, +{(unsigned char*)"angmsdac", {226, 166, 170, 0}}, +{(unsigned char*)"angmsdad", {226, 166, 171, 0}}, +{(unsigned char*)"angmsdae", {226, 166, 172, 0}}, +{(unsigned char*)"angmsdaf", {226, 166, 173, 0}}, +{(unsigned char*)"angmsdag", {226, 166, 174, 0}}, +{(unsigned char*)"angmsdah", {226, 166, 175, 0}}, +{(unsigned char*)"angrt", {226, 136, 159, 0}}, +{(unsigned char*)"angrtvb", {226, 138, 190, 0}}, +{(unsigned char*)"angrtvbd", {226, 166, 157, 0}}, +{(unsigned char*)"angsph", {226, 136, 162, 0}}, +{(unsigned char*)"angst", {195, 133, 0}}, +{(unsigned char*)"angzarr", {226, 141, 188, 0}}, +{(unsigned char*)"aogon", {196, 133, 0}}, +{(unsigned char*)"aopf", {240, 157, 149, 146, 0}}, +{(unsigned char*)"ap", {226, 137, 136, 0}}, +{(unsigned char*)"apE", {226, 169, 176, 0}}, +{(unsigned char*)"apacir", {226, 169, 175, 0}}, +{(unsigned char*)"ape", {226, 137, 138, 0}}, +{(unsigned char*)"apid", {226, 137, 139, 0}}, +{(unsigned char*)"apos", {39, 0}}, +{(unsigned char*)"approx", {226, 137, 136, 0}}, +{(unsigned char*)"approxeq", {226, 137, 138, 0}}, +{(unsigned char*)"aring", {195, 165, 0}}, +{(unsigned char*)"ascr", {240, 157, 146, 182, 0}}, +{(unsigned char*)"ast", {42, 0}}, +{(unsigned char*)"asymp", {226, 137, 136, 0}}, +{(unsigned char*)"asympeq", {226, 137, 141, 0}}, +{(unsigned char*)"atilde", {195, 163, 0}}, +{(unsigned char*)"auml", {195, 164, 0}}, +{(unsigned char*)"awconint", {226, 136, 179, 0}}, +{(unsigned char*)"awint", {226, 168, 145, 0}}, +{(unsigned char*)"bNot", {226, 171, 173, 0}}, +{(unsigned char*)"backcong", {226, 137, 140, 0}}, +{(unsigned char*)"backepsilon", {207, 182, 0}}, +{(unsigned char*)"backprime", {226, 128, 181, 0}}, +{(unsigned char*)"backsim", {226, 136, 189, 0}}, +{(unsigned char*)"backsimeq", {226, 139, 141, 0}}, +{(unsigned char*)"barvee", {226, 138, 189, 0}}, +{(unsigned char*)"barwed", {226, 140, 133, 0}}, +{(unsigned char*)"barwedge", {226, 140, 133, 0}}, +{(unsigned char*)"bbrk", {226, 142, 181, 0}}, +{(unsigned char*)"bbrktbrk", {226, 142, 182, 0}}, +{(unsigned char*)"bcong", {226, 137, 140, 0}}, +{(unsigned char*)"bcy", {208, 177, 0}}, +{(unsigned char*)"bdquo", {226, 128, 158, 0}}, +{(unsigned char*)"becaus", {226, 136, 181, 0}}, +{(unsigned char*)"because", {226, 136, 181, 0}}, +{(unsigned char*)"bemptyv", {226, 166, 176, 0}}, +{(unsigned char*)"bepsi", {207, 182, 0}}, +{(unsigned char*)"bernou", {226, 132, 172, 0}}, +{(unsigned char*)"beta", {206, 178, 0}}, +{(unsigned char*)"beth", {226, 132, 182, 0}}, +{(unsigned char*)"between", {226, 137, 172, 0}}, +{(unsigned char*)"bfr", {240, 157, 148, 159, 0}}, +{(unsigned char*)"bigcap", {226, 139, 130, 0}}, +{(unsigned char*)"bigcirc", {226, 151, 175, 0}}, +{(unsigned char*)"bigcup", {226, 139, 131, 0}}, +{(unsigned char*)"bigodot", {226, 168, 128, 0}}, +{(unsigned char*)"bigoplus", {226, 168, 129, 0}}, +{(unsigned char*)"bigotimes", {226, 168, 130, 0}}, +{(unsigned char*)"bigsqcup", {226, 168, 134, 0}}, +{(unsigned char*)"bigstar", {226, 152, 133, 0}}, +{(unsigned char*)"bigtriangledown", {226, 150, 189, 0}}, +{(unsigned char*)"bigtriangleup", {226, 150, 179, 0}}, +{(unsigned char*)"biguplus", {226, 168, 132, 0}}, +{(unsigned char*)"bigvee", {226, 139, 129, 0}}, +{(unsigned char*)"bigwedge", {226, 139, 128, 0}}, +{(unsigned char*)"bkarow", {226, 164, 141, 0}}, +{(unsigned char*)"blacklozenge", {226, 167, 171, 0}}, +{(unsigned char*)"blacksquare", {226, 150, 170, 0}}, +{(unsigned char*)"blacktriangle", {226, 150, 180, 0}}, +{(unsigned char*)"blacktriangledown", {226, 150, 190, 0}}, +{(unsigned char*)"blacktriangleleft", {226, 151, 130, 0}}, +{(unsigned char*)"blacktriangleright", {226, 150, 184, 0}}, +{(unsigned char*)"blank", {226, 144, 163, 0}}, +{(unsigned char*)"blk12", {226, 150, 146, 0}}, +{(unsigned char*)"blk14", {226, 150, 145, 0}}, +{(unsigned char*)"blk34", {226, 150, 147, 0}}, +{(unsigned char*)"block", {226, 150, 136, 0}}, +{(unsigned char*)"bne", {61, 226, 131, 165, 0}}, +{(unsigned char*)"bnequiv", {226, 137, 161, 226, 131, 165, 0}}, +{(unsigned char*)"bnot", {226, 140, 144, 0}}, +{(unsigned char*)"bopf", {240, 157, 149, 147, 0}}, +{(unsigned char*)"bot", {226, 138, 165, 0}}, +{(unsigned char*)"bottom", {226, 138, 165, 0}}, +{(unsigned char*)"bowtie", {226, 139, 136, 0}}, +{(unsigned char*)"boxDL", {226, 149, 151, 0}}, +{(unsigned char*)"boxDR", {226, 149, 148, 0}}, +{(unsigned char*)"boxDl", {226, 149, 150, 0}}, +{(unsigned char*)"boxDr", {226, 149, 147, 0}}, +{(unsigned char*)"boxH", {226, 149, 144, 0}}, +{(unsigned char*)"boxHD", {226, 149, 166, 0}}, +{(unsigned char*)"boxHU", {226, 149, 169, 0}}, +{(unsigned char*)"boxHd", {226, 149, 164, 0}}, +{(unsigned char*)"boxHu", {226, 149, 167, 0}}, +{(unsigned char*)"boxUL", {226, 149, 157, 0}}, +{(unsigned char*)"boxUR", {226, 149, 154, 0}}, +{(unsigned char*)"boxUl", {226, 149, 156, 0}}, +{(unsigned char*)"boxUr", {226, 149, 153, 0}}, +{(unsigned char*)"boxV", {226, 149, 145, 0}}, +{(unsigned char*)"boxVH", {226, 149, 172, 0}}, +{(unsigned char*)"boxVL", {226, 149, 163, 0}}, +{(unsigned char*)"boxVR", {226, 149, 160, 0}}, +{(unsigned char*)"boxVh", {226, 149, 171, 0}}, +{(unsigned char*)"boxVl", {226, 149, 162, 0}}, +{(unsigned char*)"boxVr", {226, 149, 159, 0}}, +{(unsigned char*)"boxbox", {226, 167, 137, 0}}, +{(unsigned char*)"boxdL", {226, 149, 149, 0}}, +{(unsigned char*)"boxdR", {226, 149, 146, 0}}, +{(unsigned char*)"boxdl", {226, 148, 144, 0}}, +{(unsigned char*)"boxdr", {226, 148, 140, 0}}, +{(unsigned char*)"boxh", {226, 148, 128, 0}}, +{(unsigned char*)"boxhD", {226, 149, 165, 0}}, +{(unsigned char*)"boxhU", {226, 149, 168, 0}}, +{(unsigned char*)"boxhd", {226, 148, 172, 0}}, +{(unsigned char*)"boxhu", {226, 148, 180, 0}}, +{(unsigned char*)"boxminus", {226, 138, 159, 0}}, +{(unsigned char*)"boxplus", {226, 138, 158, 0}}, +{(unsigned char*)"boxtimes", {226, 138, 160, 0}}, +{(unsigned char*)"boxuL", {226, 149, 155, 0}}, +{(unsigned char*)"boxuR", {226, 149, 152, 0}}, +{(unsigned char*)"boxul", {226, 148, 152, 0}}, +{(unsigned char*)"boxur", {226, 148, 148, 0}}, +{(unsigned char*)"boxv", {226, 148, 130, 0}}, +{(unsigned char*)"boxvH", {226, 149, 170, 0}}, +{(unsigned char*)"boxvL", {226, 149, 161, 0}}, +{(unsigned char*)"boxvR", {226, 149, 158, 0}}, +{(unsigned char*)"boxvh", {226, 148, 188, 0}}, +{(unsigned char*)"boxvl", {226, 148, 164, 0}}, +{(unsigned char*)"boxvr", {226, 148, 156, 0}}, +{(unsigned char*)"bprime", {226, 128, 181, 0}}, +{(unsigned char*)"breve", {203, 152, 0}}, +{(unsigned char*)"brvbar", {194, 166, 0}}, +{(unsigned char*)"bscr", {240, 157, 146, 183, 0}}, +{(unsigned char*)"bsemi", {226, 129, 143, 0}}, +{(unsigned char*)"bsim", {226, 136, 189, 0}}, +{(unsigned char*)"bsime", {226, 139, 141, 0}}, +{(unsigned char*)"bsol", {92, 0}}, +{(unsigned char*)"bsolb", {226, 167, 133, 0}}, +{(unsigned char*)"bsolhsub", {226, 159, 136, 0}}, +{(unsigned char*)"bull", {226, 128, 162, 0}}, +{(unsigned char*)"bullet", {226, 128, 162, 0}}, +{(unsigned char*)"bump", {226, 137, 142, 0}}, +{(unsigned char*)"bumpE", {226, 170, 174, 0}}, +{(unsigned char*)"bumpe", {226, 137, 143, 0}}, +{(unsigned char*)"bumpeq", {226, 137, 143, 0}}, +{(unsigned char*)"cacute", {196, 135, 0}}, +{(unsigned char*)"cap", {226, 136, 169, 0}}, +{(unsigned char*)"capand", {226, 169, 132, 0}}, +{(unsigned char*)"capbrcup", {226, 169, 137, 0}}, +{(unsigned char*)"capcap", {226, 169, 139, 0}}, +{(unsigned char*)"capcup", {226, 169, 135, 0}}, +{(unsigned char*)"capdot", {226, 169, 128, 0}}, +{(unsigned char*)"caps", {226, 136, 169, 239, 184, 128, 0}}, +{(unsigned char*)"caret", {226, 129, 129, 0}}, +{(unsigned char*)"caron", {203, 135, 0}}, +{(unsigned char*)"ccaps", {226, 169, 141, 0}}, +{(unsigned char*)"ccaron", {196, 141, 0}}, +{(unsigned char*)"ccedil", {195, 167, 0}}, +{(unsigned char*)"ccirc", {196, 137, 0}}, +{(unsigned char*)"ccups", {226, 169, 140, 0}}, +{(unsigned char*)"ccupssm", {226, 169, 144, 0}}, +{(unsigned char*)"cdot", {196, 139, 0}}, +{(unsigned char*)"cedil", {194, 184, 0}}, +{(unsigned char*)"cemptyv", {226, 166, 178, 0}}, +{(unsigned char*)"cent", {194, 162, 0}}, +{(unsigned char*)"centerdot", {194, 183, 0}}, +{(unsigned char*)"cfr", {240, 157, 148, 160, 0}}, +{(unsigned char*)"chcy", {209, 135, 0}}, +{(unsigned char*)"check", {226, 156, 147, 0}}, +{(unsigned char*)"checkmark", {226, 156, 147, 0}}, +{(unsigned char*)"chi", {207, 135, 0}}, +{(unsigned char*)"cir", {226, 151, 139, 0}}, +{(unsigned char*)"cirE", {226, 167, 131, 0}}, +{(unsigned char*)"circ", {203, 134, 0}}, +{(unsigned char*)"circeq", {226, 137, 151, 0}}, +{(unsigned char*)"circlearrowleft", {226, 134, 186, 0}}, +{(unsigned char*)"circlearrowright", {226, 134, 187, 0}}, +{(unsigned char*)"circledR", {194, 174, 0}}, +{(unsigned char*)"circledS", {226, 147, 136, 0}}, +{(unsigned char*)"circledast", {226, 138, 155, 0}}, +{(unsigned char*)"circledcirc", {226, 138, 154, 0}}, +{(unsigned char*)"circleddash", {226, 138, 157, 0}}, +{(unsigned char*)"cire", {226, 137, 151, 0}}, +{(unsigned char*)"cirfnint", {226, 168, 144, 0}}, +{(unsigned char*)"cirmid", {226, 171, 175, 0}}, +{(unsigned char*)"cirscir", {226, 167, 130, 0}}, +{(unsigned char*)"clubs", {226, 153, 163, 0}}, +{(unsigned char*)"clubsuit", {226, 153, 163, 0}}, +{(unsigned char*)"colon", {58, 0}}, +{(unsigned char*)"colone", {226, 137, 148, 0}}, +{(unsigned char*)"coloneq", {226, 137, 148, 0}}, +{(unsigned char*)"comma", {44, 0}}, +{(unsigned char*)"commat", {64, 0}}, +{(unsigned char*)"comp", {226, 136, 129, 0}}, +{(unsigned char*)"compfn", {226, 136, 152, 0}}, +{(unsigned char*)"complement", {226, 136, 129, 0}}, +{(unsigned char*)"complexes", {226, 132, 130, 0}}, +{(unsigned char*)"cong", {226, 137, 133, 0}}, +{(unsigned char*)"congdot", {226, 169, 173, 0}}, +{(unsigned char*)"conint", {226, 136, 174, 0}}, +{(unsigned char*)"copf", {240, 157, 149, 148, 0}}, +{(unsigned char*)"coprod", {226, 136, 144, 0}}, +{(unsigned char*)"copy", {194, 169, 0}}, +{(unsigned char*)"copysr", {226, 132, 151, 0}}, +{(unsigned char*)"crarr", {226, 134, 181, 0}}, +{(unsigned char*)"cross", {226, 156, 151, 0}}, +{(unsigned char*)"cscr", {240, 157, 146, 184, 0}}, +{(unsigned char*)"csub", {226, 171, 143, 0}}, +{(unsigned char*)"csube", {226, 171, 145, 0}}, +{(unsigned char*)"csup", {226, 171, 144, 0}}, +{(unsigned char*)"csupe", {226, 171, 146, 0}}, +{(unsigned char*)"ctdot", {226, 139, 175, 0}}, +{(unsigned char*)"cudarrl", {226, 164, 184, 0}}, +{(unsigned char*)"cudarrr", {226, 164, 181, 0}}, +{(unsigned char*)"cuepr", {226, 139, 158, 0}}, +{(unsigned char*)"cuesc", {226, 139, 159, 0}}, +{(unsigned char*)"cularr", {226, 134, 182, 0}}, +{(unsigned char*)"cularrp", {226, 164, 189, 0}}, +{(unsigned char*)"cup", {226, 136, 170, 0}}, +{(unsigned char*)"cupbrcap", {226, 169, 136, 0}}, +{(unsigned char*)"cupcap", {226, 169, 134, 0}}, +{(unsigned char*)"cupcup", {226, 169, 138, 0}}, +{(unsigned char*)"cupdot", {226, 138, 141, 0}}, +{(unsigned char*)"cupor", {226, 169, 133, 0}}, +{(unsigned char*)"cups", {226, 136, 170, 239, 184, 128, 0}}, +{(unsigned char*)"curarr", {226, 134, 183, 0}}, +{(unsigned char*)"curarrm", {226, 164, 188, 0}}, +{(unsigned char*)"curlyeqprec", {226, 139, 158, 0}}, +{(unsigned char*)"curlyeqsucc", {226, 139, 159, 0}}, +{(unsigned char*)"curlyvee", {226, 139, 142, 0}}, +{(unsigned char*)"curlywedge", {226, 139, 143, 0}}, +{(unsigned char*)"curren", {194, 164, 0}}, +{(unsigned char*)"curvearrowleft", {226, 134, 182, 0}}, +{(unsigned char*)"curvearrowright", {226, 134, 183, 0}}, +{(unsigned char*)"cuvee", {226, 139, 142, 0}}, +{(unsigned char*)"cuwed", {226, 139, 143, 0}}, +{(unsigned char*)"cwconint", {226, 136, 178, 0}}, +{(unsigned char*)"cwint", {226, 136, 177, 0}}, +{(unsigned char*)"cylcty", {226, 140, 173, 0}}, +{(unsigned char*)"dArr", {226, 135, 147, 0}}, +{(unsigned char*)"dHar", {226, 165, 165, 0}}, +{(unsigned char*)"dagger", {226, 128, 160, 0}}, +{(unsigned char*)"daleth", {226, 132, 184, 0}}, +{(unsigned char*)"darr", {226, 134, 147, 0}}, +{(unsigned char*)"dash", {226, 128, 144, 0}}, +{(unsigned char*)"dashv", {226, 138, 163, 0}}, +{(unsigned char*)"dbkarow", {226, 164, 143, 0}}, +{(unsigned char*)"dblac", {203, 157, 0}}, +{(unsigned char*)"dcaron", {196, 143, 0}}, +{(unsigned char*)"dcy", {208, 180, 0}}, +{(unsigned char*)"dd", {226, 133, 134, 0}}, +{(unsigned char*)"ddagger", {226, 128, 161, 0}}, +{(unsigned char*)"ddarr", {226, 135, 138, 0}}, +{(unsigned char*)"ddotseq", {226, 169, 183, 0}}, +{(unsigned char*)"deg", {194, 176, 0}}, +{(unsigned char*)"delta", {206, 180, 0}}, +{(unsigned char*)"demptyv", {226, 166, 177, 0}}, +{(unsigned char*)"dfisht", {226, 165, 191, 0}}, +{(unsigned char*)"dfr", {240, 157, 148, 161, 0}}, +{(unsigned char*)"dharl", {226, 135, 131, 0}}, +{(unsigned char*)"dharr", {226, 135, 130, 0}}, +{(unsigned char*)"diam", {226, 139, 132, 0}}, +{(unsigned char*)"diamond", {226, 139, 132, 0}}, +{(unsigned char*)"diamondsuit", {226, 153, 166, 0}}, +{(unsigned char*)"diams", {226, 153, 166, 0}}, +{(unsigned char*)"die", {194, 168, 0}}, +{(unsigned char*)"digamma", {207, 157, 0}}, +{(unsigned char*)"disin", {226, 139, 178, 0}}, +{(unsigned char*)"div", {195, 183, 0}}, +{(unsigned char*)"divide", {195, 183, 0}}, +{(unsigned char*)"divideontimes", {226, 139, 135, 0}}, +{(unsigned char*)"divonx", {226, 139, 135, 0}}, +{(unsigned char*)"djcy", {209, 146, 0}}, +{(unsigned char*)"dlcorn", {226, 140, 158, 0}}, +{(unsigned char*)"dlcrop", {226, 140, 141, 0}}, +{(unsigned char*)"dollar", {36, 0}}, +{(unsigned char*)"dopf", {240, 157, 149, 149, 0}}, +{(unsigned char*)"dot", {203, 153, 0}}, +{(unsigned char*)"doteq", {226, 137, 144, 0}}, +{(unsigned char*)"doteqdot", {226, 137, 145, 0}}, +{(unsigned char*)"dotminus", {226, 136, 184, 0}}, +{(unsigned char*)"dotplus", {226, 136, 148, 0}}, +{(unsigned char*)"dotsquare", {226, 138, 161, 0}}, +{(unsigned char*)"doublebarwedge", {226, 140, 134, 0}}, +{(unsigned char*)"downarrow", {226, 134, 147, 0}}, +{(unsigned char*)"downdownarrows", {226, 135, 138, 0}}, +{(unsigned char*)"downharpoonleft", {226, 135, 131, 0}}, +{(unsigned char*)"downharpoonright", {226, 135, 130, 0}}, +{(unsigned char*)"drbkarow", {226, 164, 144, 0}}, +{(unsigned char*)"drcorn", {226, 140, 159, 0}}, +{(unsigned char*)"drcrop", {226, 140, 140, 0}}, +{(unsigned char*)"dscr", {240, 157, 146, 185, 0}}, +{(unsigned char*)"dscy", {209, 149, 0}}, +{(unsigned char*)"dsol", {226, 167, 182, 0}}, +{(unsigned char*)"dstrok", {196, 145, 0}}, +{(unsigned char*)"dtdot", {226, 139, 177, 0}}, +{(unsigned char*)"dtri", {226, 150, 191, 0}}, +{(unsigned char*)"dtrif", {226, 150, 190, 0}}, +{(unsigned char*)"duarr", {226, 135, 181, 0}}, +{(unsigned char*)"duhar", {226, 165, 175, 0}}, +{(unsigned char*)"dwangle", {226, 166, 166, 0}}, +{(unsigned char*)"dzcy", {209, 159, 0}}, +{(unsigned char*)"dzigrarr", {226, 159, 191, 0}}, +{(unsigned char*)"eDDot", {226, 169, 183, 0}}, +{(unsigned char*)"eDot", {226, 137, 145, 0}}, +{(unsigned char*)"eacute", {195, 169, 0}}, +{(unsigned char*)"easter", {226, 169, 174, 0}}, +{(unsigned char*)"ecaron", {196, 155, 0}}, +{(unsigned char*)"ecir", {226, 137, 150, 0}}, +{(unsigned char*)"ecirc", {195, 170, 0}}, +{(unsigned char*)"ecolon", {226, 137, 149, 0}}, +{(unsigned char*)"ecy", {209, 141, 0}}, +{(unsigned char*)"edot", {196, 151, 0}}, +{(unsigned char*)"ee", {226, 133, 135, 0}}, +{(unsigned char*)"efDot", {226, 137, 146, 0}}, +{(unsigned char*)"efr", {240, 157, 148, 162, 0}}, +{(unsigned char*)"eg", {226, 170, 154, 0}}, +{(unsigned char*)"egrave", {195, 168, 0}}, +{(unsigned char*)"egs", {226, 170, 150, 0}}, +{(unsigned char*)"egsdot", {226, 170, 152, 0}}, +{(unsigned char*)"el", {226, 170, 153, 0}}, +{(unsigned char*)"elinters", {226, 143, 167, 0}}, +{(unsigned char*)"ell", {226, 132, 147, 0}}, +{(unsigned char*)"els", {226, 170, 149, 0}}, +{(unsigned char*)"elsdot", {226, 170, 151, 0}}, +{(unsigned char*)"emacr", {196, 147, 0}}, +{(unsigned char*)"empty", {226, 136, 133, 0}}, +{(unsigned char*)"emptyset", {226, 136, 133, 0}}, +{(unsigned char*)"emptyv", {226, 136, 133, 0}}, +{(unsigned char*)"emsp", {226, 128, 131, 0}}, +{(unsigned char*)"emsp13", {226, 128, 132, 0}}, +{(unsigned char*)"emsp14", {226, 128, 133, 0}}, +{(unsigned char*)"eng", {197, 139, 0}}, +{(unsigned char*)"ensp", {226, 128, 130, 0}}, +{(unsigned char*)"eogon", {196, 153, 0}}, +{(unsigned char*)"eopf", {240, 157, 149, 150, 0}}, +{(unsigned char*)"epar", {226, 139, 149, 0}}, +{(unsigned char*)"eparsl", {226, 167, 163, 0}}, +{(unsigned char*)"eplus", {226, 169, 177, 0}}, +{(unsigned char*)"epsi", {206, 181, 0}}, +{(unsigned char*)"epsilon", {206, 181, 0}}, +{(unsigned char*)"epsiv", {207, 181, 0}}, +{(unsigned char*)"eqcirc", {226, 137, 150, 0}}, +{(unsigned char*)"eqcolon", {226, 137, 149, 0}}, +{(unsigned char*)"eqsim", {226, 137, 130, 0}}, +{(unsigned char*)"eqslantgtr", {226, 170, 150, 0}}, +{(unsigned char*)"eqslantless", {226, 170, 149, 0}}, +{(unsigned char*)"equals", {61, 0}}, +{(unsigned char*)"equest", {226, 137, 159, 0}}, +{(unsigned char*)"equiv", {226, 137, 161, 0}}, +{(unsigned char*)"equivDD", {226, 169, 184, 0}}, +{(unsigned char*)"eqvparsl", {226, 167, 165, 0}}, +{(unsigned char*)"erDot", {226, 137, 147, 0}}, +{(unsigned char*)"erarr", {226, 165, 177, 0}}, +{(unsigned char*)"escr", {226, 132, 175, 0}}, +{(unsigned char*)"esdot", {226, 137, 144, 0}}, +{(unsigned char*)"esim", {226, 137, 130, 0}}, +{(unsigned char*)"eta", {206, 183, 0}}, +{(unsigned char*)"eth", {195, 176, 0}}, +{(unsigned char*)"euml", {195, 171, 0}}, +{(unsigned char*)"euro", {226, 130, 172, 0}}, +{(unsigned char*)"excl", {33, 0}}, +{(unsigned char*)"exist", {226, 136, 131, 0}}, +{(unsigned char*)"expectation", {226, 132, 176, 0}}, +{(unsigned char*)"exponentiale", {226, 133, 135, 0}}, +{(unsigned char*)"fallingdotseq", {226, 137, 146, 0}}, +{(unsigned char*)"fcy", {209, 132, 0}}, +{(unsigned char*)"female", {226, 153, 128, 0}}, +{(unsigned char*)"ffilig", {239, 172, 131, 0}}, +{(unsigned char*)"fflig", {239, 172, 128, 0}}, +{(unsigned char*)"ffllig", {239, 172, 132, 0}}, +{(unsigned char*)"ffr", {240, 157, 148, 163, 0}}, +{(unsigned char*)"filig", {239, 172, 129, 0}}, +{(unsigned char*)"fjlig", {102, 106, 0}}, +{(unsigned char*)"flat", {226, 153, 173, 0}}, +{(unsigned char*)"fllig", {239, 172, 130, 0}}, +{(unsigned char*)"fltns", {226, 150, 177, 0}}, +{(unsigned char*)"fnof", {198, 146, 0}}, +{(unsigned char*)"fopf", {240, 157, 149, 151, 0}}, +{(unsigned char*)"forall", {226, 136, 128, 0}}, +{(unsigned char*)"fork", {226, 139, 148, 0}}, +{(unsigned char*)"forkv", {226, 171, 153, 0}}, +{(unsigned char*)"fpartint", {226, 168, 141, 0}}, +{(unsigned char*)"frac12", {194, 189, 0}}, +{(unsigned char*)"frac13", {226, 133, 147, 0}}, +{(unsigned char*)"frac14", {194, 188, 0}}, +{(unsigned char*)"frac15", {226, 133, 149, 0}}, +{(unsigned char*)"frac16", {226, 133, 153, 0}}, +{(unsigned char*)"frac18", {226, 133, 155, 0}}, +{(unsigned char*)"frac23", {226, 133, 148, 0}}, +{(unsigned char*)"frac25", {226, 133, 150, 0}}, +{(unsigned char*)"frac34", {194, 190, 0}}, +{(unsigned char*)"frac35", {226, 133, 151, 0}}, +{(unsigned char*)"frac38", {226, 133, 156, 0}}, +{(unsigned char*)"frac45", {226, 133, 152, 0}}, +{(unsigned char*)"frac56", {226, 133, 154, 0}}, +{(unsigned char*)"frac58", {226, 133, 157, 0}}, +{(unsigned char*)"frac78", {226, 133, 158, 0}}, +{(unsigned char*)"frasl", {226, 129, 132, 0}}, +{(unsigned char*)"frown", {226, 140, 162, 0}}, +{(unsigned char*)"fscr", {240, 157, 146, 187, 0}}, +{(unsigned char*)"gE", {226, 137, 167, 0}}, +{(unsigned char*)"gEl", {226, 170, 140, 0}}, +{(unsigned char*)"gacute", {199, 181, 0}}, +{(unsigned char*)"gamma", {206, 179, 0}}, +{(unsigned char*)"gammad", {207, 157, 0}}, +{(unsigned char*)"gap", {226, 170, 134, 0}}, +{(unsigned char*)"gbreve", {196, 159, 0}}, +{(unsigned char*)"gcirc", {196, 157, 0}}, +{(unsigned char*)"gcy", {208, 179, 0}}, +{(unsigned char*)"gdot", {196, 161, 0}}, +{(unsigned char*)"ge", {226, 137, 165, 0}}, +{(unsigned char*)"gel", {226, 139, 155, 0}}, +{(unsigned char*)"geq", {226, 137, 165, 0}}, +{(unsigned char*)"geqq", {226, 137, 167, 0}}, +{(unsigned char*)"geqslant", {226, 169, 190, 0}}, +{(unsigned char*)"ges", {226, 169, 190, 0}}, +{(unsigned char*)"gescc", {226, 170, 169, 0}}, +{(unsigned char*)"gesdot", {226, 170, 128, 0}}, +{(unsigned char*)"gesdoto", {226, 170, 130, 0}}, +{(unsigned char*)"gesdotol", {226, 170, 132, 0}}, +{(unsigned char*)"gesl", {226, 139, 155, 239, 184, 128, 0}}, +{(unsigned char*)"gesles", {226, 170, 148, 0}}, +{(unsigned char*)"gfr", {240, 157, 148, 164, 0}}, +{(unsigned char*)"gg", {226, 137, 171, 0}}, +{(unsigned char*)"ggg", {226, 139, 153, 0}}, +{(unsigned char*)"gimel", {226, 132, 183, 0}}, +{(unsigned char*)"gjcy", {209, 147, 0}}, +{(unsigned char*)"gl", {226, 137, 183, 0}}, +{(unsigned char*)"glE", {226, 170, 146, 0}}, +{(unsigned char*)"gla", {226, 170, 165, 0}}, +{(unsigned char*)"glj", {226, 170, 164, 0}}, +{(unsigned char*)"gnE", {226, 137, 169, 0}}, +{(unsigned char*)"gnap", {226, 170, 138, 0}}, +{(unsigned char*)"gnapprox", {226, 170, 138, 0}}, +{(unsigned char*)"gne", {226, 170, 136, 0}}, +{(unsigned char*)"gneq", {226, 170, 136, 0}}, +{(unsigned char*)"gneqq", {226, 137, 169, 0}}, +{(unsigned char*)"gnsim", {226, 139, 167, 0}}, +{(unsigned char*)"gopf", {240, 157, 149, 152, 0}}, +{(unsigned char*)"grave", {96, 0}}, +{(unsigned char*)"gscr", {226, 132, 138, 0}}, +{(unsigned char*)"gsim", {226, 137, 179, 0}}, +{(unsigned char*)"gsime", {226, 170, 142, 0}}, +{(unsigned char*)"gsiml", {226, 170, 144, 0}}, +{(unsigned char*)"gt", {62, 0}}, +{(unsigned char*)"gtcc", {226, 170, 167, 0}}, +{(unsigned char*)"gtcir", {226, 169, 186, 0}}, +{(unsigned char*)"gtdot", {226, 139, 151, 0}}, +{(unsigned char*)"gtlPar", {226, 166, 149, 0}}, +{(unsigned char*)"gtquest", {226, 169, 188, 0}}, +{(unsigned char*)"gtrapprox", {226, 170, 134, 0}}, +{(unsigned char*)"gtrarr", {226, 165, 184, 0}}, +{(unsigned char*)"gtrdot", {226, 139, 151, 0}}, +{(unsigned char*)"gtreqless", {226, 139, 155, 0}}, +{(unsigned char*)"gtreqqless", {226, 170, 140, 0}}, +{(unsigned char*)"gtrless", {226, 137, 183, 0}}, +{(unsigned char*)"gtrsim", {226, 137, 179, 0}}, +{(unsigned char*)"gvertneqq", {226, 137, 169, 239, 184, 128, 0}}, +{(unsigned char*)"gvnE", {226, 137, 169, 239, 184, 128, 0}}, +{(unsigned char*)"hArr", {226, 135, 148, 0}}, +{(unsigned char*)"hairsp", {226, 128, 138, 0}}, +{(unsigned char*)"half", {194, 189, 0}}, +{(unsigned char*)"hamilt", {226, 132, 139, 0}}, +{(unsigned char*)"hardcy", {209, 138, 0}}, +{(unsigned char*)"harr", {226, 134, 148, 0}}, +{(unsigned char*)"harrcir", {226, 165, 136, 0}}, +{(unsigned char*)"harrw", {226, 134, 173, 0}}, +{(unsigned char*)"hbar", {226, 132, 143, 0}}, +{(unsigned char*)"hcirc", {196, 165, 0}}, +{(unsigned char*)"hearts", {226, 153, 165, 0}}, +{(unsigned char*)"heartsuit", {226, 153, 165, 0}}, +{(unsigned char*)"hellip", {226, 128, 166, 0}}, +{(unsigned char*)"hercon", {226, 138, 185, 0}}, +{(unsigned char*)"hfr", {240, 157, 148, 165, 0}}, +{(unsigned char*)"hksearow", {226, 164, 165, 0}}, +{(unsigned char*)"hkswarow", {226, 164, 166, 0}}, +{(unsigned char*)"hoarr", {226, 135, 191, 0}}, +{(unsigned char*)"homtht", {226, 136, 187, 0}}, +{(unsigned char*)"hookleftarrow", {226, 134, 169, 0}}, +{(unsigned char*)"hookrightarrow", {226, 134, 170, 0}}, +{(unsigned char*)"hopf", {240, 157, 149, 153, 0}}, +{(unsigned char*)"horbar", {226, 128, 149, 0}}, +{(unsigned char*)"hscr", {240, 157, 146, 189, 0}}, +{(unsigned char*)"hslash", {226, 132, 143, 0}}, +{(unsigned char*)"hstrok", {196, 167, 0}}, +{(unsigned char*)"hybull", {226, 129, 131, 0}}, +{(unsigned char*)"hyphen", {226, 128, 144, 0}}, +{(unsigned char*)"iacute", {195, 173, 0}}, +{(unsigned char*)"ic", {226, 129, 163, 0}}, +{(unsigned char*)"icirc", {195, 174, 0}}, +{(unsigned char*)"icy", {208, 184, 0}}, +{(unsigned char*)"iecy", {208, 181, 0}}, +{(unsigned char*)"iexcl", {194, 161, 0}}, +{(unsigned char*)"iff", {226, 135, 148, 0}}, +{(unsigned char*)"ifr", {240, 157, 148, 166, 0}}, +{(unsigned char*)"igrave", {195, 172, 0}}, +{(unsigned char*)"ii", {226, 133, 136, 0}}, +{(unsigned char*)"iiiint", {226, 168, 140, 0}}, +{(unsigned char*)"iiint", {226, 136, 173, 0}}, +{(unsigned char*)"iinfin", {226, 167, 156, 0}}, +{(unsigned char*)"iiota", {226, 132, 169, 0}}, +{(unsigned char*)"ijlig", {196, 179, 0}}, +{(unsigned char*)"imacr", {196, 171, 0}}, +{(unsigned char*)"image", {226, 132, 145, 0}}, +{(unsigned char*)"imagline", {226, 132, 144, 0}}, +{(unsigned char*)"imagpart", {226, 132, 145, 0}}, +{(unsigned char*)"imath", {196, 177, 0}}, +{(unsigned char*)"imof", {226, 138, 183, 0}}, +{(unsigned char*)"imped", {198, 181, 0}}, +{(unsigned char*)"in", {226, 136, 136, 0}}, +{(unsigned char*)"incare", {226, 132, 133, 0}}, +{(unsigned char*)"infin", {226, 136, 158, 0}}, +{(unsigned char*)"infintie", {226, 167, 157, 0}}, +{(unsigned char*)"inodot", {196, 177, 0}}, +{(unsigned char*)"int", {226, 136, 171, 0}}, +{(unsigned char*)"intcal", {226, 138, 186, 0}}, +{(unsigned char*)"integers", {226, 132, 164, 0}}, +{(unsigned char*)"intercal", {226, 138, 186, 0}}, +{(unsigned char*)"intlarhk", {226, 168, 151, 0}}, +{(unsigned char*)"intprod", {226, 168, 188, 0}}, +{(unsigned char*)"iocy", {209, 145, 0}}, +{(unsigned char*)"iogon", {196, 175, 0}}, +{(unsigned char*)"iopf", {240, 157, 149, 154, 0}}, +{(unsigned char*)"iota", {206, 185, 0}}, +{(unsigned char*)"iprod", {226, 168, 188, 0}}, +{(unsigned char*)"iquest", {194, 191, 0}}, +{(unsigned char*)"iscr", {240, 157, 146, 190, 0}}, +{(unsigned char*)"isin", {226, 136, 136, 0}}, +{(unsigned char*)"isinE", {226, 139, 185, 0}}, +{(unsigned char*)"isindot", {226, 139, 181, 0}}, +{(unsigned char*)"isins", {226, 139, 180, 0}}, +{(unsigned char*)"isinsv", {226, 139, 179, 0}}, +{(unsigned char*)"isinv", {226, 136, 136, 0}}, +{(unsigned char*)"it", {226, 129, 162, 0}}, +{(unsigned char*)"itilde", {196, 169, 0}}, +{(unsigned char*)"iukcy", {209, 150, 0}}, +{(unsigned char*)"iuml", {195, 175, 0}}, +{(unsigned char*)"jcirc", {196, 181, 0}}, +{(unsigned char*)"jcy", {208, 185, 0}}, +{(unsigned char*)"jfr", {240, 157, 148, 167, 0}}, +{(unsigned char*)"jmath", {200, 183, 0}}, +{(unsigned char*)"jopf", {240, 157, 149, 155, 0}}, +{(unsigned char*)"jscr", {240, 157, 146, 191, 0}}, +{(unsigned char*)"jsercy", {209, 152, 0}}, +{(unsigned char*)"jukcy", {209, 148, 0}}, +{(unsigned char*)"kappa", {206, 186, 0}}, +{(unsigned char*)"kappav", {207, 176, 0}}, +{(unsigned char*)"kcedil", {196, 183, 0}}, +{(unsigned char*)"kcy", {208, 186, 0}}, +{(unsigned char*)"kfr", {240, 157, 148, 168, 0}}, +{(unsigned char*)"kgreen", {196, 184, 0}}, +{(unsigned char*)"khcy", {209, 133, 0}}, +{(unsigned char*)"kjcy", {209, 156, 0}}, +{(unsigned char*)"kopf", {240, 157, 149, 156, 0}}, +{(unsigned char*)"kscr", {240, 157, 147, 128, 0}}, +{(unsigned char*)"lAarr", {226, 135, 154, 0}}, +{(unsigned char*)"lArr", {226, 135, 144, 0}}, +{(unsigned char*)"lAtail", {226, 164, 155, 0}}, +{(unsigned char*)"lBarr", {226, 164, 142, 0}}, +{(unsigned char*)"lE", {226, 137, 166, 0}}, +{(unsigned char*)"lEg", {226, 170, 139, 0}}, +{(unsigned char*)"lHar", {226, 165, 162, 0}}, +{(unsigned char*)"lacute", {196, 186, 0}}, +{(unsigned char*)"laemptyv", {226, 166, 180, 0}}, +{(unsigned char*)"lagran", {226, 132, 146, 0}}, +{(unsigned char*)"lambda", {206, 187, 0}}, +{(unsigned char*)"lang", {226, 159, 168, 0}}, +{(unsigned char*)"langd", {226, 166, 145, 0}}, +{(unsigned char*)"langle", {226, 159, 168, 0}}, +{(unsigned char*)"lap", {226, 170, 133, 0}}, +{(unsigned char*)"laquo", {194, 171, 0}}, +{(unsigned char*)"larr", {226, 134, 144, 0}}, +{(unsigned char*)"larrb", {226, 135, 164, 0}}, +{(unsigned char*)"larrbfs", {226, 164, 159, 0}}, +{(unsigned char*)"larrfs", {226, 164, 157, 0}}, +{(unsigned char*)"larrhk", {226, 134, 169, 0}}, +{(unsigned char*)"larrlp", {226, 134, 171, 0}}, +{(unsigned char*)"larrpl", {226, 164, 185, 0}}, +{(unsigned char*)"larrsim", {226, 165, 179, 0}}, +{(unsigned char*)"larrtl", {226, 134, 162, 0}}, +{(unsigned char*)"lat", {226, 170, 171, 0}}, +{(unsigned char*)"latail", {226, 164, 153, 0}}, +{(unsigned char*)"late", {226, 170, 173, 0}}, +{(unsigned char*)"lates", {226, 170, 173, 239, 184, 128, 0}}, +{(unsigned char*)"lbarr", {226, 164, 140, 0}}, +{(unsigned char*)"lbbrk", {226, 157, 178, 0}}, +{(unsigned char*)"lbrace", {123, 0}}, +{(unsigned char*)"lbrack", {91, 0}}, +{(unsigned char*)"lbrke", {226, 166, 139, 0}}, +{(unsigned char*)"lbrksld", {226, 166, 143, 0}}, +{(unsigned char*)"lbrkslu", {226, 166, 141, 0}}, +{(unsigned char*)"lcaron", {196, 190, 0}}, +{(unsigned char*)"lcedil", {196, 188, 0}}, +{(unsigned char*)"lceil", {226, 140, 136, 0}}, +{(unsigned char*)"lcub", {123, 0}}, +{(unsigned char*)"lcy", {208, 187, 0}}, +{(unsigned char*)"ldca", {226, 164, 182, 0}}, +{(unsigned char*)"ldquo", {226, 128, 156, 0}}, +{(unsigned char*)"ldquor", {226, 128, 158, 0}}, +{(unsigned char*)"ldrdhar", {226, 165, 167, 0}}, +{(unsigned char*)"ldrushar", {226, 165, 139, 0}}, +{(unsigned char*)"ldsh", {226, 134, 178, 0}}, +{(unsigned char*)"le", {226, 137, 164, 0}}, +{(unsigned char*)"leftarrow", {226, 134, 144, 0}}, +{(unsigned char*)"leftarrowtail", {226, 134, 162, 0}}, +{(unsigned char*)"leftharpoondown", {226, 134, 189, 0}}, +{(unsigned char*)"leftharpoonup", {226, 134, 188, 0}}, +{(unsigned char*)"leftleftarrows", {226, 135, 135, 0}}, +{(unsigned char*)"leftrightarrow", {226, 134, 148, 0}}, +{(unsigned char*)"leftrightarrows", {226, 135, 134, 0}}, +{(unsigned char*)"leftrightharpoons", {226, 135, 139, 0}}, +{(unsigned char*)"leftrightsquigarrow", {226, 134, 173, 0}}, +{(unsigned char*)"leftthreetimes", {226, 139, 139, 0}}, +{(unsigned char*)"leg", {226, 139, 154, 0}}, +{(unsigned char*)"leq", {226, 137, 164, 0}}, +{(unsigned char*)"leqq", {226, 137, 166, 0}}, +{(unsigned char*)"leqslant", {226, 169, 189, 0}}, +{(unsigned char*)"les", {226, 169, 189, 0}}, +{(unsigned char*)"lescc", {226, 170, 168, 0}}, +{(unsigned char*)"lesdot", {226, 169, 191, 0}}, +{(unsigned char*)"lesdoto", {226, 170, 129, 0}}, +{(unsigned char*)"lesdotor", {226, 170, 131, 0}}, +{(unsigned char*)"lesg", {226, 139, 154, 239, 184, 128, 0}}, +{(unsigned char*)"lesges", {226, 170, 147, 0}}, +{(unsigned char*)"lessapprox", {226, 170, 133, 0}}, +{(unsigned char*)"lessdot", {226, 139, 150, 0}}, +{(unsigned char*)"lesseqgtr", {226, 139, 154, 0}}, +{(unsigned char*)"lesseqqgtr", {226, 170, 139, 0}}, +{(unsigned char*)"lessgtr", {226, 137, 182, 0}}, +{(unsigned char*)"lesssim", {226, 137, 178, 0}}, +{(unsigned char*)"lfisht", {226, 165, 188, 0}}, +{(unsigned char*)"lfloor", {226, 140, 138, 0}}, +{(unsigned char*)"lfr", {240, 157, 148, 169, 0}}, +{(unsigned char*)"lg", {226, 137, 182, 0}}, +{(unsigned char*)"lgE", {226, 170, 145, 0}}, +{(unsigned char*)"lhard", {226, 134, 189, 0}}, +{(unsigned char*)"lharu", {226, 134, 188, 0}}, +{(unsigned char*)"lharul", {226, 165, 170, 0}}, +{(unsigned char*)"lhblk", {226, 150, 132, 0}}, +{(unsigned char*)"ljcy", {209, 153, 0}}, +{(unsigned char*)"ll", {226, 137, 170, 0}}, +{(unsigned char*)"llarr", {226, 135, 135, 0}}, +{(unsigned char*)"llcorner", {226, 140, 158, 0}}, +{(unsigned char*)"llhard", {226, 165, 171, 0}}, +{(unsigned char*)"lltri", {226, 151, 186, 0}}, +{(unsigned char*)"lmidot", {197, 128, 0}}, +{(unsigned char*)"lmoust", {226, 142, 176, 0}}, +{(unsigned char*)"lmoustache", {226, 142, 176, 0}}, +{(unsigned char*)"lnE", {226, 137, 168, 0}}, +{(unsigned char*)"lnap", {226, 170, 137, 0}}, +{(unsigned char*)"lnapprox", {226, 170, 137, 0}}, +{(unsigned char*)"lne", {226, 170, 135, 0}}, +{(unsigned char*)"lneq", {226, 170, 135, 0}}, +{(unsigned char*)"lneqq", {226, 137, 168, 0}}, +{(unsigned char*)"lnsim", {226, 139, 166, 0}}, +{(unsigned char*)"loang", {226, 159, 172, 0}}, +{(unsigned char*)"loarr", {226, 135, 189, 0}}, +{(unsigned char*)"lobrk", {226, 159, 166, 0}}, +{(unsigned char*)"longleftarrow", {226, 159, 181, 0}}, +{(unsigned char*)"longleftrightarrow", {226, 159, 183, 0}}, +{(unsigned char*)"longmapsto", {226, 159, 188, 0}}, +{(unsigned char*)"longrightarrow", {226, 159, 182, 0}}, +{(unsigned char*)"looparrowleft", {226, 134, 171, 0}}, +{(unsigned char*)"looparrowright", {226, 134, 172, 0}}, +{(unsigned char*)"lopar", {226, 166, 133, 0}}, +{(unsigned char*)"lopf", {240, 157, 149, 157, 0}}, +{(unsigned char*)"loplus", {226, 168, 173, 0}}, +{(unsigned char*)"lotimes", {226, 168, 180, 0}}, +{(unsigned char*)"lowast", {226, 136, 151, 0}}, +{(unsigned char*)"lowbar", {95, 0}}, +{(unsigned char*)"loz", {226, 151, 138, 0}}, +{(unsigned char*)"lozenge", {226, 151, 138, 0}}, +{(unsigned char*)"lozf", {226, 167, 171, 0}}, +{(unsigned char*)"lpar", {40, 0}}, +{(unsigned char*)"lparlt", {226, 166, 147, 0}}, +{(unsigned char*)"lrarr", {226, 135, 134, 0}}, +{(unsigned char*)"lrcorner", {226, 140, 159, 0}}, +{(unsigned char*)"lrhar", {226, 135, 139, 0}}, +{(unsigned char*)"lrhard", {226, 165, 173, 0}}, +{(unsigned char*)"lrm", {226, 128, 142, 0}}, +{(unsigned char*)"lrtri", {226, 138, 191, 0}}, +{(unsigned char*)"lsaquo", {226, 128, 185, 0}}, +{(unsigned char*)"lscr", {240, 157, 147, 129, 0}}, +{(unsigned char*)"lsh", {226, 134, 176, 0}}, +{(unsigned char*)"lsim", {226, 137, 178, 0}}, +{(unsigned char*)"lsime", {226, 170, 141, 0}}, +{(unsigned char*)"lsimg", {226, 170, 143, 0}}, +{(unsigned char*)"lsqb", {91, 0}}, +{(unsigned char*)"lsquo", {226, 128, 152, 0}}, +{(unsigned char*)"lsquor", {226, 128, 154, 0}}, +{(unsigned char*)"lstrok", {197, 130, 0}}, +{(unsigned char*)"lt", {60, 0}}, +{(unsigned char*)"ltcc", {226, 170, 166, 0}}, +{(unsigned char*)"ltcir", {226, 169, 185, 0}}, +{(unsigned char*)"ltdot", {226, 139, 150, 0}}, +{(unsigned char*)"lthree", {226, 139, 139, 0}}, +{(unsigned char*)"ltimes", {226, 139, 137, 0}}, +{(unsigned char*)"ltlarr", {226, 165, 182, 0}}, +{(unsigned char*)"ltquest", {226, 169, 187, 0}}, +{(unsigned char*)"ltrPar", {226, 166, 150, 0}}, +{(unsigned char*)"ltri", {226, 151, 131, 0}}, +{(unsigned char*)"ltrie", {226, 138, 180, 0}}, +{(unsigned char*)"ltrif", {226, 151, 130, 0}}, +{(unsigned char*)"lurdshar", {226, 165, 138, 0}}, +{(unsigned char*)"luruhar", {226, 165, 166, 0}}, +{(unsigned char*)"lvertneqq", {226, 137, 168, 239, 184, 128, 0}}, +{(unsigned char*)"lvnE", {226, 137, 168, 239, 184, 128, 0}}, +{(unsigned char*)"mDDot", {226, 136, 186, 0}}, +{(unsigned char*)"macr", {194, 175, 0}}, +{(unsigned char*)"male", {226, 153, 130, 0}}, +{(unsigned char*)"malt", {226, 156, 160, 0}}, +{(unsigned char*)"maltese", {226, 156, 160, 0}}, +{(unsigned char*)"map", {226, 134, 166, 0}}, +{(unsigned char*)"mapsto", {226, 134, 166, 0}}, +{(unsigned char*)"mapstodown", {226, 134, 167, 0}}, +{(unsigned char*)"mapstoleft", {226, 134, 164, 0}}, +{(unsigned char*)"mapstoup", {226, 134, 165, 0}}, +{(unsigned char*)"marker", {226, 150, 174, 0}}, +{(unsigned char*)"mcomma", {226, 168, 169, 0}}, +{(unsigned char*)"mcy", {208, 188, 0}}, +{(unsigned char*)"mdash", {226, 128, 148, 0}}, +{(unsigned char*)"measuredangle", {226, 136, 161, 0}}, +{(unsigned char*)"mfr", {240, 157, 148, 170, 0}}, +{(unsigned char*)"mho", {226, 132, 167, 0}}, +{(unsigned char*)"micro", {194, 181, 0}}, +{(unsigned char*)"mid", {226, 136, 163, 0}}, +{(unsigned char*)"midast", {42, 0}}, +{(unsigned char*)"midcir", {226, 171, 176, 0}}, +{(unsigned char*)"middot", {194, 183, 0}}, +{(unsigned char*)"minus", {226, 136, 146, 0}}, +{(unsigned char*)"minusb", {226, 138, 159, 0}}, +{(unsigned char*)"minusd", {226, 136, 184, 0}}, +{(unsigned char*)"minusdu", {226, 168, 170, 0}}, +{(unsigned char*)"mlcp", {226, 171, 155, 0}}, +{(unsigned char*)"mldr", {226, 128, 166, 0}}, +{(unsigned char*)"mnplus", {226, 136, 147, 0}}, +{(unsigned char*)"models", {226, 138, 167, 0}}, +{(unsigned char*)"mopf", {240, 157, 149, 158, 0}}, +{(unsigned char*)"mp", {226, 136, 147, 0}}, +{(unsigned char*)"mscr", {240, 157, 147, 130, 0}}, +{(unsigned char*)"mstpos", {226, 136, 190, 0}}, +{(unsigned char*)"mu", {206, 188, 0}}, +{(unsigned char*)"multimap", {226, 138, 184, 0}}, +{(unsigned char*)"mumap", {226, 138, 184, 0}}, +{(unsigned char*)"nGg", {226, 139, 153, 204, 184, 0}}, +{(unsigned char*)"nGt", {226, 137, 171, 226, 131, 146, 0}}, +{(unsigned char*)"nGtv", {226, 137, 171, 204, 184, 0}}, +{(unsigned char*)"nLeftarrow", {226, 135, 141, 0}}, +{(unsigned char*)"nLeftrightarrow", {226, 135, 142, 0}}, +{(unsigned char*)"nLl", {226, 139, 152, 204, 184, 0}}, +{(unsigned char*)"nLt", {226, 137, 170, 226, 131, 146, 0}}, +{(unsigned char*)"nLtv", {226, 137, 170, 204, 184, 0}}, +{(unsigned char*)"nRightarrow", {226, 135, 143, 0}}, +{(unsigned char*)"nVDash", {226, 138, 175, 0}}, +{(unsigned char*)"nVdash", {226, 138, 174, 0}}, +{(unsigned char*)"nabla", {226, 136, 135, 0}}, +{(unsigned char*)"nacute", {197, 132, 0}}, +{(unsigned char*)"nang", {226, 136, 160, 226, 131, 146, 0}}, +{(unsigned char*)"nap", {226, 137, 137, 0}}, +{(unsigned char*)"napE", {226, 169, 176, 204, 184, 0}}, +{(unsigned char*)"napid", {226, 137, 139, 204, 184, 0}}, +{(unsigned char*)"napos", {197, 137, 0}}, +{(unsigned char*)"napprox", {226, 137, 137, 0}}, +{(unsigned char*)"natur", {226, 153, 174, 0}}, +{(unsigned char*)"natural", {226, 153, 174, 0}}, +{(unsigned char*)"naturals", {226, 132, 149, 0}}, +{(unsigned char*)"nbsp", {194, 160, 0}}, +{(unsigned char*)"nbump", {226, 137, 142, 204, 184, 0}}, +{(unsigned char*)"nbumpe", {226, 137, 143, 204, 184, 0}}, +{(unsigned char*)"ncap", {226, 169, 131, 0}}, +{(unsigned char*)"ncaron", {197, 136, 0}}, +{(unsigned char*)"ncedil", {197, 134, 0}}, +{(unsigned char*)"ncong", {226, 137, 135, 0}}, +{(unsigned char*)"ncongdot", {226, 169, 173, 204, 184, 0}}, +{(unsigned char*)"ncup", {226, 169, 130, 0}}, +{(unsigned char*)"ncy", {208, 189, 0}}, +{(unsigned char*)"ndash", {226, 128, 147, 0}}, +{(unsigned char*)"ne", {226, 137, 160, 0}}, +{(unsigned char*)"neArr", {226, 135, 151, 0}}, +{(unsigned char*)"nearhk", {226, 164, 164, 0}}, +{(unsigned char*)"nearr", {226, 134, 151, 0}}, +{(unsigned char*)"nearrow", {226, 134, 151, 0}}, +{(unsigned char*)"nedot", {226, 137, 144, 204, 184, 0}}, +{(unsigned char*)"nequiv", {226, 137, 162, 0}}, +{(unsigned char*)"nesear", {226, 164, 168, 0}}, +{(unsigned char*)"nesim", {226, 137, 130, 204, 184, 0}}, +{(unsigned char*)"nexist", {226, 136, 132, 0}}, +{(unsigned char*)"nexists", {226, 136, 132, 0}}, +{(unsigned char*)"nfr", {240, 157, 148, 171, 0}}, +{(unsigned char*)"ngE", {226, 137, 167, 204, 184, 0}}, +{(unsigned char*)"nge", {226, 137, 177, 0}}, +{(unsigned char*)"ngeq", {226, 137, 177, 0}}, +{(unsigned char*)"ngeqq", {226, 137, 167, 204, 184, 0}}, +{(unsigned char*)"ngeqslant", {226, 169, 190, 204, 184, 0}}, +{(unsigned char*)"nges", {226, 169, 190, 204, 184, 0}}, +{(unsigned char*)"ngsim", {226, 137, 181, 0}}, +{(unsigned char*)"ngt", {226, 137, 175, 0}}, +{(unsigned char*)"ngtr", {226, 137, 175, 0}}, +{(unsigned char*)"nhArr", {226, 135, 142, 0}}, +{(unsigned char*)"nharr", {226, 134, 174, 0}}, +{(unsigned char*)"nhpar", {226, 171, 178, 0}}, +{(unsigned char*)"ni", {226, 136, 139, 0}}, +{(unsigned char*)"nis", {226, 139, 188, 0}}, +{(unsigned char*)"nisd", {226, 139, 186, 0}}, +{(unsigned char*)"niv", {226, 136, 139, 0}}, +{(unsigned char*)"njcy", {209, 154, 0}}, +{(unsigned char*)"nlArr", {226, 135, 141, 0}}, +{(unsigned char*)"nlE", {226, 137, 166, 204, 184, 0}}, +{(unsigned char*)"nlarr", {226, 134, 154, 0}}, +{(unsigned char*)"nldr", {226, 128, 165, 0}}, +{(unsigned char*)"nle", {226, 137, 176, 0}}, +{(unsigned char*)"nleftarrow", {226, 134, 154, 0}}, +{(unsigned char*)"nleftrightarrow", {226, 134, 174, 0}}, +{(unsigned char*)"nleq", {226, 137, 176, 0}}, +{(unsigned char*)"nleqq", {226, 137, 166, 204, 184, 0}}, +{(unsigned char*)"nleqslant", {226, 169, 189, 204, 184, 0}}, +{(unsigned char*)"nles", {226, 169, 189, 204, 184, 0}}, +{(unsigned char*)"nless", {226, 137, 174, 0}}, +{(unsigned char*)"nlsim", {226, 137, 180, 0}}, +{(unsigned char*)"nlt", {226, 137, 174, 0}}, +{(unsigned char*)"nltri", {226, 139, 170, 0}}, +{(unsigned char*)"nltrie", {226, 139, 172, 0}}, +{(unsigned char*)"nmid", {226, 136, 164, 0}}, +{(unsigned char*)"nopf", {240, 157, 149, 159, 0}}, +{(unsigned char*)"not", {194, 172, 0}}, +{(unsigned char*)"notin", {226, 136, 137, 0}}, +{(unsigned char*)"notinE", {226, 139, 185, 204, 184, 0}}, +{(unsigned char*)"notindot", {226, 139, 181, 204, 184, 0}}, +{(unsigned char*)"notinva", {226, 136, 137, 0}}, +{(unsigned char*)"notinvb", {226, 139, 183, 0}}, +{(unsigned char*)"notinvc", {226, 139, 182, 0}}, +{(unsigned char*)"notni", {226, 136, 140, 0}}, +{(unsigned char*)"notniva", {226, 136, 140, 0}}, +{(unsigned char*)"notnivb", {226, 139, 190, 0}}, +{(unsigned char*)"notnivc", {226, 139, 189, 0}}, +{(unsigned char*)"npar", {226, 136, 166, 0}}, +{(unsigned char*)"nparallel", {226, 136, 166, 0}}, +{(unsigned char*)"nparsl", {226, 171, 189, 226, 131, 165, 0}}, +{(unsigned char*)"npart", {226, 136, 130, 204, 184, 0}}, +{(unsigned char*)"npolint", {226, 168, 148, 0}}, +{(unsigned char*)"npr", {226, 138, 128, 0}}, +{(unsigned char*)"nprcue", {226, 139, 160, 0}}, +{(unsigned char*)"npre", {226, 170, 175, 204, 184, 0}}, +{(unsigned char*)"nprec", {226, 138, 128, 0}}, +{(unsigned char*)"npreceq", {226, 170, 175, 204, 184, 0}}, +{(unsigned char*)"nrArr", {226, 135, 143, 0}}, +{(unsigned char*)"nrarr", {226, 134, 155, 0}}, +{(unsigned char*)"nrarrc", {226, 164, 179, 204, 184, 0}}, +{(unsigned char*)"nrarrw", {226, 134, 157, 204, 184, 0}}, +{(unsigned char*)"nrightarrow", {226, 134, 155, 0}}, +{(unsigned char*)"nrtri", {226, 139, 171, 0}}, +{(unsigned char*)"nrtrie", {226, 139, 173, 0}}, +{(unsigned char*)"nsc", {226, 138, 129, 0}}, +{(unsigned char*)"nsccue", {226, 139, 161, 0}}, +{(unsigned char*)"nsce", {226, 170, 176, 204, 184, 0}}, +{(unsigned char*)"nscr", {240, 157, 147, 131, 0}}, +{(unsigned char*)"nshortmid", {226, 136, 164, 0}}, +{(unsigned char*)"nshortparallel", {226, 136, 166, 0}}, +{(unsigned char*)"nsim", {226, 137, 129, 0}}, +{(unsigned char*)"nsime", {226, 137, 132, 0}}, +{(unsigned char*)"nsimeq", {226, 137, 132, 0}}, +{(unsigned char*)"nsmid", {226, 136, 164, 0}}, +{(unsigned char*)"nspar", {226, 136, 166, 0}}, +{(unsigned char*)"nsqsube", {226, 139, 162, 0}}, +{(unsigned char*)"nsqsupe", {226, 139, 163, 0}}, +{(unsigned char*)"nsub", {226, 138, 132, 0}}, +{(unsigned char*)"nsubE", {226, 171, 133, 204, 184, 0}}, +{(unsigned char*)"nsube", {226, 138, 136, 0}}, +{(unsigned char*)"nsubset", {226, 138, 130, 226, 131, 146, 0}}, +{(unsigned char*)"nsubseteq", {226, 138, 136, 0}}, +{(unsigned char*)"nsubseteqq", {226, 171, 133, 204, 184, 0}}, +{(unsigned char*)"nsucc", {226, 138, 129, 0}}, +{(unsigned char*)"nsucceq", {226, 170, 176, 204, 184, 0}}, +{(unsigned char*)"nsup", {226, 138, 133, 0}}, +{(unsigned char*)"nsupE", {226, 171, 134, 204, 184, 0}}, +{(unsigned char*)"nsupe", {226, 138, 137, 0}}, +{(unsigned char*)"nsupset", {226, 138, 131, 226, 131, 146, 0}}, +{(unsigned char*)"nsupseteq", {226, 138, 137, 0}}, +{(unsigned char*)"nsupseteqq", {226, 171, 134, 204, 184, 0}}, +{(unsigned char*)"ntgl", {226, 137, 185, 0}}, +{(unsigned char*)"ntilde", {195, 177, 0}}, +{(unsigned char*)"ntlg", {226, 137, 184, 0}}, +{(unsigned char*)"ntriangleleft", {226, 139, 170, 0}}, +{(unsigned char*)"ntrianglelefteq", {226, 139, 172, 0}}, +{(unsigned char*)"ntriangleright", {226, 139, 171, 0}}, +{(unsigned char*)"ntrianglerighteq", {226, 139, 173, 0}}, +{(unsigned char*)"nu", {206, 189, 0}}, +{(unsigned char*)"num", {35, 0}}, +{(unsigned char*)"numero", {226, 132, 150, 0}}, +{(unsigned char*)"numsp", {226, 128, 135, 0}}, +{(unsigned char*)"nvDash", {226, 138, 173, 0}}, +{(unsigned char*)"nvHarr", {226, 164, 132, 0}}, +{(unsigned char*)"nvap", {226, 137, 141, 226, 131, 146, 0}}, +{(unsigned char*)"nvdash", {226, 138, 172, 0}}, +{(unsigned char*)"nvge", {226, 137, 165, 226, 131, 146, 0}}, +{(unsigned char*)"nvgt", {62, 226, 131, 146, 0}}, +{(unsigned char*)"nvinfin", {226, 167, 158, 0}}, +{(unsigned char*)"nvlArr", {226, 164, 130, 0}}, +{(unsigned char*)"nvle", {226, 137, 164, 226, 131, 146, 0}}, +{(unsigned char*)"nvlt", {60, 226, 131, 146, 0}}, +{(unsigned char*)"nvltrie", {226, 138, 180, 226, 131, 146, 0}}, +{(unsigned char*)"nvrArr", {226, 164, 131, 0}}, +{(unsigned char*)"nvrtrie", {226, 138, 181, 226, 131, 146, 0}}, +{(unsigned char*)"nvsim", {226, 136, 188, 226, 131, 146, 0}}, +{(unsigned char*)"nwArr", {226, 135, 150, 0}}, +{(unsigned char*)"nwarhk", {226, 164, 163, 0}}, +{(unsigned char*)"nwarr", {226, 134, 150, 0}}, +{(unsigned char*)"nwarrow", {226, 134, 150, 0}}, +{(unsigned char*)"nwnear", {226, 164, 167, 0}}, +{(unsigned char*)"oS", {226, 147, 136, 0}}, +{(unsigned char*)"oacute", {195, 179, 0}}, +{(unsigned char*)"oast", {226, 138, 155, 0}}, +{(unsigned char*)"ocir", {226, 138, 154, 0}}, +{(unsigned char*)"ocirc", {195, 180, 0}}, +{(unsigned char*)"ocy", {208, 190, 0}}, +{(unsigned char*)"odash", {226, 138, 157, 0}}, +{(unsigned char*)"odblac", {197, 145, 0}}, +{(unsigned char*)"odiv", {226, 168, 184, 0}}, +{(unsigned char*)"odot", {226, 138, 153, 0}}, +{(unsigned char*)"odsold", {226, 166, 188, 0}}, +{(unsigned char*)"oelig", {197, 147, 0}}, +{(unsigned char*)"ofcir", {226, 166, 191, 0}}, +{(unsigned char*)"ofr", {240, 157, 148, 172, 0}}, +{(unsigned char*)"ogon", {203, 155, 0}}, +{(unsigned char*)"ograve", {195, 178, 0}}, +{(unsigned char*)"ogt", {226, 167, 129, 0}}, +{(unsigned char*)"ohbar", {226, 166, 181, 0}}, +{(unsigned char*)"ohm", {206, 169, 0}}, +{(unsigned char*)"oint", {226, 136, 174, 0}}, +{(unsigned char*)"olarr", {226, 134, 186, 0}}, +{(unsigned char*)"olcir", {226, 166, 190, 0}}, +{(unsigned char*)"olcross", {226, 166, 187, 0}}, +{(unsigned char*)"oline", {226, 128, 190, 0}}, +{(unsigned char*)"olt", {226, 167, 128, 0}}, +{(unsigned char*)"omacr", {197, 141, 0}}, +{(unsigned char*)"omega", {207, 137, 0}}, +{(unsigned char*)"omicron", {206, 191, 0}}, +{(unsigned char*)"omid", {226, 166, 182, 0}}, +{(unsigned char*)"ominus", {226, 138, 150, 0}}, +{(unsigned char*)"oopf", {240, 157, 149, 160, 0}}, +{(unsigned char*)"opar", {226, 166, 183, 0}}, +{(unsigned char*)"operp", {226, 166, 185, 0}}, +{(unsigned char*)"oplus", {226, 138, 149, 0}}, +{(unsigned char*)"or", {226, 136, 168, 0}}, +{(unsigned char*)"orarr", {226, 134, 187, 0}}, +{(unsigned char*)"ord", {226, 169, 157, 0}}, +{(unsigned char*)"order", {226, 132, 180, 0}}, +{(unsigned char*)"orderof", {226, 132, 180, 0}}, +{(unsigned char*)"ordf", {194, 170, 0}}, +{(unsigned char*)"ordm", {194, 186, 0}}, +{(unsigned char*)"origof", {226, 138, 182, 0}}, +{(unsigned char*)"oror", {226, 169, 150, 0}}, +{(unsigned char*)"orslope", {226, 169, 151, 0}}, +{(unsigned char*)"orv", {226, 169, 155, 0}}, +{(unsigned char*)"oscr", {226, 132, 180, 0}}, +{(unsigned char*)"oslash", {195, 184, 0}}, +{(unsigned char*)"osol", {226, 138, 152, 0}}, +{(unsigned char*)"otilde", {195, 181, 0}}, +{(unsigned char*)"otimes", {226, 138, 151, 0}}, +{(unsigned char*)"otimesas", {226, 168, 182, 0}}, +{(unsigned char*)"ouml", {195, 182, 0}}, +{(unsigned char*)"ovbar", {226, 140, 189, 0}}, +{(unsigned char*)"par", {226, 136, 165, 0}}, +{(unsigned char*)"para", {194, 182, 0}}, +{(unsigned char*)"parallel", {226, 136, 165, 0}}, +{(unsigned char*)"parsim", {226, 171, 179, 0}}, +{(unsigned char*)"parsl", {226, 171, 189, 0}}, +{(unsigned char*)"part", {226, 136, 130, 0}}, +{(unsigned char*)"pcy", {208, 191, 0}}, +{(unsigned char*)"percnt", {37, 0}}, +{(unsigned char*)"period", {46, 0}}, +{(unsigned char*)"permil", {226, 128, 176, 0}}, +{(unsigned char*)"perp", {226, 138, 165, 0}}, +{(unsigned char*)"pertenk", {226, 128, 177, 0}}, +{(unsigned char*)"pfr", {240, 157, 148, 173, 0}}, +{(unsigned char*)"phi", {207, 134, 0}}, +{(unsigned char*)"phiv", {207, 149, 0}}, +{(unsigned char*)"phmmat", {226, 132, 179, 0}}, +{(unsigned char*)"phone", {226, 152, 142, 0}}, +{(unsigned char*)"pi", {207, 128, 0}}, +{(unsigned char*)"pitchfork", {226, 139, 148, 0}}, +{(unsigned char*)"piv", {207, 150, 0}}, +{(unsigned char*)"planck", {226, 132, 143, 0}}, +{(unsigned char*)"planckh", {226, 132, 142, 0}}, +{(unsigned char*)"plankv", {226, 132, 143, 0}}, +{(unsigned char*)"plus", {43, 0}}, +{(unsigned char*)"plusacir", {226, 168, 163, 0}}, +{(unsigned char*)"plusb", {226, 138, 158, 0}}, +{(unsigned char*)"pluscir", {226, 168, 162, 0}}, +{(unsigned char*)"plusdo", {226, 136, 148, 0}}, +{(unsigned char*)"plusdu", {226, 168, 165, 0}}, +{(unsigned char*)"pluse", {226, 169, 178, 0}}, +{(unsigned char*)"plusmn", {194, 177, 0}}, +{(unsigned char*)"plussim", {226, 168, 166, 0}}, +{(unsigned char*)"plustwo", {226, 168, 167, 0}}, +{(unsigned char*)"pm", {194, 177, 0}}, +{(unsigned char*)"pointint", {226, 168, 149, 0}}, +{(unsigned char*)"popf", {240, 157, 149, 161, 0}}, +{(unsigned char*)"pound", {194, 163, 0}}, +{(unsigned char*)"pr", {226, 137, 186, 0}}, +{(unsigned char*)"prE", {226, 170, 179, 0}}, +{(unsigned char*)"prap", {226, 170, 183, 0}}, +{(unsigned char*)"prcue", {226, 137, 188, 0}}, +{(unsigned char*)"pre", {226, 170, 175, 0}}, +{(unsigned char*)"prec", {226, 137, 186, 0}}, +{(unsigned char*)"precapprox", {226, 170, 183, 0}}, +{(unsigned char*)"preccurlyeq", {226, 137, 188, 0}}, +{(unsigned char*)"preceq", {226, 170, 175, 0}}, +{(unsigned char*)"precnapprox", {226, 170, 185, 0}}, +{(unsigned char*)"precneqq", {226, 170, 181, 0}}, +{(unsigned char*)"precnsim", {226, 139, 168, 0}}, +{(unsigned char*)"precsim", {226, 137, 190, 0}}, +{(unsigned char*)"prime", {226, 128, 178, 0}}, +{(unsigned char*)"primes", {226, 132, 153, 0}}, +{(unsigned char*)"prnE", {226, 170, 181, 0}}, +{(unsigned char*)"prnap", {226, 170, 185, 0}}, +{(unsigned char*)"prnsim", {226, 139, 168, 0}}, +{(unsigned char*)"prod", {226, 136, 143, 0}}, +{(unsigned char*)"profalar", {226, 140, 174, 0}}, +{(unsigned char*)"profline", {226, 140, 146, 0}}, +{(unsigned char*)"profsurf", {226, 140, 147, 0}}, +{(unsigned char*)"prop", {226, 136, 157, 0}}, +{(unsigned char*)"propto", {226, 136, 157, 0}}, +{(unsigned char*)"prsim", {226, 137, 190, 0}}, +{(unsigned char*)"prurel", {226, 138, 176, 0}}, +{(unsigned char*)"pscr", {240, 157, 147, 133, 0}}, +{(unsigned char*)"psi", {207, 136, 0}}, +{(unsigned char*)"puncsp", {226, 128, 136, 0}}, +{(unsigned char*)"qfr", {240, 157, 148, 174, 0}}, +{(unsigned char*)"qint", {226, 168, 140, 0}}, +{(unsigned char*)"qopf", {240, 157, 149, 162, 0}}, +{(unsigned char*)"qprime", {226, 129, 151, 0}}, +{(unsigned char*)"qscr", {240, 157, 147, 134, 0}}, +{(unsigned char*)"quaternions", {226, 132, 141, 0}}, +{(unsigned char*)"quatint", {226, 168, 150, 0}}, +{(unsigned char*)"quest", {63, 0}}, +{(unsigned char*)"questeq", {226, 137, 159, 0}}, +{(unsigned char*)"quot", {34, 0}}, +{(unsigned char*)"rAarr", {226, 135, 155, 0}}, +{(unsigned char*)"rArr", {226, 135, 146, 0}}, +{(unsigned char*)"rAtail", {226, 164, 156, 0}}, +{(unsigned char*)"rBarr", {226, 164, 143, 0}}, +{(unsigned char*)"rHar", {226, 165, 164, 0}}, +{(unsigned char*)"race", {226, 136, 189, 204, 177, 0}}, +{(unsigned char*)"racute", {197, 149, 0}}, +{(unsigned char*)"radic", {226, 136, 154, 0}}, +{(unsigned char*)"raemptyv", {226, 166, 179, 0}}, +{(unsigned char*)"rang", {226, 159, 169, 0}}, +{(unsigned char*)"rangd", {226, 166, 146, 0}}, +{(unsigned char*)"range", {226, 166, 165, 0}}, +{(unsigned char*)"rangle", {226, 159, 169, 0}}, +{(unsigned char*)"raquo", {194, 187, 0}}, +{(unsigned char*)"rarr", {226, 134, 146, 0}}, +{(unsigned char*)"rarrap", {226, 165, 181, 0}}, +{(unsigned char*)"rarrb", {226, 135, 165, 0}}, +{(unsigned char*)"rarrbfs", {226, 164, 160, 0}}, +{(unsigned char*)"rarrc", {226, 164, 179, 0}}, +{(unsigned char*)"rarrfs", {226, 164, 158, 0}}, +{(unsigned char*)"rarrhk", {226, 134, 170, 0}}, +{(unsigned char*)"rarrlp", {226, 134, 172, 0}}, +{(unsigned char*)"rarrpl", {226, 165, 133, 0}}, +{(unsigned char*)"rarrsim", {226, 165, 180, 0}}, +{(unsigned char*)"rarrtl", {226, 134, 163, 0}}, +{(unsigned char*)"rarrw", {226, 134, 157, 0}}, +{(unsigned char*)"ratail", {226, 164, 154, 0}}, +{(unsigned char*)"ratio", {226, 136, 182, 0}}, +{(unsigned char*)"rationals", {226, 132, 154, 0}}, +{(unsigned char*)"rbarr", {226, 164, 141, 0}}, +{(unsigned char*)"rbbrk", {226, 157, 179, 0}}, +{(unsigned char*)"rbrace", {125, 0}}, +{(unsigned char*)"rbrack", {93, 0}}, +{(unsigned char*)"rbrke", {226, 166, 140, 0}}, +{(unsigned char*)"rbrksld", {226, 166, 142, 0}}, +{(unsigned char*)"rbrkslu", {226, 166, 144, 0}}, +{(unsigned char*)"rcaron", {197, 153, 0}}, +{(unsigned char*)"rcedil", {197, 151, 0}}, +{(unsigned char*)"rceil", {226, 140, 137, 0}}, +{(unsigned char*)"rcub", {125, 0}}, +{(unsigned char*)"rcy", {209, 128, 0}}, +{(unsigned char*)"rdca", {226, 164, 183, 0}}, +{(unsigned char*)"rdldhar", {226, 165, 169, 0}}, +{(unsigned char*)"rdquo", {226, 128, 157, 0}}, +{(unsigned char*)"rdquor", {226, 128, 157, 0}}, +{(unsigned char*)"rdsh", {226, 134, 179, 0}}, +{(unsigned char*)"real", {226, 132, 156, 0}}, +{(unsigned char*)"realine", {226, 132, 155, 0}}, +{(unsigned char*)"realpart", {226, 132, 156, 0}}, +{(unsigned char*)"reals", {226, 132, 157, 0}}, +{(unsigned char*)"rect", {226, 150, 173, 0}}, +{(unsigned char*)"reg", {194, 174, 0}}, +{(unsigned char*)"rfisht", {226, 165, 189, 0}}, +{(unsigned char*)"rfloor", {226, 140, 139, 0}}, +{(unsigned char*)"rfr", {240, 157, 148, 175, 0}}, +{(unsigned char*)"rhard", {226, 135, 129, 0}}, +{(unsigned char*)"rharu", {226, 135, 128, 0}}, +{(unsigned char*)"rharul", {226, 165, 172, 0}}, +{(unsigned char*)"rho", {207, 129, 0}}, +{(unsigned char*)"rhov", {207, 177, 0}}, +{(unsigned char*)"rightarrow", {226, 134, 146, 0}}, +{(unsigned char*)"rightarrowtail", {226, 134, 163, 0}}, +{(unsigned char*)"rightharpoondown", {226, 135, 129, 0}}, +{(unsigned char*)"rightharpoonup", {226, 135, 128, 0}}, +{(unsigned char*)"rightleftarrows", {226, 135, 132, 0}}, +{(unsigned char*)"rightleftharpoons", {226, 135, 140, 0}}, +{(unsigned char*)"rightrightarrows", {226, 135, 137, 0}}, +{(unsigned char*)"rightsquigarrow", {226, 134, 157, 0}}, +{(unsigned char*)"rightthreetimes", {226, 139, 140, 0}}, +{(unsigned char*)"ring", {203, 154, 0}}, +{(unsigned char*)"risingdotseq", {226, 137, 147, 0}}, +{(unsigned char*)"rlarr", {226, 135, 132, 0}}, +{(unsigned char*)"rlhar", {226, 135, 140, 0}}, +{(unsigned char*)"rlm", {226, 128, 143, 0}}, +{(unsigned char*)"rmoust", {226, 142, 177, 0}}, +{(unsigned char*)"rmoustache", {226, 142, 177, 0}}, +{(unsigned char*)"rnmid", {226, 171, 174, 0}}, +{(unsigned char*)"roang", {226, 159, 173, 0}}, +{(unsigned char*)"roarr", {226, 135, 190, 0}}, +{(unsigned char*)"robrk", {226, 159, 167, 0}}, +{(unsigned char*)"ropar", {226, 166, 134, 0}}, +{(unsigned char*)"ropf", {240, 157, 149, 163, 0}}, +{(unsigned char*)"roplus", {226, 168, 174, 0}}, +{(unsigned char*)"rotimes", {226, 168, 181, 0}}, +{(unsigned char*)"rpar", {41, 0}}, +{(unsigned char*)"rpargt", {226, 166, 148, 0}}, +{(unsigned char*)"rppolint", {226, 168, 146, 0}}, +{(unsigned char*)"rrarr", {226, 135, 137, 0}}, +{(unsigned char*)"rsaquo", {226, 128, 186, 0}}, +{(unsigned char*)"rscr", {240, 157, 147, 135, 0}}, +{(unsigned char*)"rsh", {226, 134, 177, 0}}, +{(unsigned char*)"rsqb", {93, 0}}, +{(unsigned char*)"rsquo", {226, 128, 153, 0}}, +{(unsigned char*)"rsquor", {226, 128, 153, 0}}, +{(unsigned char*)"rthree", {226, 139, 140, 0}}, +{(unsigned char*)"rtimes", {226, 139, 138, 0}}, +{(unsigned char*)"rtri", {226, 150, 185, 0}}, +{(unsigned char*)"rtrie", {226, 138, 181, 0}}, +{(unsigned char*)"rtrif", {226, 150, 184, 0}}, +{(unsigned char*)"rtriltri", {226, 167, 142, 0}}, +{(unsigned char*)"ruluhar", {226, 165, 168, 0}}, +{(unsigned char*)"rx", {226, 132, 158, 0}}, +{(unsigned char*)"sacute", {197, 155, 0}}, +{(unsigned char*)"sbquo", {226, 128, 154, 0}}, +{(unsigned char*)"sc", {226, 137, 187, 0}}, +{(unsigned char*)"scE", {226, 170, 180, 0}}, +{(unsigned char*)"scap", {226, 170, 184, 0}}, +{(unsigned char*)"scaron", {197, 161, 0}}, +{(unsigned char*)"sccue", {226, 137, 189, 0}}, +{(unsigned char*)"sce", {226, 170, 176, 0}}, +{(unsigned char*)"scedil", {197, 159, 0}}, +{(unsigned char*)"scirc", {197, 157, 0}}, +{(unsigned char*)"scnE", {226, 170, 182, 0}}, +{(unsigned char*)"scnap", {226, 170, 186, 0}}, +{(unsigned char*)"scnsim", {226, 139, 169, 0}}, +{(unsigned char*)"scpolint", {226, 168, 147, 0}}, +{(unsigned char*)"scsim", {226, 137, 191, 0}}, +{(unsigned char*)"scy", {209, 129, 0}}, +{(unsigned char*)"sdot", {226, 139, 133, 0}}, +{(unsigned char*)"sdotb", {226, 138, 161, 0}}, +{(unsigned char*)"sdote", {226, 169, 166, 0}}, +{(unsigned char*)"seArr", {226, 135, 152, 0}}, +{(unsigned char*)"searhk", {226, 164, 165, 0}}, +{(unsigned char*)"searr", {226, 134, 152, 0}}, +{(unsigned char*)"searrow", {226, 134, 152, 0}}, +{(unsigned char*)"sect", {194, 167, 0}}, +{(unsigned char*)"semi", {59, 0}}, +{(unsigned char*)"seswar", {226, 164, 169, 0}}, +{(unsigned char*)"setminus", {226, 136, 150, 0}}, +{(unsigned char*)"setmn", {226, 136, 150, 0}}, +{(unsigned char*)"sext", {226, 156, 182, 0}}, +{(unsigned char*)"sfr", {240, 157, 148, 176, 0}}, +{(unsigned char*)"sfrown", {226, 140, 162, 0}}, +{(unsigned char*)"sharp", {226, 153, 175, 0}}, +{(unsigned char*)"shchcy", {209, 137, 0}}, +{(unsigned char*)"shcy", {209, 136, 0}}, +{(unsigned char*)"shortmid", {226, 136, 163, 0}}, +{(unsigned char*)"shortparallel", {226, 136, 165, 0}}, +{(unsigned char*)"shy", {194, 173, 0}}, +{(unsigned char*)"sigma", {207, 131, 0}}, +{(unsigned char*)"sigmaf", {207, 130, 0}}, +{(unsigned char*)"sigmav", {207, 130, 0}}, +{(unsigned char*)"sim", {226, 136, 188, 0}}, +{(unsigned char*)"simdot", {226, 169, 170, 0}}, +{(unsigned char*)"sime", {226, 137, 131, 0}}, +{(unsigned char*)"simeq", {226, 137, 131, 0}}, +{(unsigned char*)"simg", {226, 170, 158, 0}}, +{(unsigned char*)"simgE", {226, 170, 160, 0}}, +{(unsigned char*)"siml", {226, 170, 157, 0}}, +{(unsigned char*)"simlE", {226, 170, 159, 0}}, +{(unsigned char*)"simne", {226, 137, 134, 0}}, +{(unsigned char*)"simplus", {226, 168, 164, 0}}, +{(unsigned char*)"simrarr", {226, 165, 178, 0}}, +{(unsigned char*)"slarr", {226, 134, 144, 0}}, +{(unsigned char*)"smallsetminus", {226, 136, 150, 0}}, +{(unsigned char*)"smashp", {226, 168, 179, 0}}, +{(unsigned char*)"smeparsl", {226, 167, 164, 0}}, +{(unsigned char*)"smid", {226, 136, 163, 0}}, +{(unsigned char*)"smile", {226, 140, 163, 0}}, +{(unsigned char*)"smt", {226, 170, 170, 0}}, +{(unsigned char*)"smte", {226, 170, 172, 0}}, +{(unsigned char*)"smtes", {226, 170, 172, 239, 184, 128, 0}}, +{(unsigned char*)"softcy", {209, 140, 0}}, +{(unsigned char*)"sol", {47, 0}}, +{(unsigned char*)"solb", {226, 167, 132, 0}}, +{(unsigned char*)"solbar", {226, 140, 191, 0}}, +{(unsigned char*)"sopf", {240, 157, 149, 164, 0}}, +{(unsigned char*)"spades", {226, 153, 160, 0}}, +{(unsigned char*)"spadesuit", {226, 153, 160, 0}}, +{(unsigned char*)"spar", {226, 136, 165, 0}}, +{(unsigned char*)"sqcap", {226, 138, 147, 0}}, +{(unsigned char*)"sqcaps", {226, 138, 147, 239, 184, 128, 0}}, +{(unsigned char*)"sqcup", {226, 138, 148, 0}}, +{(unsigned char*)"sqcups", {226, 138, 148, 239, 184, 128, 0}}, +{(unsigned char*)"sqsub", {226, 138, 143, 0}}, +{(unsigned char*)"sqsube", {226, 138, 145, 0}}, +{(unsigned char*)"sqsubset", {226, 138, 143, 0}}, +{(unsigned char*)"sqsubseteq", {226, 138, 145, 0}}, +{(unsigned char*)"sqsup", {226, 138, 144, 0}}, +{(unsigned char*)"sqsupe", {226, 138, 146, 0}}, +{(unsigned char*)"sqsupset", {226, 138, 144, 0}}, +{(unsigned char*)"sqsupseteq", {226, 138, 146, 0}}, +{(unsigned char*)"squ", {226, 150, 161, 0}}, +{(unsigned char*)"square", {226, 150, 161, 0}}, +{(unsigned char*)"squarf", {226, 150, 170, 0}}, +{(unsigned char*)"squf", {226, 150, 170, 0}}, +{(unsigned char*)"srarr", {226, 134, 146, 0}}, +{(unsigned char*)"sscr", {240, 157, 147, 136, 0}}, +{(unsigned char*)"ssetmn", {226, 136, 150, 0}}, +{(unsigned char*)"ssmile", {226, 140, 163, 0}}, +{(unsigned char*)"sstarf", {226, 139, 134, 0}}, +{(unsigned char*)"star", {226, 152, 134, 0}}, +{(unsigned char*)"starf", {226, 152, 133, 0}}, +{(unsigned char*)"straightepsilon", {207, 181, 0}}, +{(unsigned char*)"straightphi", {207, 149, 0}}, +{(unsigned char*)"strns", {194, 175, 0}}, +{(unsigned char*)"sub", {226, 138, 130, 0}}, +{(unsigned char*)"subE", {226, 171, 133, 0}}, +{(unsigned char*)"subdot", {226, 170, 189, 0}}, +{(unsigned char*)"sube", {226, 138, 134, 0}}, +{(unsigned char*)"subedot", {226, 171, 131, 0}}, +{(unsigned char*)"submult", {226, 171, 129, 0}}, +{(unsigned char*)"subnE", {226, 171, 139, 0}}, +{(unsigned char*)"subne", {226, 138, 138, 0}}, +{(unsigned char*)"subplus", {226, 170, 191, 0}}, +{(unsigned char*)"subrarr", {226, 165, 185, 0}}, +{(unsigned char*)"subset", {226, 138, 130, 0}}, +{(unsigned char*)"subseteq", {226, 138, 134, 0}}, +{(unsigned char*)"subseteqq", {226, 171, 133, 0}}, +{(unsigned char*)"subsetneq", {226, 138, 138, 0}}, +{(unsigned char*)"subsetneqq", {226, 171, 139, 0}}, +{(unsigned char*)"subsim", {226, 171, 135, 0}}, +{(unsigned char*)"subsub", {226, 171, 149, 0}}, +{(unsigned char*)"subsup", {226, 171, 147, 0}}, +{(unsigned char*)"succ", {226, 137, 187, 0}}, +{(unsigned char*)"succapprox", {226, 170, 184, 0}}, +{(unsigned char*)"succcurlyeq", {226, 137, 189, 0}}, +{(unsigned char*)"succeq", {226, 170, 176, 0}}, +{(unsigned char*)"succnapprox", {226, 170, 186, 0}}, +{(unsigned char*)"succneqq", {226, 170, 182, 0}}, +{(unsigned char*)"succnsim", {226, 139, 169, 0}}, +{(unsigned char*)"succsim", {226, 137, 191, 0}}, +{(unsigned char*)"sum", {226, 136, 145, 0}}, +{(unsigned char*)"sung", {226, 153, 170, 0}}, +{(unsigned char*)"sup", {226, 138, 131, 0}}, +{(unsigned char*)"sup1", {194, 185, 0}}, +{(unsigned char*)"sup2", {194, 178, 0}}, +{(unsigned char*)"sup3", {194, 179, 0}}, +{(unsigned char*)"supE", {226, 171, 134, 0}}, +{(unsigned char*)"supdot", {226, 170, 190, 0}}, +{(unsigned char*)"supdsub", {226, 171, 152, 0}}, +{(unsigned char*)"supe", {226, 138, 135, 0}}, +{(unsigned char*)"supedot", {226, 171, 132, 0}}, +{(unsigned char*)"suphsol", {226, 159, 137, 0}}, +{(unsigned char*)"suphsub", {226, 171, 151, 0}}, +{(unsigned char*)"suplarr", {226, 165, 187, 0}}, +{(unsigned char*)"supmult", {226, 171, 130, 0}}, +{(unsigned char*)"supnE", {226, 171, 140, 0}}, +{(unsigned char*)"supne", {226, 138, 139, 0}}, +{(unsigned char*)"supplus", {226, 171, 128, 0}}, +{(unsigned char*)"supset", {226, 138, 131, 0}}, +{(unsigned char*)"supseteq", {226, 138, 135, 0}}, +{(unsigned char*)"supseteqq", {226, 171, 134, 0}}, +{(unsigned char*)"supsetneq", {226, 138, 139, 0}}, +{(unsigned char*)"supsetneqq", {226, 171, 140, 0}}, +{(unsigned char*)"supsim", {226, 171, 136, 0}}, +{(unsigned char*)"supsub", {226, 171, 148, 0}}, +{(unsigned char*)"supsup", {226, 171, 150, 0}}, +{(unsigned char*)"swArr", {226, 135, 153, 0}}, +{(unsigned char*)"swarhk", {226, 164, 166, 0}}, +{(unsigned char*)"swarr", {226, 134, 153, 0}}, +{(unsigned char*)"swarrow", {226, 134, 153, 0}}, +{(unsigned char*)"swnwar", {226, 164, 170, 0}}, +{(unsigned char*)"szlig", {195, 159, 0}}, +{(unsigned char*)"target", {226, 140, 150, 0}}, +{(unsigned char*)"tau", {207, 132, 0}}, +{(unsigned char*)"tbrk", {226, 142, 180, 0}}, +{(unsigned char*)"tcaron", {197, 165, 0}}, +{(unsigned char*)"tcedil", {197, 163, 0}}, +{(unsigned char*)"tcy", {209, 130, 0}}, +{(unsigned char*)"tdot", {226, 131, 155, 0}}, +{(unsigned char*)"telrec", {226, 140, 149, 0}}, +{(unsigned char*)"tfr", {240, 157, 148, 177, 0}}, +{(unsigned char*)"there4", {226, 136, 180, 0}}, +{(unsigned char*)"therefore", {226, 136, 180, 0}}, +{(unsigned char*)"theta", {206, 184, 0}}, +{(unsigned char*)"thetasym", {207, 145, 0}}, +{(unsigned char*)"thetav", {207, 145, 0}}, +{(unsigned char*)"thickapprox", {226, 137, 136, 0}}, +{(unsigned char*)"thicksim", {226, 136, 188, 0}}, +{(unsigned char*)"thinsp", {226, 128, 137, 0}}, +{(unsigned char*)"thkap", {226, 137, 136, 0}}, +{(unsigned char*)"thksim", {226, 136, 188, 0}}, +{(unsigned char*)"thorn", {195, 190, 0}}, +{(unsigned char*)"tilde", {203, 156, 0}}, +{(unsigned char*)"times", {195, 151, 0}}, +{(unsigned char*)"timesb", {226, 138, 160, 0}}, +{(unsigned char*)"timesbar", {226, 168, 177, 0}}, +{(unsigned char*)"timesd", {226, 168, 176, 0}}, +{(unsigned char*)"tint", {226, 136, 173, 0}}, +{(unsigned char*)"toea", {226, 164, 168, 0}}, +{(unsigned char*)"top", {226, 138, 164, 0}}, +{(unsigned char*)"topbot", {226, 140, 182, 0}}, +{(unsigned char*)"topcir", {226, 171, 177, 0}}, +{(unsigned char*)"topf", {240, 157, 149, 165, 0}}, +{(unsigned char*)"topfork", {226, 171, 154, 0}}, +{(unsigned char*)"tosa", {226, 164, 169, 0}}, +{(unsigned char*)"tprime", {226, 128, 180, 0}}, +{(unsigned char*)"trade", {226, 132, 162, 0}}, +{(unsigned char*)"triangle", {226, 150, 181, 0}}, +{(unsigned char*)"triangledown", {226, 150, 191, 0}}, +{(unsigned char*)"triangleleft", {226, 151, 131, 0}}, +{(unsigned char*)"trianglelefteq", {226, 138, 180, 0}}, +{(unsigned char*)"triangleq", {226, 137, 156, 0}}, +{(unsigned char*)"triangleright", {226, 150, 185, 0}}, +{(unsigned char*)"trianglerighteq", {226, 138, 181, 0}}, +{(unsigned char*)"tridot", {226, 151, 172, 0}}, +{(unsigned char*)"trie", {226, 137, 156, 0}}, +{(unsigned char*)"triminus", {226, 168, 186, 0}}, +{(unsigned char*)"triplus", {226, 168, 185, 0}}, +{(unsigned char*)"trisb", {226, 167, 141, 0}}, +{(unsigned char*)"tritime", {226, 168, 187, 0}}, +{(unsigned char*)"trpezium", {226, 143, 162, 0}}, +{(unsigned char*)"tscr", {240, 157, 147, 137, 0}}, +{(unsigned char*)"tscy", {209, 134, 0}}, +{(unsigned char*)"tshcy", {209, 155, 0}}, +{(unsigned char*)"tstrok", {197, 167, 0}}, +{(unsigned char*)"twixt", {226, 137, 172, 0}}, +{(unsigned char*)"twoheadleftarrow", {226, 134, 158, 0}}, +{(unsigned char*)"twoheadrightarrow", {226, 134, 160, 0}}, +{(unsigned char*)"uArr", {226, 135, 145, 0}}, +{(unsigned char*)"uHar", {226, 165, 163, 0}}, +{(unsigned char*)"uacute", {195, 186, 0}}, +{(unsigned char*)"uarr", {226, 134, 145, 0}}, +{(unsigned char*)"ubrcy", {209, 158, 0}}, +{(unsigned char*)"ubreve", {197, 173, 0}}, +{(unsigned char*)"ucirc", {195, 187, 0}}, +{(unsigned char*)"ucy", {209, 131, 0}}, +{(unsigned char*)"udarr", {226, 135, 133, 0}}, +{(unsigned char*)"udblac", {197, 177, 0}}, +{(unsigned char*)"udhar", {226, 165, 174, 0}}, +{(unsigned char*)"ufisht", {226, 165, 190, 0}}, +{(unsigned char*)"ufr", {240, 157, 148, 178, 0}}, +{(unsigned char*)"ugrave", {195, 185, 0}}, +{(unsigned char*)"uharl", {226, 134, 191, 0}}, +{(unsigned char*)"uharr", {226, 134, 190, 0}}, +{(unsigned char*)"uhblk", {226, 150, 128, 0}}, +{(unsigned char*)"ulcorn", {226, 140, 156, 0}}, +{(unsigned char*)"ulcorner", {226, 140, 156, 0}}, +{(unsigned char*)"ulcrop", {226, 140, 143, 0}}, +{(unsigned char*)"ultri", {226, 151, 184, 0}}, +{(unsigned char*)"umacr", {197, 171, 0}}, +{(unsigned char*)"uml", {194, 168, 0}}, +{(unsigned char*)"uogon", {197, 179, 0}}, +{(unsigned char*)"uopf", {240, 157, 149, 166, 0}}, +{(unsigned char*)"uparrow", {226, 134, 145, 0}}, +{(unsigned char*)"updownarrow", {226, 134, 149, 0}}, +{(unsigned char*)"upharpoonleft", {226, 134, 191, 0}}, +{(unsigned char*)"upharpoonright", {226, 134, 190, 0}}, +{(unsigned char*)"uplus", {226, 138, 142, 0}}, +{(unsigned char*)"upsi", {207, 133, 0}}, +{(unsigned char*)"upsih", {207, 146, 0}}, +{(unsigned char*)"upsilon", {207, 133, 0}}, +{(unsigned char*)"upuparrows", {226, 135, 136, 0}}, +{(unsigned char*)"urcorn", {226, 140, 157, 0}}, +{(unsigned char*)"urcorner", {226, 140, 157, 0}}, +{(unsigned char*)"urcrop", {226, 140, 142, 0}}, +{(unsigned char*)"uring", {197, 175, 0}}, +{(unsigned char*)"urtri", {226, 151, 185, 0}}, +{(unsigned char*)"uscr", {240, 157, 147, 138, 0}}, +{(unsigned char*)"utdot", {226, 139, 176, 0}}, +{(unsigned char*)"utilde", {197, 169, 0}}, +{(unsigned char*)"utri", {226, 150, 181, 0}}, +{(unsigned char*)"utrif", {226, 150, 180, 0}}, +{(unsigned char*)"uuarr", {226, 135, 136, 0}}, +{(unsigned char*)"uuml", {195, 188, 0}}, +{(unsigned char*)"uwangle", {226, 166, 167, 0}}, +{(unsigned char*)"vArr", {226, 135, 149, 0}}, +{(unsigned char*)"vBar", {226, 171, 168, 0}}, +{(unsigned char*)"vBarv", {226, 171, 169, 0}}, +{(unsigned char*)"vDash", {226, 138, 168, 0}}, +{(unsigned char*)"vangrt", {226, 166, 156, 0}}, +{(unsigned char*)"varepsilon", {207, 181, 0}}, +{(unsigned char*)"varkappa", {207, 176, 0}}, +{(unsigned char*)"varnothing", {226, 136, 133, 0}}, +{(unsigned char*)"varphi", {207, 149, 0}}, +{(unsigned char*)"varpi", {207, 150, 0}}, +{(unsigned char*)"varpropto", {226, 136, 157, 0}}, +{(unsigned char*)"varr", {226, 134, 149, 0}}, +{(unsigned char*)"varrho", {207, 177, 0}}, +{(unsigned char*)"varsigma", {207, 130, 0}}, +{(unsigned char*)"varsubsetneq", {226, 138, 138, 239, 184, 128, 0}}, +{(unsigned char*)"varsubsetneqq", {226, 171, 139, 239, 184, 128, 0}}, +{(unsigned char*)"varsupsetneq", {226, 138, 139, 239, 184, 128, 0}}, +{(unsigned char*)"varsupsetneqq", {226, 171, 140, 239, 184, 128, 0}}, +{(unsigned char*)"vartheta", {207, 145, 0}}, +{(unsigned char*)"vartriangleleft", {226, 138, 178, 0}}, +{(unsigned char*)"vartriangleright", {226, 138, 179, 0}}, +{(unsigned char*)"vcy", {208, 178, 0}}, +{(unsigned char*)"vdash", {226, 138, 162, 0}}, +{(unsigned char*)"vee", {226, 136, 168, 0}}, +{(unsigned char*)"veebar", {226, 138, 187, 0}}, +{(unsigned char*)"veeeq", {226, 137, 154, 0}}, +{(unsigned char*)"vellip", {226, 139, 174, 0}}, +{(unsigned char*)"verbar", {124, 0}}, +{(unsigned char*)"vert", {124, 0}}, +{(unsigned char*)"vfr", {240, 157, 148, 179, 0}}, +{(unsigned char*)"vltri", {226, 138, 178, 0}}, +{(unsigned char*)"vnsub", {226, 138, 130, 226, 131, 146, 0}}, +{(unsigned char*)"vnsup", {226, 138, 131, 226, 131, 146, 0}}, +{(unsigned char*)"vopf", {240, 157, 149, 167, 0}}, +{(unsigned char*)"vprop", {226, 136, 157, 0}}, +{(unsigned char*)"vrtri", {226, 138, 179, 0}}, +{(unsigned char*)"vscr", {240, 157, 147, 139, 0}}, +{(unsigned char*)"vsubnE", {226, 171, 139, 239, 184, 128, 0}}, +{(unsigned char*)"vsubne", {226, 138, 138, 239, 184, 128, 0}}, +{(unsigned char*)"vsupnE", {226, 171, 140, 239, 184, 128, 0}}, +{(unsigned char*)"vsupne", {226, 138, 139, 239, 184, 128, 0}}, +{(unsigned char*)"vzigzag", {226, 166, 154, 0}}, +{(unsigned char*)"wcirc", {197, 181, 0}}, +{(unsigned char*)"wedbar", {226, 169, 159, 0}}, +{(unsigned char*)"wedge", {226, 136, 167, 0}}, +{(unsigned char*)"wedgeq", {226, 137, 153, 0}}, +{(unsigned char*)"weierp", {226, 132, 152, 0}}, +{(unsigned char*)"wfr", {240, 157, 148, 180, 0}}, +{(unsigned char*)"wopf", {240, 157, 149, 168, 0}}, +{(unsigned char*)"wp", {226, 132, 152, 0}}, +{(unsigned char*)"wr", {226, 137, 128, 0}}, +{(unsigned char*)"wreath", {226, 137, 128, 0}}, +{(unsigned char*)"wscr", {240, 157, 147, 140, 0}}, +{(unsigned char*)"xcap", {226, 139, 130, 0}}, +{(unsigned char*)"xcirc", {226, 151, 175, 0}}, +{(unsigned char*)"xcup", {226, 139, 131, 0}}, +{(unsigned char*)"xdtri", {226, 150, 189, 0}}, +{(unsigned char*)"xfr", {240, 157, 148, 181, 0}}, +{(unsigned char*)"xhArr", {226, 159, 186, 0}}, +{(unsigned char*)"xharr", {226, 159, 183, 0}}, +{(unsigned char*)"xi", {206, 190, 0}}, +{(unsigned char*)"xlArr", {226, 159, 184, 0}}, +{(unsigned char*)"xlarr", {226, 159, 181, 0}}, +{(unsigned char*)"xmap", {226, 159, 188, 0}}, +{(unsigned char*)"xnis", {226, 139, 187, 0}}, +{(unsigned char*)"xodot", {226, 168, 128, 0}}, +{(unsigned char*)"xopf", {240, 157, 149, 169, 0}}, +{(unsigned char*)"xoplus", {226, 168, 129, 0}}, +{(unsigned char*)"xotime", {226, 168, 130, 0}}, +{(unsigned char*)"xrArr", {226, 159, 185, 0}}, +{(unsigned char*)"xrarr", {226, 159, 182, 0}}, +{(unsigned char*)"xscr", {240, 157, 147, 141, 0}}, +{(unsigned char*)"xsqcup", {226, 168, 134, 0}}, +{(unsigned char*)"xuplus", {226, 168, 132, 0}}, +{(unsigned char*)"xutri", {226, 150, 179, 0}}, +{(unsigned char*)"xvee", {226, 139, 129, 0}}, +{(unsigned char*)"xwedge", {226, 139, 128, 0}}, +{(unsigned char*)"yacute", {195, 189, 0}}, +{(unsigned char*)"yacy", {209, 143, 0}}, +{(unsigned char*)"ycirc", {197, 183, 0}}, +{(unsigned char*)"ycy", {209, 139, 0}}, +{(unsigned char*)"yen", {194, 165, 0}}, +{(unsigned char*)"yfr", {240, 157, 148, 182, 0}}, +{(unsigned char*)"yicy", {209, 151, 0}}, +{(unsigned char*)"yopf", {240, 157, 149, 170, 0}}, +{(unsigned char*)"yscr", {240, 157, 147, 142, 0}}, +{(unsigned char*)"yucy", {209, 142, 0}}, +{(unsigned char*)"yuml", {195, 191, 0}}, +{(unsigned char*)"zacute", {197, 186, 0}}, +{(unsigned char*)"zcaron", {197, 190, 0}}, +{(unsigned char*)"zcy", {208, 183, 0}}, +{(unsigned char*)"zdot", {197, 188, 0}}, +{(unsigned char*)"zeetrf", {226, 132, 168, 0}}, +{(unsigned char*)"zeta", {206, 182, 0}}, +{(unsigned char*)"zfr", {240, 157, 148, 183, 0}}, +{(unsigned char*)"zhcy", {208, 182, 0}}, +{(unsigned char*)"zigrarr", {226, 135, 157, 0}}, +{(unsigned char*)"zopf", {240, 157, 149, 171, 0}}, +{(unsigned char*)"zscr", {240, 157, 147, 143, 0}}, +{(unsigned char*)"zwj", {226, 128, 141, 0}}, +{(unsigned char*)"zwnj", {226, 128, 140, 0}}, +}; diff --git a/houdini_html_u.c b/houdini_html_u.c index e57894d..002357d 100644 --- a/houdini_html_u.c +++ b/houdini_html_u.c @@ -5,7 +5,35 @@ #include "buffer.h" #include "houdini.h" #include "utf8.h" -#include "html_unescape.h" +#include "entities.inc" + +/* Binary tree lookup code for entities added by JGM */ + +static unsigned char * +S_lookup(int i, int low, int hi, const unsigned char *s, int len) +{ + int j; + int cmp = strncmp((char *)s, (char *)cmark_entities[i].entity, len); + if (cmp == 0 && cmark_entities[i].entity[len] == 0) { + return (unsigned char *)cmark_entities[i].bytes; + } else if (cmp < 0 && i > low) { + j = i - ((i - low) / 2); + if (j == i) j -= 1; + return S_lookup(j, low, i - 1, s, len); + } else if (cmp > 0 && i < hi) { + j = i + ((hi - i) / 2); + if (j == i) j += 1; + return S_lookup(j, i + 1, hi, s, len); + } else { + return NULL; + } +} + +static unsigned char * +S_lookup_entity(const unsigned char *s, int len) +{ + return S_lookup(CMARK_NUM_ENTITIES / 2, 0, CMARK_NUM_ENTITIES - 1, s, len); +} bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) @@ -57,22 +85,18 @@ houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) } else { - if (size > MAX_WORD_LENGTH) - size = MAX_WORD_LENGTH; + if (size > CMARK_ENTITY_MAX_LENGTH) + size = CMARK_ENTITY_MAX_LENGTH; - for (i = MIN_WORD_LENGTH; i < size; ++i) { + for (i = CMARK_ENTITY_MIN_LENGTH; i < size; ++i) { if (src[i] == ' ') break; if (src[i] == ';') { - const struct html_ent *entity = find_entity((char *)src, i); + const unsigned char *entity = S_lookup_entity(src, i); if (entity != NULL) { - bufsize_t len = 0; - while (len < 4 && entity->utf8[len] != '\0') { - ++len; - } - cmark_strbuf_put(ob, entity->utf8, len); + cmark_strbuf_puts(ob, (const char *)entity); return i + 1; } diff --git a/html.c b/html.c index a30bbca..c6bbea6 100644 --- a/html.c +++ b/html.c @@ -2,12 +2,13 @@ #include #include #include - +#include "cmark_ctype.h" #include "config.h" #include "cmark.h" #include "node.h" #include "buffer.h" #include "houdini.h" +#include "scanners.h" // Functions to convert cmark_nodes to HTML strings. @@ -156,7 +157,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, } else { bufsize_t first_tag = 0; while (first_tag < node->as.code.info.len && - node->as.code.info.data[first_tag] != ' ') { + !cmark_isspace(node->as.code.info.data[first_tag])) { first_tag += 1; } @@ -174,7 +175,13 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_HTML: cr(html); - cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); + if (options & CMARK_OPT_SAFE) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_put(html, node->as.literal.data, + node->as.literal.len); + } + cr(html); break; case CMARK_NODE_HRULE: @@ -228,7 +235,12 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, break; case CMARK_NODE_INLINE_HTML: - cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); + if (options & CMARK_OPT_SAFE) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_put(html, node->as.literal.data, + node->as.literal.len); + } break; case CMARK_NODE_STRONG: @@ -250,15 +262,19 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_LINK: if (entering) { cmark_strbuf_puts(html, "as.link.url.data, - node->as.link.url.len); + if (!((options & CMARK_OPT_SAFE) && + scan_dangerous_url(&node->as.link.url, 0))) { + houdini_escape_href(html, + node->as.link.url.data, + node->as.link.url.len); + } if (node->as.link.title.len) { cmark_strbuf_puts(html, "\" title=\""); - escape_html(html, node->as.link.title.data, + escape_html(html, + node->as.link.title.data, node->as.link.title.len); } - cmark_strbuf_puts(html, "\">"); } else { cmark_strbuf_puts(html, ""); @@ -268,9 +284,13 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_IMAGE: if (entering) { cmark_strbuf_puts(html, "as.link.url.data, - node->as.link.url.len); + if (!((options & CMARK_OPT_SAFE) && + scan_dangerous_url(&node->as.link.url, 0))) { + houdini_escape_href(html, + node->as.link.url.data, + node->as.link.url.len); + } cmark_strbuf_puts(html, "\" alt=\""); state->plain = node; } else { diff --git a/inlines.c b/inlines.c index 7e8f806..7ea308d 100644 --- a/inlines.c +++ b/inlines.c @@ -50,6 +50,12 @@ typedef struct { delimiter *last_delim; } subject; +static inline bool +S_is_line_end_char(char c) +{ + return (c == '\n' || c == '\r'); +} + static delimiter* S_insert_emph(subject *subj, delimiter *opener, delimiter *closer); @@ -163,8 +169,6 @@ static void subject_from_buf(subject *e, cmark_strbuf *buffer, e->pos = 0; e->refmap = refmap; e->last_delim = NULL; - - cmark_chunk_rtrim(&e->input); } static inline int isbacktick(int c) @@ -174,6 +178,9 @@ static inline int isbacktick(int c) static inline unsigned char peek_char(subject *subj) { + // NULL bytes should have been stripped out by now. If they're + // present, it's a programming error: + assert(!(subj->pos < subj->input.len && subj->input.data[subj->pos] == 0)); return (subj->pos < subj->input.len) ? subj->input.data[subj->pos] : 0; } @@ -191,6 +198,32 @@ static inline int is_eof(subject* subj) // Advance the subject. Doesn't check for eof. #define advance(subj) (subj)->pos += 1 +static inline bool +skip_spaces(subject *subj) +{ + bool skipped = false; + while (peek_char(subj) == ' ' || peek_char(subj) == '\t') { + advance(subj); + skipped = true; + } + return skipped; +} + +static inline bool +skip_line_end(subject *subj) +{ + bool seen_line_end_char = false; + if (peek_char(subj) == '\r') { + advance(subj); + seen_line_end_char = true; + } + if (peek_char(subj) == '\n') { + advance(subj); + seen_line_end_char = true; + } + return seen_line_end_char || is_eof(subj); +} + // Take characters while a predicate holds, and return a string. static inline cmark_chunk take_while(subject* subj, int (*f)(int)) { @@ -326,10 +359,10 @@ 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, + printf("Item at stack pos %p, text pos %d: %d %d %d next(%p) prev(%p)\n", + (void*)delim, delim->position, delim->delim_char, delim->can_open, delim->can_close, - delim->next, delim->previous); + (void*)delim->next, (void*)delim->previous); delim = delim->previous; } } @@ -404,18 +437,45 @@ static cmark_node* handle_delim(subject* subj, unsigned char c, bool smart) // Assumes we have a hyphen at the current position. static cmark_node* handle_hyphen(subject* subj, bool smart) { + int startpos = subj->pos; + 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 { + + if (!smart || peek_char(subj) != '-') { return make_str(cmark_chunk_literal("-")); } + + while (smart && peek_char(subj) == '-') { + advance(subj); + } + + int numhyphens = subj->pos - startpos; + int en_count = 0; + int em_count = 0; + int i; + cmark_strbuf buf = GH_BUF_INIT; + + if (numhyphens % 3 == 0) { // if divisible by 3, use all em dashes + em_count = numhyphens / 3; + } else if (numhyphens % 2 == 0) { // if divisible by 2, use all en dashes + en_count = numhyphens / 2; + } else if (numhyphens % 3 == 2) { // use one en dash at end + en_count = 1; + em_count = (numhyphens - 2) / 3; + } else { // use two en dashes at the end + en_count = 2; + em_count = (numhyphens - 4) / 3; + } + + for (i = em_count; i > 0; i--) { + cmark_strbuf_puts(&buf, EMDASH); + } + + for (i = en_count; i > 0; i--) { + cmark_strbuf_puts(&buf, ENDASH); + } + + return make_str(cmark_chunk_buf_detach(&buf)); } // Assumes we have a period at the current position. @@ -435,13 +495,22 @@ static cmark_node* handle_period(subject* subj, bool smart) } } -static void process_emphasis(subject *subj, delimiter *start_delim) +static void process_emphasis(subject *subj, delimiter *stack_bottom) { delimiter *closer = subj->last_delim; delimiter *opener; + delimiter *old_closer; + bool opener_found; + delimiter *openers_bottom[128]; + + // initialize openers_bottom: + openers_bottom['*'] = stack_bottom; + openers_bottom['_'] = stack_bottom; + openers_bottom['\''] = stack_bottom; + openers_bottom['"'] = stack_bottom; // move back to first relevant delim. - while (closer != NULL && closer->previous != start_delim) { + while (closer != NULL && closer->previous != stack_bottom) { closer = closer->previous; } @@ -452,15 +521,19 @@ static void process_emphasis(subject *subj, delimiter *start_delim) closer->delim_char == '"' || closer->delim_char == '\'')) { // Now look backwards for first matching opener: opener = closer->previous; - while (opener != NULL && opener != start_delim) { + opener_found = false; + while (opener != NULL && opener != stack_bottom && + opener != openers_bottom[closer->delim_char]) { if (opener->delim_char == closer->delim_char && opener->can_open) { + opener_found = true; break; } opener = opener->previous; } + old_closer = closer; if (closer->delim_char == '*' || closer->delim_char == '_') { - if (opener != NULL && opener != start_delim) { + if (opener_found) { closer = S_insert_emph(subj, opener, closer); } else { closer = closer->next; @@ -469,7 +542,7 @@ static void process_emphasis(subject *subj, delimiter *start_delim) cmark_chunk_free(&closer->inl_text->as.literal); closer->inl_text->as.literal = cmark_chunk_literal(RIGHTSINGLEQUOTE); - if (opener != NULL && opener != start_delim) { + if (opener_found) { cmark_chunk_free(&opener->inl_text->as.literal); opener->inl_text->as.literal = cmark_chunk_literal(LEFTSINGLEQUOTE); @@ -479,19 +552,29 @@ static void process_emphasis(subject *subj, delimiter *start_delim) cmark_chunk_free(&closer->inl_text->as.literal); closer->inl_text->as.literal = cmark_chunk_literal(RIGHTDOUBLEQUOTE); - if (opener != NULL && opener != start_delim) { + if (opener_found) { cmark_chunk_free(&opener->inl_text->as.literal); opener->inl_text->as.literal = cmark_chunk_literal(LEFTDOUBLEQUOTE); } closer = closer->next; } + if (!opener_found) { + // set lower bound for future searches for openers: + openers_bottom[old_closer->delim_char] = old_closer->previous; + if (!old_closer->can_open) { + // we can remove a closer that can't be an + // opener, once we've seen there's no + // matching opener: + remove_delimiter(subj, old_closer); + } + } } else { closer = closer->next; } } - // free all delimiters in list until start_delim: - while (subj->last_delim != start_delim) { + // free all delimiters in list until stack_bottom: + while (subj->last_delim != stack_bottom) { remove_delimiter(subj, subj->last_delim); } } @@ -583,8 +666,7 @@ static cmark_node* handle_backslash(subject *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 == '\r' || nextchar == '\n') { - advance(subj); + } else if (!is_eof(subj) && skip_line_end(subj)) { return make_linebreak(); } else { return make_str(cmark_chunk_literal("\\")); @@ -882,7 +964,7 @@ static cmark_node* handle_close_bracket(subject* subj, cmark_node *parent) inl->type = is_image ? NODE_IMAGE : NODE_LINK; cmark_chunk_free(&inl->as.literal); inl->first_child = link_text; - process_emphasis(subj, opener->previous); + process_emphasis(subj, opener); inl->as.link.url = url; inl->as.link.title = title; inl->next = NULL; @@ -897,10 +979,10 @@ static cmark_node* handle_close_bracket(subject* subj, cmark_node *parent) } 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.) + remove_delimiter(subj, opener); if (!is_image) { opener = subj->last_delim; while (opener != NULL) { @@ -926,9 +1008,7 @@ static cmark_node* handle_newline(subject *subj) // skip over newline advance(subj); // skip spaces at beginning of line - while (peek_char(subj) == ' ') { - advance(subj); - } + skip_spaces(subj); if (nlpos > 1 && peek_at(subj, nlpos - 1) == ' ' && peek_at(subj, nlpos - 2) == ' ') { @@ -1059,7 +1139,7 @@ static int parse_inline(subject* subj, cmark_node * parent, int options) subj->pos = endpos; // if we're at a newline, strip trailing spaces. - if (peek_char(subj) == '\r' || peek_char(subj) == '\n') { + if (S_is_line_end_char(peek_char(subj))) { cmark_chunk_rtrim(&contents); } @@ -1077,6 +1157,7 @@ extern void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap, { subject subj; subject_from_buf(&subj, &parent->string_content, refmap); + cmark_chunk_rtrim(&subj.input); while (!is_eof(&subj) && parse_inline(&subj, parent, options)) ; @@ -1086,11 +1167,9 @@ extern void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap, // 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) == '\r' || peek_char(subj) == '\n'))) { - advance(subj); + skip_spaces(subj); + if (skip_line_end(subj)) { + skip_spaces(subj); } } @@ -1143,14 +1222,19 @@ bufsize_t cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map subj.pos = beforetitle; title = cmark_chunk_literal(""); } + // parse final spaces and newline: - while (peek_char(&subj) == ' ') { - advance(&subj); - } - if (peek_char(&subj) == '\r' || peek_char(&subj) == '\n') { - advance(&subj); - } else if (peek_char(&subj) != 0) { - return 0; + skip_spaces(&subj); + if (!skip_line_end(&subj)) { + if (matchlen) { // try rewinding before title + subj.pos = beforetitle; + skip_spaces(&subj); + if (!skip_line_end(&subj)) { + return 0; + } + } else { + return 0; + } } // insert reference into refmap cmark_reference_create(refmap, &lab, &url, &title); diff --git a/latex.c b/latex.c new file mode 100644 index 0000000..782b0c0 --- /dev/null +++ b/latex.c @@ -0,0 +1,430 @@ +#include +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "utf8.h" +#include "scanners.h" +#include "render.h" + +#define safe_strlen(s) cmark_strbuf_safe_strlen(s) +#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping) +#define LIT(s) renderer->out(renderer, s, false, LITERAL) +#define CR() renderer->cr(renderer) +#define BLANKLINE() renderer->blankline(renderer) + +static inline void outc(cmark_renderer *renderer, + cmark_escaping escape, + int32_t c, + unsigned char nextc) +{ + if (escape == LITERAL) { + cmark_render_code_point(renderer, c); + return; + } + + switch(c) { + case 123: // '{' + case 125: // '}' + case 35: // '#' + case 37: // '%' + case 38: // '&' + cmark_render_ascii(renderer, "\\"); + cmark_render_code_point(renderer, c); + break; + case 36: // '$' + case 95: // '_' + if (escape == NORMAL) { + cmark_render_ascii(renderer, "\\"); + } + cmark_render_code_point(renderer, c); + break; + case 45 : // '-' + if (nextc == 45) { // prevent ligature + cmark_render_ascii(renderer, "\\-"); + } else { + cmark_render_ascii(renderer, "-"); + } + break; + case 126: // '~' + if (escape == NORMAL) { + cmark_render_ascii(renderer, "\\textasciitilde{}"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 94: // '^' + cmark_render_ascii(renderer, "\\^{}"); + break; + case 92: // '\\' + if (escape == URL) { + // / acts as path sep even on windows: + cmark_render_ascii(renderer, "/"); + } else { + cmark_render_ascii(renderer, "\\textbackslash{}"); + } + break; + case 124: // '|' + cmark_render_ascii(renderer, "\\textbar{}"); + break; + case 60: // '<' + cmark_render_ascii(renderer, "\\textless{}"); + break; + case 62: // '>' + cmark_render_ascii(renderer, "\\textgreater{}"); + break; + case 91: // '[' + case 93: // ']' + cmark_render_ascii(renderer, "{"); + cmark_render_code_point(renderer, c); + cmark_render_ascii(renderer, "}"); + break; + case 34: // '"' + cmark_render_ascii(renderer, "\\textquotedbl{}"); + // requires \usepackage[T1]{fontenc} + break; + case 39: // '\'' + cmark_render_ascii(renderer, "\\textquotesingle{}"); + // requires \usepackage{textcomp} + break; + case 160: // nbsp + cmark_render_ascii(renderer, "~"); + break; + case 8230: // hellip + cmark_render_ascii(renderer, "\\ldots{}"); + break; + case 8216: // lsquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "`"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8217: // rsquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "\'"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8220: // ldquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "``"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8221: // rdquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "''"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8212: // emdash + if (escape == NORMAL) { + cmark_render_ascii(renderer, "---"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8211: // endash + if (escape == NORMAL) { + cmark_render_ascii(renderer, "--"); + } else { + cmark_render_code_point(renderer, c); + } + break; + default: + cmark_render_code_point(renderer, c); + } +} + +typedef enum { + NO_LINK, + URL_AUTOLINK, + EMAIL_AUTOLINK, + NORMAL_LINK +} link_type; + +static link_type +get_link_type(cmark_node *node) +{ + size_t title_len, url_len; + cmark_node *link_text; + char *realurl; + int realurllen; + bool isemail = false; + + if (node->type != CMARK_NODE_LINK) { + return NO_LINK; + } + + const char* url = cmark_node_get_url(node); + cmark_chunk url_chunk = cmark_chunk_literal(url); + + url_len = safe_strlen(url); + if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) { + return NO_LINK; + } + + const char* title = cmark_node_get_title(node); + title_len = safe_strlen(title); + // if it has a title, we can't treat it as an autolink: + if (title_len > 0) { + return NORMAL_LINK; + } + + link_text = node->first_child; + cmark_consolidate_text_nodes(link_text); + realurl = (char*)url; + realurllen = url_len; + if (strncmp(realurl, "mailto:", 7) == 0) { + realurl += 7; + realurllen -= 7; + isemail = true; + } + if (realurllen == link_text->as.literal.len && + strncmp(realurl, + (char*)link_text->as.literal.data, + link_text->as.literal.len) == 0) { + if (isemail) { + return EMAIL_AUTOLINK; + } else { + return URL_AUTOLINK; + } + } else { + return NORMAL_LINK; + } +} + +static int +S_get_enumlevel(cmark_node *node) +{ + int enumlevel = 0; + cmark_node *tmp = node; + while (tmp) { + if (tmp->type == CMARK_NODE_LIST && + cmark_node_get_list_type(node) == CMARK_ORDERED_LIST) { + enumlevel++; + } + tmp = tmp->parent; + } + return enumlevel; +} + +static int +S_render_node(cmark_renderer *renderer, + cmark_node *node, + cmark_event_type ev_type, + int options) +{ + int list_number; + char list_number_string[20]; + bool entering = (ev_type == CMARK_EVENT_ENTER); + cmark_list_type list_type; + const char* roman_numerals[] = { "", "i", "ii", "iii", "iv", "v", + "vi", "vii", "viii", "ix", "x" + }; + + // avoid warning about unused parameter: + (void)(options); + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + LIT("\\begin{quote}"); + CR(); + } else { + LIT("\\end{quote}"); + BLANKLINE(); + } + break; + + case CMARK_NODE_LIST: + list_type = cmark_node_get_list_type(node); + if (entering) { + LIT("\\begin{"); + LIT(list_type == CMARK_ORDERED_LIST ? + "enumerate" : "itemize"); + LIT("}"); + CR(); + list_number = cmark_node_get_list_start(node); + if (list_number > 1) { + sprintf(list_number_string, + "%d", list_number); + LIT("\\setcounter{enum"); + LIT((char *)roman_numerals[S_get_enumlevel(node)]); + LIT("}{"); + OUT(list_number_string, false, NORMAL); + LIT("}"); + CR(); + } + } else { + LIT("\\end{"); + LIT(list_type == CMARK_ORDERED_LIST ? + "enumerate" : "itemize"); + LIT("}"); + BLANKLINE(); + } + break; + + case CMARK_NODE_ITEM: + if (entering) { + LIT("\\item "); + } else { + CR(); + } + break; + + case CMARK_NODE_HEADER: + if (entering) { + switch (cmark_node_get_header_level(node)) { + case 1: + LIT("\\section"); + break; + case 2: + LIT("\\subsection"); + break; + case 3: + LIT("\\subsubsection"); + break; + case 4: + LIT("\\paragraph"); + break; + case 5: + LIT("\\subparagraph"); + break; + } + LIT("{"); + } else { + LIT("}"); + BLANKLINE(); + } + break; + + case CMARK_NODE_CODE_BLOCK: + CR(); + LIT("\\begin{verbatim}"); + CR(); + OUT(cmark_node_get_literal(node), false, LITERAL); + CR(); + LIT("\\end{verbatim}"); + BLANKLINE(); + break; + + case CMARK_NODE_HTML: + break; + + case CMARK_NODE_HRULE: + BLANKLINE(); + LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}"); + BLANKLINE(); + break; + + case CMARK_NODE_PARAGRAPH: + if (!entering) { + BLANKLINE(); + } + break; + + case CMARK_NODE_TEXT: + OUT(cmark_node_get_literal(node), true, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + LIT("\\\\"); + CR(); + break; + + case CMARK_NODE_SOFTBREAK: + if (renderer->width == 0) { + CR(); + } else { + OUT(" ", true, NORMAL); + } + break; + + case CMARK_NODE_CODE: + LIT("\\texttt{"); + OUT(cmark_node_get_literal(node), false, NORMAL); + LIT("}"); + break; + + case CMARK_NODE_INLINE_HTML: + break; + + case CMARK_NODE_STRONG: + if (entering) { + LIT("\\textbf{"); + } else { + LIT("}"); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + LIT("\\emph{"); + } else { + LIT("}"); + } + break; + + case CMARK_NODE_LINK: + if (entering) { + const char* url = cmark_node_get_url(node); + // requires \usepackage{hyperref} + switch(get_link_type(node)) { + case URL_AUTOLINK: + LIT("\\url{"); + OUT(url, false, URL); + break; + case EMAIL_AUTOLINK: + LIT("\\href{"); + OUT(url, false, URL); + LIT("}\\nolinkurl{"); + break; + case NORMAL_LINK: + LIT("\\href{"); + OUT(url, false, URL); + LIT("}{"); + break; + case NO_LINK: + LIT("{"); // error? + } + } else { + LIT("}"); + } + + break; + + case CMARK_NODE_IMAGE: + if (entering) { + LIT("\\protect\\includegraphics{"); + // requires \include{graphicx} + OUT(cmark_node_get_url(node), false, URL); + LIT("}"); + return 0; + } + break; + + default: + assert(false); + break; + } + + return 1; +} + +char *cmark_render_latex(cmark_node *root, int options, int width) +{ + return cmark_render(root, options, width, outc, S_render_node); +} diff --git a/man.c b/man.c index 8ff4a9f..6ff33f5 100644 --- a/man.c +++ b/man.c @@ -8,110 +8,83 @@ #include "node.h" #include "buffer.h" #include "utf8.h" +#include "render.h" -// Functions to convert cmark_nodes to groff man strings. +#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping) +#define LIT(s) renderer->out(renderer, s, false, LITERAL) +#define CR() renderer->cr(renderer) +#define BLANKLINE() renderer->blankline(renderer) -static void escape_man(cmark_strbuf *dest, const unsigned char *source, int length) +// Functions to convert cmark_nodes to groff man strings. +static +void S_outc(cmark_renderer *renderer, + cmark_escaping escape, + int32_t c, + unsigned char nextc) { - int32_t c; - int i = 0; - int len; - bool beginLine = true; + (void)(nextc); - while (i < length) { - len = utf8proc_iterate(source + i, length - i, &c); - if (len == -1) { // error condition - return; // return without rendering anything + if (escape == LITERAL) { + cmark_render_code_point(renderer, c); + return; + } + + switch(c) { + case 46: + if (renderer->begin_line) { + cmark_render_ascii(renderer, "\\&."); + } else { + cmark_render_code_point(renderer, 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); + break; + case 39: + if (renderer->begin_line) { + cmark_render_ascii(renderer, "\\&'"); + } else { + cmark_render_code_point(renderer, c); } - beginLine = (c == 10); - i += len; + break; + case 45: + cmark_render_ascii(renderer, "\\-"); + break; + case 92: + cmark_render_ascii(renderer, "\\e"); + break; + case 8216: // left single quote + cmark_render_ascii(renderer, "\\[oq]"); + break; + case 8217: // right single quote + cmark_render_ascii(renderer, "\\[cq]"); + break; + case 8220: // left double quote + cmark_render_ascii(renderer, "\\[lq]"); + break; + case 8221: // right double quote + cmark_render_ascii(renderer, "\\[rq]"); + break; + case 8212: // em dash + cmark_render_ascii(renderer, "\\[em]"); + break; + case 8211: // en dash + cmark_render_ascii(renderer, "\\[en]"); + break; + default: + cmark_render_code_point(renderer, c); } } -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) +S_render_node(cmark_renderer *renderer, + cmark_node *node, + cmark_event_type ev_type, + int options) { 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; - } + // avoid unused parameter error: + (void)(options); switch (node->type) { case CMARK_NODE_DOCUMENT: @@ -119,13 +92,13 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_BLOCK_QUOTE: if (entering) { - cr(man); - cmark_strbuf_puts(man, ".RS"); - cr(man); + CR(); + LIT(".RS"); + CR(); } else { - cr(man); - cmark_strbuf_puts(man, ".RE"); - cr(man); + CR(); + LIT(".RE"); + CR(); } break; @@ -134,11 +107,11 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_ITEM: if (entering) { - cr(man); - cmark_strbuf_puts(man, ".IP "); + CR(); + LIT(".IP "); if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { - cmark_strbuf_puts(man, "\\[bu] 2"); + LIT("\\[bu] 2"); } else { list_number = cmark_node_get_list_start(node->parent); tmp = node; @@ -146,43 +119,45 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, tmp = tmp->prev; list_number += 1; } - cmark_strbuf_printf(man, "\"%d.\" 4", list_number); + char list_number_s[20]; + sprintf(list_number_s, "\"%d.\" 4", list_number); + LIT(list_number_s); } - cr(man); + CR(); } else { - cr(man); + CR(); } break; case CMARK_NODE_HEADER: if (entering) { - cr(man); - cmark_strbuf_puts(man, - cmark_node_get_header_level(node) == 1 ? - ".SH" : ".SS"); - cr(man); + CR(); + LIT(cmark_node_get_header_level(node) == 1 ? + ".SH" : ".SS"); + CR(); } else { - cr(man); + CR(); } 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); + CR(); + LIT(".IP\n.nf\n\\f[C]\n"); + OUT(cmark_node_get_literal(node), + false, + NORMAL); + CR(); + LIT("\\f[]\n.fi"); + CR(); break; case CMARK_NODE_HTML: break; case CMARK_NODE_HRULE: - cr(man); - cmark_strbuf_puts(man, ".PP\n * * * * *"); - cr(man); + CR(); + LIT(".PP\n * * * * *"); + CR(); break; case CMARK_NODE_PARAGRAPH: @@ -193,32 +168,36 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, node->prev == NULL) { // no blank line or .PP } else { - cr(man); - cmark_strbuf_puts(man, ".PP\n"); + CR(); + LIT(".PP"); + CR(); } } else { - cr(man); + CR(); } break; case CMARK_NODE_TEXT: - escape_man(man, node->as.literal.data, - node->as.literal.len); + OUT(cmark_node_get_literal(node), true, NORMAL); break; case CMARK_NODE_LINEBREAK: - cmark_strbuf_puts(man, ".PD 0\n.P\n.PD"); - cr(man); + LIT(".PD 0\n.P\n.PD"); + CR(); break; case CMARK_NODE_SOFTBREAK: - cmark_strbuf_putc(man, '\n'); + if (renderer->width == 0) { + CR(); + } else { + OUT(" ", true, LITERAL); + } 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[]"); + LIT("\\f[C]"); + OUT(cmark_node_get_literal(node), true, NORMAL); + LIT("\\f[]"); break; case CMARK_NODE_INLINE_HTML: @@ -226,33 +205,33 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_STRONG: if (entering) { - cmark_strbuf_puts(man, "\\f[B]"); + LIT("\\f[B]"); } else { - cmark_strbuf_puts(man, "\\f[]"); + LIT("\\f[]"); } break; case CMARK_NODE_EMPH: if (entering) { - cmark_strbuf_puts(man, "\\f[I]"); + LIT("\\f[I]"); } else { - cmark_strbuf_puts(man, "\\f[]"); + LIT("\\f[]"); } break; case CMARK_NODE_LINK: if (!entering) { - cmark_strbuf_printf(man, " (%s)", - cmark_node_get_url(node)); + LIT(" ("); + OUT(cmark_node_get_url(node), true, URL); + LIT(")"); } break; case CMARK_NODE_IMAGE: if (entering) { - cmark_strbuf_puts(man, "[IMAGE: "); - state->plain = node; + LIT("[IMAGE: "); } else { - cmark_strbuf_puts(man, "]"); + LIT("]"); } break; @@ -261,27 +240,10 @@ S_render_node(cmark_node *node, cmark_event_type ev_type, break; } - // cmark_strbuf_putc(man, 'x'); return 1; } -char *cmark_render_man(cmark_node *root, int options) +char *cmark_render_man(cmark_node *root, int options, int width) { - 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; + return cmark_render(root, options, width, S_outc, S_render_node); } diff --git a/node.go b/node.go index 6453a6b..56c402a 100644 --- a/node.go +++ b/node.go @@ -68,6 +68,8 @@ const CMARK_OPT_SOURCEPOS = 1 const CMARK_OPT_HARDBREAKS = 2 const CMARK_OPT_NORMALIZE = 4 const CMARK_OPT_SMART = 8 +const CMARK_OPT_VALIDATE_UTF8 = 16 +const CMARK_OPT_SAFE = 32 //converts C int return codes to True/False :) func success(code C.int) bool { @@ -110,8 +112,8 @@ func (node *CMarkNode) RenderHtml(options int) string { // Renders the document as a groff man page, // without the header -func (node *CMarkNode) RenderMan(options int) string { - result := C.cmark_render_man(node.node, C.int(options)) +func (node *CMarkNode) RenderMan(options int, width int) string { + result := C.cmark_render_man(node.node, C.int(options), C.int(width)) defer C.free(unsafe.Pointer(result)) return C.GoString(result) } @@ -123,6 +125,13 @@ func (node *CMarkNode) RenderCMark(options int, width int) string { return C.GoString(result) } +// Renders node tree as a LaTeX document +func (node *CMarkNode) RenderLatex(options int, width int) string { + result := C.cmark_render_latex(node.node, C.int(options), C.int(width)) + defer C.free(unsafe.Pointer(result)) + return C.GoString(result) +} + // Cleanup a node, including any children. // Unlinks a node from the tree and frees it. func (node *CMarkNode) Free() { diff --git a/node.h b/node.h index 911a18f..b579408 100644 --- a/node.h +++ b/node.h @@ -69,6 +69,7 @@ struct cmark_node { cmark_code code; cmark_header header; cmark_link link; + int html_block_type; } as; }; diff --git a/parser.h b/parser.h index 6e18c67..01a7aeb 100644 --- a/parser.h +++ b/parser.h @@ -17,7 +17,9 @@ struct cmark_parser { struct cmark_node* current; int line_number; bufsize_t offset; + bufsize_t column; bufsize_t first_nonspace; + bufsize_t first_nonspace_column; int indent; bool blank; cmark_strbuf *curline; diff --git a/render.c b/render.c new file mode 100644 index 0000000..2f1faac --- /dev/null +++ b/render.c @@ -0,0 +1,186 @@ +#include +#include "buffer.h" +#include "chunk.h" +#include "cmark.h" +#include "utf8.h" +#include "render.h" + +static inline +void S_cr(cmark_renderer *renderer) +{ + if (renderer->need_cr < 1) { + renderer->need_cr = 1; + } +} + +static inline +void S_blankline(cmark_renderer *renderer) +{ + if (renderer->need_cr < 2) { + renderer->need_cr = 2; + } +} + +static +void S_out(cmark_renderer *renderer, + const char *source, + bool wrap, + cmark_escaping escape) +{ + int length = cmark_strbuf_safe_strlen(source); + unsigned char nextc; + int32_t c; + int i = 0; + int len; + cmark_chunk remainder = cmark_chunk_literal(""); + int k = renderer->buffer->size - 1; + + wrap = wrap && !renderer->no_wrap; + + if (renderer->in_tight_list_item && renderer->need_cr > 1) { + renderer->need_cr = 1; + } + while (renderer->need_cr) { + if (k < 0 || renderer->buffer->ptr[k] == '\n') { + k -= 1; + } else { + cmark_strbuf_putc(renderer->buffer, '\n'); + if (renderer->need_cr > 1) { + cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, + renderer->prefix->size); + } + } + renderer->column = 0; + renderer->begin_line = true; + renderer->need_cr -= 1; + } + + while (i < length) { + if (renderer->begin_line) { + cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, + renderer->prefix->size); + // note: this assumes prefix is ascii: + renderer->column = renderer->prefix->size; + } + + len = utf8proc_iterate((const uint8_t *)source + i, length - i, &c); + if (len == -1) { // error condition + return; // return without rendering rest of string + } + nextc = source[i + len]; + if (c == 32 && wrap) { + if (!renderer->begin_line) { + cmark_strbuf_putc(renderer->buffer, ' '); + renderer->column += 1; + renderer->begin_line = false; + renderer->last_breakable = renderer->buffer->size - + 1; + // skip following spaces + while (source[i + 1] == ' ') { + i++; + } + } + + } else if (c == 10) { + cmark_strbuf_putc(renderer->buffer, '\n'); + renderer->column = 0; + renderer->begin_line = true; + renderer->last_breakable = 0; + } else if (escape == LITERAL) { + cmark_render_code_point(renderer, c); + renderer->begin_line = false; + } else { + (renderer->outc)(renderer, escape, c, nextc); + renderer->begin_line = false; + } + + // If adding the character went beyond width, look for an + // earlier place where the line could be broken: + if (renderer->width > 0 && + renderer->column > renderer->width && + !renderer->begin_line && + renderer->last_breakable > 0) { + + // copy from last_breakable to remainder + cmark_chunk_set_cstr(&remainder, (char *) renderer->buffer->ptr + renderer->last_breakable + 1); + // truncate at last_breakable + cmark_strbuf_truncate(renderer->buffer, renderer->last_breakable); + // add newline, prefix, and remainder + cmark_strbuf_putc(renderer->buffer, '\n'); + cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, + renderer->prefix->size); + cmark_strbuf_put(renderer->buffer, remainder.data, remainder.len); + renderer->column = renderer->prefix->size + remainder.len; + cmark_chunk_free(&remainder); + renderer->last_breakable = 0; + renderer->begin_line = false; + } + + i += len; + } +} + +// Assumes no newlines, assumes ascii content: +void +cmark_render_ascii(cmark_renderer* renderer, const char* s) +{ + int origsize = renderer->buffer->size; + cmark_strbuf_puts(renderer->buffer, s); + renderer->column += renderer->buffer->size - origsize; +} + +void +cmark_render_code_point(cmark_renderer *renderer, uint32_t c) +{ + utf8proc_encode_char(c, renderer->buffer); + renderer->column += 1; +} + +char* +cmark_render(cmark_node *root, + int options, + int width, + void (*outc)(cmark_renderer*, + cmark_escaping, + int32_t, + unsigned char), + int (*render_node)(cmark_renderer *renderer, + cmark_node *node, + cmark_event_type ev_type, + int options)) +{ + cmark_strbuf pref = GH_BUF_INIT; + cmark_strbuf buf = GH_BUF_INIT; + cmark_node *cur; + cmark_event_type ev_type; + char *result; + cmark_iter *iter = cmark_iter_new(root); + + cmark_renderer renderer = { &buf, &pref, 0, width, + 0, 0, true, false, false, + outc, S_cr, S_blankline, S_out + }; + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + if (!render_node(&renderer, cur, ev_type, options)) { + // a false value causes us to skip processing + // the node's contents. this is used for + // autolinks. + cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT); + } + } + + // ensure final newline + if (renderer.buffer->ptr[renderer.buffer->size - 1] != '\n') { + cmark_strbuf_putc(renderer.buffer, '\n'); + } + + result = (char *)cmark_strbuf_detach(renderer.buffer); + + cmark_iter_free(iter); + cmark_strbuf_free(renderer.prefix); + cmark_strbuf_free(renderer.buffer); + + return result; +} diff --git a/render.h b/render.h new file mode 100644 index 0000000..ca541bc --- /dev/null +++ b/render.h @@ -0,0 +1,66 @@ +#ifndef CMARK_RENDER_H +#define CMARK_RENDER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "buffer.h" +#include "chunk.h" + +typedef enum { + LITERAL, + NORMAL, + TITLE, + URL +} cmark_escaping; + +struct cmark_renderer { + cmark_strbuf* buffer; + cmark_strbuf* prefix; + int column; + int width; + int need_cr; + bufsize_t last_breakable; + bool begin_line; + bool no_wrap; + bool in_tight_list_item; + void (*outc)(struct cmark_renderer*, + cmark_escaping, + int32_t, + unsigned char); + void (*cr)(struct cmark_renderer*); + void (*blankline)(struct cmark_renderer*); + void (*out)(struct cmark_renderer*, + const char *, + bool, + cmark_escaping); +}; + +typedef struct cmark_renderer cmark_renderer; + +void +cmark_render_ascii(cmark_renderer *renderer, const char* s); + +void +cmark_render_code_point(cmark_renderer *renderer, uint32_t c); + +char* +cmark_render(cmark_node *root, + int options, + int width, + void (*outc)(cmark_renderer*, + cmark_escaping, + int32_t, + unsigned char), + int (*render_node)(cmark_renderer *renderer, + cmark_node *node, + cmark_event_type ev_type, + int options)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/scanners.c b/scanners.c index 3f4ddac..75fdb46 100644 --- a/scanners.c +++ b/scanners.c @@ -1,4 +1,4 @@ -/* Generated by re2c 0.13.5 */ +/* Generated by re2c 0.14.3 */ #include #include "chunk.h" #include "scanners.h" @@ -27,62 +27,124 @@ bufsize_t _scan_scheme(const unsigned char *p) { unsigned char yych; - 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; + yych = *(marker = p); + if (yych <= 'c') { + if (yych <= 'M') { + if (yych <= 'E') { + if (yych <= 'A') { + if (yych == '\n') goto yy2; + if (yych <= '@') goto yy29; + goto yy6; + } else { + if (yych <= 'B') goto yy24; + if (yych <= 'C') goto yy3; + if (yych <= 'D') goto yy4; + goto yy25; + } + } else { + if (yych <= 'I') { + if (yych <= 'F') goto yy7; + if (yych <= 'G') goto yy8; + if (yych <= 'H') goto yy9; + goto yy10; + } else { + if (yych <= 'J') goto yy5; + if (yych <= 'K') goto yy26; + if (yych <= 'L') goto yy11; + goto yy12; + } + } + } else { + if (yych <= 'U') { + if (yych <= 'Q') { + if (yych <= 'N') goto yy13; + if (yych <= 'O') goto yy14; + if (yych <= 'P') goto yy15; + goto yy27; + } else { + if (yych <= 'R') goto yy16; + if (yych <= 'S') goto yy17; + if (yych <= 'T') goto yy18; + goto yy19; + } + } else { + if (yych <= 'Y') { + if (yych <= 'V') goto yy20; + if (yych <= 'W') goto yy21; + if (yych <= 'X') goto yy22; + goto yy28; + } else { + if (yych <= '`') { + if (yych <= 'Z') goto yy23; + goto yy29; + } else { + if (yych <= 'a') goto yy6; + if (yych <= 'b') goto yy24; + goto yy3; + } + } + } + } + } else { + if (yych <= 't') { + if (yych <= 'k') { + if (yych <= 'g') { + if (yych <= 'd') goto yy4; + if (yych <= 'e') goto yy25; + if (yych <= 'f') goto yy7; + goto yy8; + } else { + if (yych <= 'h') goto yy9; + if (yych <= 'i') goto yy10; + if (yych <= 'j') goto yy5; + goto yy26; + } + } else { + if (yych <= 'o') { + if (yych <= 'l') goto yy11; + if (yych <= 'm') goto yy12; + if (yych <= 'n') goto yy13; + goto yy14; + } else { + if (yych <= 'q') { + if (yych <= 'p') goto yy15; + goto yy27; + } else { + if (yych <= 'r') goto yy16; + if (yych <= 's') goto yy17; + goto yy18; + } + } + } + } else { + if (yych <= 0xC1) { + if (yych <= 'x') { + if (yych <= 'u') goto yy19; + if (yych <= 'v') goto yy20; + if (yych <= 'w') goto yy21; + goto yy22; + } else { + if (yych <= 'y') goto yy28; + if (yych <= 'z') goto yy23; + if (yych <= 0x7F) goto yy29; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy30; + if (yych <= 0xE0) goto yy32; + if (yych <= 0xEC) goto yy33; + goto yy37; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy33; + goto yy34; + } else { + if (yych <= 0xF3) goto yy35; + if (yych <= 0xF4) goto yy36; + } + } + } + } } yy2: { return 0; } @@ -90,50 +152,50 @@ bufsize_t _scan_scheme(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy440; + case 'a': goto yy447; case 'H': - case 'h': goto yy439; + case 'h': goto yy446; case 'I': - case 'i': goto yy442; + case 'i': goto yy449; case 'O': - case 'o': goto yy438; + case 'o': goto yy445; case 'R': - case 'r': goto yy441; + case 'r': goto yy448; case 'V': - case 'v': goto yy437; + case 'v': goto yy444; default: goto yy2; } yy4: yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy413; + case 'a': goto yy420; case 'I': - case 'i': goto yy412; + case 'i': goto yy419; case 'L': - case 'l': goto yy410; + case 'l': goto yy417; case 'N': - case 'n': goto yy411; + case 'n': goto yy418; case 'O': - case 'o': goto yy414; + case 'o': goto yy421; case 'T': - case 't': goto yy409; + case 't': goto yy416; case 'V': - case 'v': goto yy408; + case 'v': goto yy415; default: goto yy2; } yy5: yych = *(marker = ++p); if (yych <= 'M') { - if (yych == 'A') goto yy400; + if (yych == 'A') goto yy407; if (yych <= 'L') goto yy2; - goto yy399; + goto yy406; } else { if (yych <= 'a') { if (yych <= '`') goto yy2; - goto yy400; + goto yy407; } else { - if (yych == 'm') goto yy399; + if (yych == 'm') goto yy406; goto yy2; } } @@ -141,48 +203,48 @@ bufsize_t _scan_scheme(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy381; + case 'a': goto yy388; case 'B': - case 'b': goto yy380; + case 'b': goto yy387; case 'C': - case 'c': goto yy379; + case 'c': goto yy386; case 'D': - case 'd': goto yy378; + case 'd': goto yy385; case 'F': - case 'f': goto yy377; + case 'f': goto yy384; case 'I': - case 'i': goto yy376; + case 'i': goto yy383; case 'P': - case 'p': goto yy375; + case 'p': goto yy382; case 'T': - case 't': goto yy374; + case 't': goto yy381; case 'W': - case 'w': goto yy34; + case 'w': goto yy41; default: goto yy2; } yy7: yych = *(marker = ++p); if (yych <= 'T') { if (yych <= 'E') { - if (yych == 'A') goto yy361; + if (yych == 'A') goto yy368; if (yych <= 'D') goto yy2; - goto yy360; + goto yy367; } else { - if (yych == 'I') goto yy359; + if (yych == 'I') goto yy366; if (yych <= 'S') goto yy2; - goto yy362; + goto yy369; } } else { if (yych <= 'e') { - if (yych == 'a') goto yy361; + if (yych == 'a') goto yy368; if (yych <= 'd') goto yy2; - goto yy360; + goto yy367; } else { if (yych <= 'i') { if (yych <= 'h') goto yy2; - goto yy359; + goto yy366; } else { - if (yych == 't') goto yy362; + if (yych == 't') goto yy369; goto yy2; } } @@ -191,15 +253,15 @@ bufsize_t _scan_scheme(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'E': - case 'e': goto yy344; + case 'e': goto yy351; case 'G': - case 'g': goto yy34; + case 'g': goto yy41; case 'I': - case 'i': goto yy342; + case 'i': goto yy349; case 'O': - case 'o': goto yy343; + case 'o': goto yy350; case 'T': - case 't': goto yy341; + case 't': goto yy348; default: goto yy2; } yy9: @@ -207,18 +269,18 @@ bufsize_t _scan_scheme(const unsigned char *p) if (yych <= 'S') { if (yych <= '3') { if (yych <= '2') goto yy2; - goto yy337; + goto yy344; } else { - if (yych == 'C') goto yy335; + if (yych == 'C') goto yy342; goto yy2; } } else { if (yych <= 'c') { - if (yych <= 'T') goto yy336; + if (yych <= 'T') goto yy343; if (yych <= 'b') goto yy2; - goto yy335; + goto yy342; } else { - if (yych == 't') goto yy336; + if (yych == 't') goto yy343; goto yy2; } } @@ -226,33 +288,33 @@ bufsize_t _scan_scheme(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy317; + case 'a': goto yy324; case 'C': - case 'c': goto yy314; + case 'c': goto yy321; case 'M': - case 'm': goto yy316; + case 'm': goto yy323; case 'N': - case 'n': goto yy315; + case 'n': goto yy322; case 'P': - case 'p': goto yy313; + case 'p': goto yy320; case 'R': - case 'r': goto yy312; + case 'r': goto yy319; case 'T': - case 't': goto yy311; + case 't': goto yy318; default: goto yy2; } yy11: yych = *(marker = ++p); if (yych <= 'D') { - if (yych == 'A') goto yy305; + if (yych == 'A') goto yy312; if (yych <= 'C') goto yy2; - goto yy304; + goto yy311; } else { if (yych <= 'a') { if (yych <= '`') goto yy2; - goto yy305; + goto yy312; } else { - if (yych == 'd') goto yy304; + if (yych == 'd') goto yy311; goto yy2; } } @@ -260,50 +322,50 @@ bufsize_t _scan_scheme(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy271; + case 'a': goto yy278; case 'E': - case 'e': goto yy270; + case 'e': goto yy277; case 'I': - case 'i': goto yy273; + case 'i': goto yy280; case 'M': - case 'm': goto yy269; + case 'm': goto yy276; case 'S': - case 's': goto yy268; + case 's': goto yy275; case 'T': - case 't': goto yy272; + case 't': goto yy279; case 'U': - case 'u': goto yy267; + case 'u': goto yy274; case 'V': - case 'v': goto yy266; + case 'v': goto yy273; default: goto yy2; } yy13: yych = *(marker = ++p); switch (yych) { case 'E': - case 'e': goto yy261; + case 'e': goto yy268; case 'F': - case 'f': goto yy260; + case 'f': goto yy267; case 'I': - case 'i': goto yy259; + case 'i': goto yy266; case 'N': - case 'n': goto yy258; + case 'n': goto yy265; case 'O': - case 'o': goto yy257; + case 'o': goto yy264; default: goto yy2; } yy14: yych = *(marker = ++p); if (yych <= 'P') { - if (yych == 'I') goto yy243; + if (yych == 'I') goto yy250; if (yych <= 'O') goto yy2; - goto yy244; + goto yy251; } else { if (yych <= 'i') { if (yych <= 'h') goto yy2; - goto yy243; + goto yy250; } else { - if (yych == 'p') goto yy244; + if (yych == 'p') goto yy251; goto yy2; } } @@ -311,35 +373,35 @@ bufsize_t _scan_scheme(const unsigned char *p) yych = *(marker = ++p); if (yych <= 'S') { if (yych <= 'L') { - if (yych == 'A') goto yy225; + if (yych == 'A') goto yy232; if (yych <= 'K') goto yy2; - goto yy224; + goto yy231; } else { if (yych <= 'O') { if (yych <= 'N') goto yy2; - goto yy226; + goto yy233; } else { if (yych <= 'Q') goto yy2; - if (yych <= 'R') goto yy223; - goto yy222; + if (yych <= 'R') goto yy230; + goto yy229; } } } else { if (yych <= 'n') { if (yych <= 'a') { if (yych <= '`') goto yy2; - goto yy225; + goto yy232; } else { - if (yych == 'l') goto yy224; + if (yych == 'l') goto yy231; goto yy2; } } else { if (yych <= 'q') { - if (yych <= 'o') goto yy226; + if (yych <= 'o') goto yy233; goto yy2; } else { - if (yych <= 'r') goto yy223; - if (yych <= 's') goto yy222; + if (yych <= 'r') goto yy230; + if (yych <= 's') goto yy229; goto yy2; } } @@ -348,23 +410,23 @@ bufsize_t _scan_scheme(const unsigned char *p) yych = *(marker = ++p); if (yych <= 'T') { if (yych <= 'L') { - if (yych == 'E') goto yy212; + if (yych == 'E') goto yy219; goto yy2; } else { - if (yych <= 'M') goto yy211; + if (yych <= 'M') goto yy218; if (yych <= 'R') goto yy2; - if (yych <= 'S') goto yy210; - goto yy209; + if (yych <= 'S') goto yy217; + goto yy216; } } else { if (yych <= 'm') { - if (yych == 'e') goto yy212; + if (yych == 'e') goto yy219; if (yych <= 'l') goto yy2; - goto yy211; + goto yy218; } else { if (yych <= 'r') goto yy2; - if (yych <= 's') goto yy210; - if (yych <= 't') goto yy209; + if (yych <= 's') goto yy217; + if (yych <= 't') goto yy216; goto yy2; } } @@ -372,75 +434,75 @@ bufsize_t _scan_scheme(const unsigned char *p) yych = *(marker = ++p); switch (yych) { case 'E': - case 'e': goto yy165; + case 'e': goto yy172; case 'F': - case 'f': goto yy164; + case 'f': goto yy171; case 'G': - case 'g': goto yy163; + case 'g': goto yy170; case 'H': - case 'h': goto yy168; + case 'h': goto yy175; case 'I': - case 'i': goto yy167; + case 'i': goto yy174; case 'K': - case 'k': goto yy162; + case 'k': goto yy169; case 'M': - case 'm': goto yy161; + case 'm': goto yy168; case 'N': - case 'n': goto yy166; + case 'n': goto yy173; case 'O': - case 'o': goto yy160; + case 'o': goto yy167; case 'P': - case 'p': goto yy159; + case 'p': goto yy166; case 'S': - case 's': goto yy158; + case 's': goto yy165; case 'T': - case 't': goto yy157; + case 't': goto yy164; case 'V': - case 'v': goto yy156; + case 'v': goto yy163; default: goto yy2; } yy18: yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy132; + case 'a': goto yy139; case 'E': - case 'e': goto yy128; + case 'e': goto yy135; case 'F': - case 'f': goto yy131; + case 'f': goto yy138; case 'H': - case 'h': goto yy127; + case 'h': goto yy134; case 'I': - case 'i': goto yy129; + case 'i': goto yy136; case 'N': - case 'n': goto yy130; + case 'n': goto yy137; case 'V': - case 'v': goto yy34; + case 'v': goto yy41; default: goto yy2; } yy19: yych = *(marker = ++p); if (yych <= 'T') { if (yych <= 'N') { - if (yych == 'D') goto yy119; + if (yych == 'D') goto yy126; if (yych <= 'M') goto yy2; - goto yy118; + goto yy125; } else { - if (yych == 'R') goto yy120; + if (yych == 'R') goto yy127; if (yych <= 'S') goto yy2; - goto yy117; + goto yy124; } } else { if (yych <= 'n') { - if (yych == 'd') goto yy119; + if (yych == 'd') goto yy126; if (yych <= 'm') goto yy2; - goto yy118; + goto yy125; } else { if (yych <= 'r') { if (yych <= 'q') goto yy2; - goto yy120; + goto yy127; } else { - if (yych == 't') goto yy117; + if (yych == 't') goto yy124; goto yy2; } } @@ -448,15 +510,15 @@ bufsize_t _scan_scheme(const unsigned char *p) yy20: yych = *(marker = ++p); if (yych <= 'I') { - if (yych == 'E') goto yy101; + if (yych == 'E') goto yy108; if (yych <= 'H') goto yy2; - goto yy100; + goto yy107; } else { if (yych <= 'e') { if (yych <= 'd') goto yy2; - goto yy101; + goto yy108; } else { - if (yych == 'i') goto yy100; + if (yych == 'i') goto yy107; goto yy2; } } @@ -464,22 +526,22 @@ bufsize_t _scan_scheme(const unsigned char *p) yych = *(marker = ++p); if (yych <= 'Y') { if (yych <= 'R') { - if (yych == 'E') goto yy90; + if (yych == 'E') goto yy97; goto yy2; } else { - if (yych <= 'S') goto yy91; - if (yych <= 'T') goto yy89; + if (yych <= 'S') goto yy98; + if (yych <= 'T') goto yy96; if (yych <= 'X') goto yy2; - goto yy88; + goto yy95; } } else { if (yych <= 's') { - if (yych == 'e') goto yy90; + if (yych == 'e') goto yy97; if (yych <= 'r') goto yy2; - goto yy91; + goto yy98; } else { - if (yych <= 't') goto yy89; - if (yych == 'y') goto yy88; + if (yych <= 't') goto yy96; + if (yych == 'y') goto yy95; goto yy2; } } @@ -487,193 +549,227 @@ bufsize_t _scan_scheme(const unsigned char *p) yych = *(marker = ++p); if (yych <= 'R') { if (yych <= 'F') { - if (yych == 'C') goto yy67; + if (yych == 'C') goto yy74; if (yych <= 'E') goto yy2; - goto yy65; + goto yy72; } else { - if (yych == 'M') goto yy66; + if (yych == 'M') goto yy73; if (yych <= 'Q') goto yy2; - goto yy64; + goto yy71; } } else { if (yych <= 'f') { - if (yych == 'c') goto yy67; + if (yych == 'c') goto yy74; if (yych <= 'e') goto yy2; - goto yy65; + goto yy72; } else { if (yych <= 'm') { if (yych <= 'l') goto yy2; - goto yy66; + goto yy73; } else { - if (yych == 'r') goto yy64; + if (yych == 'r') goto yy71; goto yy2; } } } yy23: yych = *(marker = ++p); - if (yych == '3') goto yy59; + if (yych == '3') goto yy66; goto yy2; yy24: yych = *(marker = ++p); if (yych <= 'O') { if (yych <= 'H') { - if (yych == 'E') goto yy49; + if (yych == 'E') goto yy56; goto yy2; } else { - if (yych <= 'I') goto yy48; + if (yych <= 'I') goto yy55; if (yych <= 'N') goto yy2; - goto yy47; + goto yy54; } } else { if (yych <= 'h') { - if (yych == 'e') goto yy49; + if (yych == 'e') goto yy56; goto yy2; } else { - if (yych <= 'i') goto yy48; - if (yych == 'o') goto yy47; + if (yych <= 'i') goto yy55; + if (yych == 'o') goto yy54; goto yy2; } } yy25: yych = *(marker = ++p); - if (yych == 'D') goto yy45; - if (yych == 'd') goto yy45; + if (yych == 'D') goto yy52; + if (yych == 'd') goto yy52; goto yy2; yy26: yych = *(marker = ++p); - if (yych == 'E') goto yy40; - if (yych == 'e') goto yy40; + if (yych == 'E') goto yy47; + if (yych == 'e') goto yy47; goto yy2; yy27: yych = *(marker = ++p); - if (yych == 'U') goto yy37; - if (yych == 'u') goto yy37; + if (yych == 'U') goto yy44; + if (yych == 'u') goto yy44; goto yy2; yy28: yych = *(marker = ++p); - if (yych == 'M') goto yy30; - if (yych == 'm') goto yy30; + if (yych == 'M') goto yy38; + if (yych == 'm') goto yy38; goto yy2; yy29: yych = *++p; goto yy2; yy30: yych = *++p; - if (yych == 'S') goto yy32; - if (yych == 's') goto yy32; + if (yych <= 0x7F) goto yy31; + if (yych <= 0xBF) goto yy29; yy31: p = marker; goto yy2; yy32: yych = *++p; - if (yych == 'G') goto yy33; - if (yych != 'g') goto yy31; + if (yych <= 0x9F) goto yy31; + if (yych <= 0xBF) goto yy30; + goto yy31; yy33: yych = *++p; - if (yych == 'R') goto yy34; - if (yych != 'r') goto yy31; + if (yych <= 0x7F) goto yy31; + if (yych <= 0xBF) goto yy30; + goto yy31; yy34: yych = *++p; - if (yych != ':') goto yy31; + if (yych <= 0x8F) goto yy31; + if (yych <= 0xBF) goto yy33; + goto yy31; yy35: - ++p; - { return (bufsize_t)(p - start); } + yych = *++p; + if (yych <= 0x7F) goto yy31; + if (yych <= 0xBF) goto yy33; + goto yy31; +yy36: + yych = *++p; + if (yych <= 0x7F) goto yy31; + if (yych <= 0x8F) goto yy33; + goto yy31; yy37: yych = *++p; - if (yych == 'E') goto yy38; - if (yych != 'e') goto yy31; + if (yych <= 0x7F) goto yy31; + if (yych <= 0x9F) goto yy30; + goto yy31; yy38: yych = *++p; - if (yych == 'R') goto yy39; - if (yych != 'r') goto yy31; + if (yych == 'S') goto yy39; + if (yych != 's') goto yy31; yy39: yych = *++p; - if (yych == 'Y') goto yy34; - if (yych == 'y') goto yy34; - goto yy31; + if (yych == 'G') goto yy40; + if (yych != 'g') goto yy31; yy40: + yych = *++p; + if (yych == 'R') goto yy41; + if (yych != 'r') goto yy31; +yy41: + yych = *++p; + if (yych != ':') goto yy31; +yy42: + ++p; + { return (bufsize_t)(p - start); } +yy44: + yych = *++p; + if (yych == 'E') goto yy45; + if (yych != 'e') goto yy31; +yy45: + yych = *++p; + if (yych == 'R') goto yy46; + if (yych != 'r') goto yy31; +yy46: yych = *++p; if (yych == 'Y') goto yy41; + if (yych == 'y') goto yy41; + goto yy31; +yy47: + yych = *++p; + if (yych == 'Y') goto yy48; if (yych != 'y') goto yy31; -yy41: +yy48: yych = *++p; - if (yych == 'P') goto yy42; + if (yych == 'P') goto yy49; if (yych != 'p') goto yy31; -yy42: +yy49: yych = *++p; - if (yych == 'A') goto yy43; + if (yych == 'A') goto yy50; if (yych != 'a') goto yy31; -yy43: +yy50: yych = *++p; - if (yych == 'R') goto yy44; + if (yych == 'R') goto yy51; if (yych != 'r') goto yy31; -yy44: +yy51: yych = *++p; - if (yych == 'C') goto yy34; - if (yych == 'c') goto yy34; + if (yych == 'C') goto yy41; + if (yych == 'c') goto yy41; goto yy31; -yy45: +yy52: yych = *++p; if (yych != '2') goto yy31; yych = *++p; - if (yych == 'K') goto yy34; - if (yych == 'k') goto yy34; + if (yych == 'K') goto yy41; + if (yych == 'k') goto yy41; goto yy31; -yy47: +yy54: yych = *++p; - if (yych == 'L') goto yy58; - if (yych == 'l') goto yy58; + if (yych == 'L') goto yy65; + if (yych == 'l') goto yy65; goto yy31; -yy48: +yy55: yych = *++p; - if (yych == 'T') goto yy54; - if (yych == 't') goto yy54; + if (yych == 'T') goto yy61; + if (yych == 't') goto yy61; goto yy31; -yy49: +yy56: yych = *++p; - if (yych == 'S') goto yy50; + if (yych == 'S') goto yy57; if (yych != 's') goto yy31; -yy50: +yy57: yych = *++p; - if (yych == 'H') goto yy51; + if (yych == 'H') goto yy58; if (yych != 'h') goto yy31; -yy51: +yy58: yych = *++p; - if (yych == 'A') goto yy52; + if (yych == 'A') goto yy59; if (yych != 'a') goto yy31; -yy52: +yy59: yych = *++p; - if (yych == 'R') goto yy53; + if (yych == 'R') goto yy60; if (yych != 'r') goto yy31; -yy53: +yy60: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy54: +yy61: yych = *++p; - if (yych == 'C') goto yy55; + if (yych == 'C') goto yy62; if (yych != 'c') goto yy31; -yy55: +yy62: yych = *++p; - if (yych == 'O') goto yy56; + if (yych == 'O') goto yy63; if (yych != 'o') goto yy31; -yy56: +yy63: yych = *++p; - if (yych == 'I') goto yy57; + if (yych == 'I') goto yy64; if (yych != 'i') goto yy31; -yy57: +yy64: yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; + if (yych == 'N') goto yy41; + if (yych == 'n') goto yy41; goto yy31; -yy58: +yy65: yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; + if (yych == 'O') goto yy41; + if (yych == 'o') goto yy41; goto yy31; -yy59: +yy66: yych = *++p; if (yych != '9') goto yy31; yych = *++p; @@ -684,2235 +780,2235 @@ bufsize_t _scan_scheme(const unsigned char *p) if (yych != '0') goto yy31; yych = *++p; if (yych <= 'Q') goto yy31; - if (yych <= 'S') goto yy34; + if (yych <= 'S') goto yy41; if (yych <= 'q') goto yy31; - if (yych <= 's') goto yy34; + if (yych <= 's') goto yy41; goto yy31; -yy64: +yy71: yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; + if (yych == 'I') goto yy41; + if (yych == 'i') goto yy41; goto yy31; -yy65: +yy72: yych = *++p; - if (yych == 'I') goto yy86; - if (yych == 'i') goto yy86; + if (yych == 'I') goto yy93; + if (yych == 'i') goto yy93; goto yy31; -yy66: +yy73: yych = *++p; if (yych <= 'P') { - if (yych == 'L') goto yy76; + if (yych == 'L') goto yy83; if (yych <= 'O') goto yy31; - goto yy77; + goto yy84; } else { if (yych <= 'l') { if (yych <= 'k') goto yy31; - goto yy76; + goto yy83; } else { - if (yych == 'p') goto yy77; + if (yych == 'p') goto yy84; goto yy31; } } -yy67: +yy74: yych = *++p; - if (yych == 'O') goto yy68; + if (yych == 'O') goto yy75; if (yych != 'o') goto yy31; -yy68: +yy75: yych = *++p; - if (yych == 'N') goto yy69; + if (yych == 'N') goto yy76; if (yych != 'n') goto yy31; -yy69: +yy76: yych = *++p; - if (yych == '-') goto yy70; - if (yych == ':') goto yy35; + if (yych == '-') goto yy77; + if (yych == ':') goto yy42; goto yy31; -yy70: +yy77: yych = *++p; - if (yych == 'U') goto yy71; + if (yych == 'U') goto yy78; if (yych != 'u') goto yy31; -yy71: +yy78: yych = *++p; - if (yych == 'S') goto yy72; + if (yych == 'S') goto yy79; if (yych != 's') goto yy31; -yy72: +yy79: yych = *++p; - if (yych == 'E') goto yy73; + if (yych == 'E') goto yy80; if (yych != 'e') goto yy31; -yy73: +yy80: yych = *++p; - if (yych == 'R') goto yy74; + if (yych == 'R') goto yy81; if (yych != 'r') goto yy31; -yy74: +yy81: yych = *++p; - if (yych == 'I') goto yy75; + if (yych == 'I') goto yy82; if (yych != 'i') goto yy31; -yy75: +yy82: yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; + if (yych == 'D') goto yy41; + if (yych == 'd') goto yy41; goto yy31; -yy76: +yy83: yych = *++p; - if (yych == 'R') goto yy78; - if (yych == 'r') goto yy78; + if (yych == 'R') goto yy85; + if (yych == 'r') goto yy85; goto yy31; -yy77: +yy84: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy78: +yy85: yych = *++p; - if (yych == 'P') goto yy79; + if (yych == 'P') goto yy86; if (yych != 'p') goto yy31; -yy79: +yy86: yych = *++p; - if (yych == 'C') goto yy80; + if (yych == 'C') goto yy87; if (yych != 'c') goto yy31; -yy80: +yy87: yych = *++p; if (yych != '.') goto yy31; yych = *++p; - if (yych == 'B') goto yy82; + if (yych == 'B') goto yy89; if (yych != 'b') goto yy31; -yy82: +yy89: yych = *++p; - if (yych == 'E') goto yy83; + if (yych == 'E') goto yy90; if (yych != 'e') goto yy31; -yy83: +yy90: yych = *++p; - if (yych == 'E') goto yy84; + if (yych == 'E') goto yy91; if (yych != 'e') goto yy31; -yy84: +yy91: yych = *++p; - if (yych == 'P') goto yy85; + if (yych == 'P') goto yy92; if (yych != 'p') goto yy31; -yy85: +yy92: yych = *++p; if (yych <= 'R') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych <= 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; } -yy86: +yy93: yych = *++p; - if (yych == 'R') goto yy87; + if (yych == 'R') goto yy94; if (yych != 'r') goto yy31; -yy87: +yy94: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy88: +yy95: yych = *++p; - if (yych == 'C') goto yy96; - if (yych == 'c') goto yy96; + if (yych == 'C') goto yy103; + if (yych == 'c') goto yy103; goto yy31; -yy89: +yy96: yych = *++p; - if (yych == 'A') goto yy95; - if (yych == 'a') goto yy95; + if (yych == 'A') goto yy102; + if (yych == 'a') goto yy102; goto yy31; -yy90: +yy97: yych = *++p; - if (yych == 'B') goto yy92; - if (yych == 'b') goto yy92; + if (yych == 'B') goto yy99; + if (yych == 'b') goto yy99; goto yy31; -yy91: +yy98: yych = *++p; if (yych <= 'R') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych <= 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; } -yy92: +yy99: yych = *++p; - if (yych == 'C') goto yy93; + if (yych == 'C') goto yy100; if (yych != 'c') goto yy31; -yy93: +yy100: yych = *++p; - if (yych == 'A') goto yy94; + if (yych == 'A') goto yy101; if (yych != 'a') goto yy31; -yy94: +yy101: yych = *++p; - if (yych == 'L') goto yy34; - if (yych == 'l') goto yy34; + if (yych == 'L') goto yy41; + if (yych == 'l') goto yy41; goto yy31; -yy95: +yy102: yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; + if (yych == 'I') goto yy41; + if (yych == 'i') goto yy41; goto yy31; -yy96: +yy103: yych = *++p; - if (yych == 'I') goto yy97; + if (yych == 'I') goto yy104; if (yych != 'i') goto yy31; -yy97: +yy104: yych = *++p; - if (yych == 'W') goto yy98; + if (yych == 'W') goto yy105; if (yych != 'w') goto yy31; -yy98: +yy105: yych = *++p; - if (yych == 'Y') goto yy99; + if (yych == 'Y') goto yy106; if (yych != 'y') goto yy31; -yy99: +yy106: yych = *++p; - if (yych == 'G') goto yy34; - if (yych == 'g') goto yy34; + if (yych == 'G') goto yy41; + if (yych == 'g') goto yy41; goto yy31; -yy100: +yy107: yych = *++p; - if (yych == 'E') goto yy109; - if (yych == 'e') goto yy109; + if (yych == 'E') goto yy116; + if (yych == 'e') goto yy116; goto yy31; -yy101: +yy108: yych = *++p; if (yych <= 'N') { if (yych <= 'L') goto yy31; - if (yych >= 'N') goto yy103; + if (yych >= 'N') goto yy110; } else { if (yych <= 'l') goto yy31; - if (yych <= 'm') goto yy102; - if (yych <= 'n') goto yy103; + if (yych <= 'm') goto yy109; + if (yych <= 'n') goto yy110; goto yy31; } -yy102: +yy109: yych = *++p; - if (yych == 'M') goto yy108; - if (yych == 'm') goto yy108; + if (yych == 'M') goto yy115; + if (yych == 'm') goto yy115; goto yy31; -yy103: +yy110: yych = *++p; - if (yych == 'T') goto yy104; + if (yych == 'T') goto yy111; if (yych != 't') goto yy31; -yy104: +yy111: yych = *++p; - if (yych == 'R') goto yy105; + if (yych == 'R') goto yy112; if (yych != 'r') goto yy31; -yy105: +yy112: yych = *++p; - if (yych == 'I') goto yy106; + if (yych == 'I') goto yy113; if (yych != 'i') goto yy31; -yy106: +yy113: yych = *++p; - if (yych == 'L') goto yy107; + if (yych == 'L') goto yy114; if (yych != 'l') goto yy31; -yy107: +yy114: yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; + if (yych == 'O') goto yy41; + if (yych == 'o') goto yy41; goto yy31; -yy108: +yy115: yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; + if (yych == 'I') goto yy41; + if (yych == 'i') goto yy41; goto yy31; -yy109: +yy116: yych = *++p; - if (yych == 'W') goto yy110; + if (yych == 'W') goto yy117; if (yych != 'w') goto yy31; -yy110: +yy117: yych = *++p; if (yych != '-') goto yy31; yych = *++p; - if (yych == 'S') goto yy112; + if (yych == 'S') goto yy119; if (yych != 's') goto yy31; -yy112: +yy119: yych = *++p; - if (yych == 'O') goto yy113; + if (yych == 'O') goto yy120; if (yych != 'o') goto yy31; -yy113: +yy120: yych = *++p; - if (yych == 'U') goto yy114; + if (yych == 'U') goto yy121; if (yych != 'u') goto yy31; -yy114: +yy121: yych = *++p; - if (yych == 'R') goto yy115; + if (yych == 'R') goto yy122; if (yych != 'r') goto yy31; -yy115: +yy122: yych = *++p; - if (yych == 'C') goto yy116; + if (yych == 'C') goto yy123; if (yych != 'c') goto yy31; -yy116: +yy123: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy117: +yy124: yych = *++p; - if (yych == '2') goto yy124; + if (yych == '2') goto yy131; goto yy31; -yy118: +yy125: yych = *++p; - if (yych == 'R') goto yy121; - if (yych == 'r') goto yy121; + if (yych == 'R') goto yy128; + if (yych == 'r') goto yy128; goto yy31; -yy119: +yy126: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy120: +yy127: yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; + if (yych == 'N') goto yy41; + if (yych == 'n') goto yy41; goto yy31; -yy121: +yy128: yych = *++p; - if (yych == 'E') goto yy122; + if (yych == 'E') goto yy129; if (yych != 'e') goto yy31; -yy122: +yy129: yych = *++p; - if (yych == 'A') goto yy123; + if (yych == 'A') goto yy130; if (yych != 'a') goto yy31; -yy123: +yy130: yych = *++p; - if (yych == 'L') goto yy34; - if (yych == 'l') goto yy34; + if (yych == 'L') goto yy41; + if (yych == 'l') goto yy41; goto yy31; -yy124: +yy131: yych = *++p; if (yych != '0') goto yy31; yych = *++p; if (yych != '0') goto yy31; yych = *++p; - if (yych == '4') goto yy34; + if (yych == '4') goto yy41; goto yy31; -yy127: +yy134: yych = *++p; - if (yych == 'I') goto yy146; - if (yych == 'i') goto yy146; + if (yych == 'I') goto yy153; + if (yych == 'i') goto yy153; goto yy31; -yy128: +yy135: yych = *++p; if (yych <= 'L') { - if (yych == 'A') goto yy138; + if (yych == 'A') goto yy145; if (yych <= 'K') goto yy31; - goto yy137; + goto yy144; } else { if (yych <= 'a') { if (yych <= '`') goto yy31; - goto yy138; + goto yy145; } else { - if (yych == 'l') goto yy137; + if (yych == 'l') goto yy144; goto yy31; } } -yy129: +yy136: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy130: +yy137: yych = *++p; - if (yych == '3') goto yy134; + if (yych == '3') goto yy141; goto yy31; -yy131: +yy138: yych = *++p; - if (yych == 'T') goto yy133; - if (yych == 't') goto yy133; + if (yych == 'T') goto yy140; + if (yych == 't') goto yy140; goto yy31; -yy132: +yy139: yych = *++p; - if (yych == 'G') goto yy34; - if (yych == 'g') goto yy34; + if (yych == 'G') goto yy41; + if (yych == 'g') goto yy41; goto yy31; -yy133: +yy140: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy134: +yy141: yych = *++p; if (yych != '2') goto yy31; yych = *++p; if (yych != '7') goto yy31; yych = *++p; - if (yych == '0') goto yy34; + if (yych == '0') goto yy41; goto yy31; -yy137: +yy144: yych = *++p; if (yych <= 'M') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'N') goto yy144; - if (yych == 'n') goto yy144; + if (yych <= 'N') goto yy151; + if (yych == 'n') goto yy151; goto yy31; } -yy138: +yy145: yych = *++p; - if (yych == 'M') goto yy139; + if (yych == 'M') goto yy146; if (yych != 'm') goto yy31; -yy139: +yy146: yych = *++p; - if (yych == 'S') goto yy140; + if (yych == 'S') goto yy147; if (yych != 's') goto yy31; -yy140: +yy147: yych = *++p; - if (yych == 'P') goto yy141; + if (yych == 'P') goto yy148; if (yych != 'p') goto yy31; -yy141: +yy148: yych = *++p; - if (yych == 'E') goto yy142; + if (yych == 'E') goto yy149; if (yych != 'e') goto yy31; -yy142: +yy149: yych = *++p; - if (yych == 'A') goto yy143; + if (yych == 'A') goto yy150; if (yych != 'a') goto yy31; -yy143: +yy150: yych = *++p; - if (yych == 'K') goto yy34; - if (yych == 'k') goto yy34; + if (yych == 'K') goto yy41; + if (yych == 'k') goto yy41; goto yy31; -yy144: +yy151: yych = *++p; - if (yych == 'E') goto yy145; + if (yych == 'E') goto yy152; if (yych != 'e') goto yy31; -yy145: +yy152: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy146: +yy153: yych = *++p; if (yych <= 'S') { - if (yych == 'N') goto yy147; + if (yych == 'N') goto yy154; if (yych <= 'R') goto yy31; - goto yy148; + goto yy155; } else { if (yych <= 'n') { if (yych <= 'm') goto yy31; } else { - if (yych == 's') goto yy148; + if (yych == 's') goto yy155; goto yy31; } } -yy147: +yy154: yych = *++p; - if (yych == 'G') goto yy155; - if (yych == 'g') goto yy155; + if (yych == 'G') goto yy162; + if (yych == 'g') goto yy162; goto yy31; -yy148: +yy155: yych = *++p; - if (yych == 'M') goto yy149; + if (yych == 'M') goto yy156; if (yych != 'm') goto yy31; -yy149: +yy156: yych = *++p; - if (yych == 'E') goto yy150; + if (yych == 'E') goto yy157; if (yych != 'e') goto yy31; -yy150: +yy157: yych = *++p; - if (yych == 'S') goto yy151; + if (yych == 'S') goto yy158; if (yych != 's') goto yy31; -yy151: +yy158: yych = *++p; - if (yych == 'S') goto yy152; + if (yych == 'S') goto yy159; if (yych != 's') goto yy31; -yy152: +yy159: yych = *++p; - if (yych == 'A') goto yy153; + if (yych == 'A') goto yy160; if (yych != 'a') goto yy31; -yy153: +yy160: yych = *++p; - if (yych == 'G') goto yy154; + if (yych == 'G') goto yy161; if (yych != 'g') goto yy31; -yy154: +yy161: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy155: +yy162: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy156: +yy163: yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; + if (yych == 'N') goto yy41; + if (yych == 'n') goto yy41; goto yy31; -yy157: +yy164: yych = *++p; - if (yych == 'E') goto yy207; - if (yych == 'e') goto yy207; + if (yych == 'E') goto yy214; + if (yych == 'e') goto yy214; goto yy31; -yy158: +yy165: yych = *++p; - if (yych == 'H') goto yy34; - if (yych == 'h') goto yy34; + if (yych == 'H') goto yy41; + if (yych == 'h') goto yy41; goto yy31; -yy159: +yy166: yych = *++p; - if (yych == 'O') goto yy203; - if (yych == 'o') goto yy203; + if (yych == 'O') goto yy210; + if (yych == 'o') goto yy210; goto yy31; -yy160: +yy167: yych = *++p; if (yych <= 'L') { - if (yych == 'A') goto yy193; + if (yych == 'A') goto yy200; if (yych <= 'K') goto yy31; - goto yy194; + goto yy201; } else { if (yych <= 'a') { if (yych <= '`') goto yy31; - goto yy193; + goto yy200; } else { - if (yych == 'l') goto yy194; + if (yych == 'l') goto yy201; goto yy31; } } -yy161: +yy168: yych = *++p; if (yych <= 'S') { - if (yych == 'B') goto yy34; + if (yych == 'B') goto yy41; if (yych <= 'R') goto yy31; - goto yy34; + goto yy41; } else { if (yych <= 'b') { if (yych <= 'a') goto yy31; - goto yy34; + goto yy41; } else { - if (yych == 's') goto yy34; + if (yych == 's') goto yy41; goto yy31; } } -yy162: +yy169: yych = *++p; - if (yych == 'Y') goto yy191; - if (yych == 'y') goto yy191; + if (yych == 'Y') goto yy198; + if (yych == 'y') goto yy198; goto yy31; -yy163: +yy170: yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; + if (yych == 'N') goto yy41; + if (yych == 'n') goto yy41; goto yy31; -yy164: +yy171: yych = *++p; - if (yych == 'T') goto yy190; - if (yych == 't') goto yy190; + if (yych == 'T') goto yy197; + if (yych == 't') goto yy197; goto yy31; -yy165: +yy172: yych = *++p; if (yych <= 'S') { if (yych <= 'C') { if (yych <= 'B') goto yy31; - goto yy177; + goto yy184; } else { if (yych <= 'Q') goto yy31; - if (yych <= 'R') goto yy175; - goto yy176; + if (yych <= 'R') goto yy182; + goto yy183; } } else { if (yych <= 'q') { - if (yych == 'c') goto yy177; + if (yych == 'c') goto yy184; goto yy31; } else { - if (yych <= 'r') goto yy175; - if (yych <= 's') goto yy176; + if (yych <= 'r') goto yy182; + if (yych <= 's') goto yy183; goto yy31; } } -yy166: +yy173: yych = *++p; - if (yych == 'M') goto yy174; - if (yych == 'm') goto yy174; + if (yych == 'M') goto yy181; + if (yych == 'm') goto yy181; goto yy31; -yy167: +yy174: yych = *++p; if (yych <= 'P') { - if (yych == 'E') goto yy171; + if (yych == 'E') goto yy178; if (yych <= 'O') goto yy31; - goto yy172; + goto yy179; } else { if (yych <= 'e') { if (yych <= 'd') goto yy31; - goto yy171; + goto yy178; } else { - if (yych == 'p') goto yy172; + if (yych == 'p') goto yy179; goto yy31; } } -yy168: +yy175: yych = *++p; - if (yych == 'T') goto yy169; + if (yych == 'T') goto yy176; if (yych != 't') goto yy31; -yy169: +yy176: yych = *++p; - if (yych == 'T') goto yy170; + if (yych == 'T') goto yy177; if (yych != 't') goto yy31; -yy170: +yy177: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy171: +yy178: yych = *++p; - if (yych == 'V') goto yy173; - if (yych == 'v') goto yy173; + if (yych == 'V') goto yy180; + if (yych == 'v') goto yy180; goto yy31; -yy172: +yy179: yych = *++p; if (yych <= 'R') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych <= 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; } -yy173: +yy180: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy174: +yy181: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy175: +yy182: yych = *++p; - if (yych == 'V') goto yy187; - if (yych == 'v') goto yy187; + if (yych == 'V') goto yy194; + if (yych == 'v') goto yy194; goto yy31; -yy176: +yy183: yych = *++p; - if (yych == 'S') goto yy184; - if (yych == 's') goto yy184; + if (yych == 'S') goto yy191; + if (yych == 's') goto yy191; goto yy31; -yy177: +yy184: yych = *++p; - if (yych == 'O') goto yy178; + if (yych == 'O') goto yy185; if (yych != 'o') goto yy31; -yy178: +yy185: yych = *++p; - if (yych == 'N') goto yy179; + if (yych == 'N') goto yy186; if (yych != 'n') goto yy31; -yy179: +yy186: yych = *++p; - if (yych == 'D') goto yy180; + if (yych == 'D') goto yy187; if (yych != 'd') goto yy31; -yy180: +yy187: yych = *++p; - if (yych == 'L') goto yy181; + if (yych == 'L') goto yy188; if (yych != 'l') goto yy31; -yy181: +yy188: yych = *++p; - if (yych == 'I') goto yy182; + if (yych == 'I') goto yy189; if (yych != 'i') goto yy31; -yy182: +yy189: yych = *++p; - if (yych == 'F') goto yy183; + if (yych == 'F') goto yy190; if (yych != 'f') goto yy31; -yy183: +yy190: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy184: +yy191: yych = *++p; - if (yych == 'I') goto yy185; + if (yych == 'I') goto yy192; if (yych != 'i') goto yy31; -yy185: +yy192: yych = *++p; - if (yych == 'O') goto yy186; + if (yych == 'O') goto yy193; if (yych != 'o') goto yy31; -yy186: +yy193: yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; + if (yych == 'N') goto yy41; + if (yych == 'n') goto yy41; goto yy31; -yy187: +yy194: yych = *++p; - if (yych == 'I') goto yy188; + if (yych == 'I') goto yy195; if (yych != 'i') goto yy31; -yy188: +yy195: yych = *++p; - if (yych == 'C') goto yy189; + if (yych == 'C') goto yy196; if (yych != 'c') goto yy31; -yy189: +yy196: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy190: +yy197: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy191: +yy198: yych = *++p; - if (yych == 'P') goto yy192; + if (yych == 'P') goto yy199; if (yych != 'p') goto yy31; -yy192: +yy199: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy193: +yy200: yych = *++p; - if (yych == 'P') goto yy197; - if (yych == 'p') goto yy197; + if (yych == 'P') goto yy204; + if (yych == 'p') goto yy204; goto yy31; -yy194: +yy201: yych = *++p; - if (yych == 'D') goto yy195; + if (yych == 'D') goto yy202; if (yych != 'd') goto yy31; -yy195: +yy202: yych = *++p; - if (yych == 'A') goto yy196; + if (yych == 'A') goto yy203; if (yych != 'a') goto yy31; -yy196: +yy203: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy197: +yy204: yych = *++p; if (yych != '.') goto yy31; yych = *++p; - if (yych == 'B') goto yy199; + if (yych == 'B') goto yy206; if (yych != 'b') goto yy31; -yy199: +yy206: yych = *++p; - if (yych == 'E') goto yy200; + if (yych == 'E') goto yy207; if (yych != 'e') goto yy31; -yy200: +yy207: yych = *++p; - if (yych == 'E') goto yy201; + if (yych == 'E') goto yy208; if (yych != 'e') goto yy31; -yy201: +yy208: yych = *++p; - if (yych == 'P') goto yy202; + if (yych == 'P') goto yy209; if (yych != 'p') goto yy31; -yy202: +yy209: yych = *++p; if (yych <= 'R') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych <= 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; } -yy203: +yy210: yych = *++p; - if (yych == 'T') goto yy204; + if (yych == 'T') goto yy211; if (yych != 't') goto yy31; -yy204: +yy211: yych = *++p; - if (yych == 'I') goto yy205; + if (yych == 'I') goto yy212; if (yych != 'i') goto yy31; -yy205: +yy212: yych = *++p; - if (yych == 'F') goto yy206; + if (yych == 'F') goto yy213; if (yych != 'f') goto yy31; -yy206: +yy213: yych = *++p; - if (yych == 'Y') goto yy34; - if (yych == 'y') goto yy34; + if (yych == 'Y') goto yy41; + if (yych == 'y') goto yy41; goto yy31; -yy207: +yy214: yych = *++p; - if (yych == 'A') goto yy208; + if (yych == 'A') goto yy215; if (yych != 'a') goto yy31; -yy208: +yy215: yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; + if (yych == 'M') goto yy41; + if (yych == 'm') goto yy41; goto yy31; -yy209: +yy216: yych = *++p; if (yych <= 'S') { - if (yych == 'M') goto yy221; + if (yych == 'M') goto yy228; if (yych <= 'R') goto yy31; - goto yy220; + goto yy227; } else { if (yych <= 'm') { if (yych <= 'l') goto yy31; - goto yy221; + goto yy228; } else { - if (yych == 's') goto yy220; + if (yych == 's') goto yy227; goto yy31; } } -yy210: +yy217: yych = *++p; - if (yych == 'Y') goto yy218; - if (yych == 'y') goto yy218; + if (yych == 'Y') goto yy225; + if (yych == 'y') goto yy225; goto yy31; -yy211: +yy218: yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; + if (yych == 'I') goto yy41; + if (yych == 'i') goto yy41; goto yy31; -yy212: +yy219: yych = *++p; - if (yych == 'S') goto yy213; + if (yych == 'S') goto yy220; if (yych != 's') goto yy31; -yy213: +yy220: yych = *++p; if (yych <= 'N') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'O') goto yy214; + if (yych <= 'O') goto yy221; if (yych != 'o') goto yy31; } -yy214: +yy221: yych = *++p; - if (yych == 'U') goto yy215; + if (yych == 'U') goto yy222; if (yych != 'u') goto yy31; -yy215: +yy222: yych = *++p; - if (yych == 'R') goto yy216; + if (yych == 'R') goto yy223; if (yych != 'r') goto yy31; -yy216: +yy223: yych = *++p; - if (yych == 'C') goto yy217; + if (yych == 'C') goto yy224; if (yych != 'c') goto yy31; -yy217: +yy224: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy218: +yy225: yych = *++p; - if (yych == 'N') goto yy219; + if (yych == 'N') goto yy226; if (yych != 'n') goto yy31; -yy219: +yy226: yych = *++p; - if (yych == 'C') goto yy34; - if (yych == 'c') goto yy34; + if (yych == 'C') goto yy41; + if (yych == 'c') goto yy41; goto yy31; -yy220: +yy227: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy221: +yy228: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy222: +yy229: yych = *++p; - if (yych == 'Y') goto yy242; - if (yych == 'y') goto yy242; + if (yych == 'Y') goto yy249; + if (yych == 'y') goto yy249; goto yy31; -yy223: +yy230: yych = *++p; if (yych <= 'O') { - if (yych == 'E') goto yy239; + if (yych == 'E') goto yy246; if (yych <= 'N') goto yy31; - goto yy240; + goto yy247; } else { if (yych <= 'e') { if (yych <= 'd') goto yy31; - goto yy239; + goto yy246; } else { - if (yych == 'o') goto yy240; + if (yych == 'o') goto yy247; goto yy31; } } -yy224: +yy231: yych = *++p; - if (yych == 'A') goto yy234; - if (yych == 'a') goto yy234; + if (yych == 'A') goto yy241; + if (yych == 'a') goto yy241; goto yy31; -yy225: +yy232: yych = *++p; if (yych <= 'P') { - if (yych == 'L') goto yy227; + if (yych == 'L') goto yy234; if (yych <= 'O') goto yy31; - goto yy228; + goto yy235; } else { if (yych <= 'l') { if (yych <= 'k') goto yy31; - goto yy227; + goto yy234; } else { - if (yych == 'p') goto yy228; + if (yych == 'p') goto yy235; goto yy31; } } -yy226: +yy233: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy227: +yy234: yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; + if (yych == 'M') goto yy41; + if (yych == 'm') goto yy41; goto yy31; -yy228: +yy235: yych = *++p; - if (yych == 'A') goto yy229; + if (yych == 'A') goto yy236; if (yych != 'a') goto yy31; -yy229: +yy236: yych = *++p; - if (yych == 'R') goto yy230; + if (yych == 'R') goto yy237; if (yych != 'r') goto yy31; -yy230: +yy237: yych = *++p; - if (yych == 'A') goto yy231; + if (yych == 'A') goto yy238; if (yych != 'a') goto yy31; -yy231: +yy238: yych = *++p; - if (yych == 'Z') goto yy232; + if (yych == 'Z') goto yy239; if (yych != 'z') goto yy31; -yy232: +yy239: yych = *++p; - if (yych == 'Z') goto yy233; + if (yych == 'Z') goto yy240; if (yych != 'z') goto yy31; -yy233: +yy240: yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; + if (yych == 'I') goto yy41; + if (yych == 'i') goto yy41; goto yy31; -yy234: +yy241: yych = *++p; - if (yych == 'T') goto yy235; + if (yych == 'T') goto yy242; if (yych != 't') goto yy31; -yy235: +yy242: yych = *++p; - if (yych == 'F') goto yy236; + if (yych == 'F') goto yy243; if (yych != 'f') goto yy31; -yy236: +yy243: yych = *++p; - if (yych == 'O') goto yy237; + if (yych == 'O') goto yy244; if (yych != 'o') goto yy31; -yy237: +yy244: yych = *++p; - if (yych == 'R') goto yy238; + if (yych == 'R') goto yy245; if (yych != 'r') goto yy31; -yy238: +yy245: yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; + if (yych == 'M') goto yy41; + if (yych == 'm') goto yy41; goto yy31; -yy239: +yy246: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy240: +yy247: yych = *++p; - if (yych == 'X') goto yy241; + if (yych == 'X') goto yy248; if (yych != 'x') goto yy31; -yy241: +yy248: yych = *++p; - if (yych == 'Y') goto yy34; - if (yych == 'y') goto yy34; + if (yych == 'Y') goto yy41; + if (yych == 'y') goto yy41; goto yy31; -yy242: +yy249: yych = *++p; - if (yych == 'C') goto yy34; - if (yych == 'c') goto yy34; + if (yych == 'C') goto yy41; + if (yych == 'c') goto yy41; goto yy31; -yy243: +yy250: yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; + if (yych == 'D') goto yy41; + if (yych == 'd') goto yy41; goto yy31; -yy244: +yy251: yych = *++p; - if (yych == 'A') goto yy245; + if (yych == 'A') goto yy252; if (yych != 'a') goto yy31; -yy245: +yy252: yych = *++p; - if (yych == 'Q') goto yy246; + if (yych == 'Q') goto yy253; if (yych != 'q') goto yy31; -yy246: +yy253: yych = *++p; - if (yych == 'U') goto yy247; + if (yych == 'U') goto yy254; if (yych != 'u') goto yy31; -yy247: +yy254: yych = *++p; - if (yych == 'E') goto yy248; + if (yych == 'E') goto yy255; if (yych != 'e') goto yy31; -yy248: +yy255: yych = *++p; - if (yych == 'L') goto yy249; + if (yych == 'L') goto yy256; if (yych != 'l') goto yy31; -yy249: +yy256: yych = *++p; - if (yych == 'O') goto yy250; + if (yych == 'O') goto yy257; if (yych != 'o') goto yy31; -yy250: +yy257: yych = *++p; - if (yych == 'C') goto yy251; + if (yych == 'C') goto yy258; if (yych != 'c') goto yy31; -yy251: +yy258: yych = *++p; - if (yych == 'K') goto yy252; + if (yych == 'K') goto yy259; if (yych != 'k') goto yy31; -yy252: +yy259: yych = *++p; - if (yych == 'T') goto yy253; + if (yych == 'T') goto yy260; if (yych != 't') goto yy31; -yy253: +yy260: yych = *++p; - if (yych == 'O') goto yy254; + if (yych == 'O') goto yy261; if (yych != 'o') goto yy31; -yy254: +yy261: yych = *++p; - if (yych == 'K') goto yy255; + if (yych == 'K') goto yy262; if (yych != 'k') goto yy31; -yy255: +yy262: yych = *++p; - if (yych == 'E') goto yy256; + if (yych == 'E') goto yy263; if (yych != 'e') goto yy31; -yy256: +yy263: yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; + if (yych == 'N') goto yy41; + if (yych == 'n') goto yy41; goto yy31; -yy257: +yy264: yych = *++p; - if (yych == 'T') goto yy264; - if (yych == 't') goto yy264; + if (yych == 'T') goto yy271; + if (yych == 't') goto yy271; goto yy31; -yy258: +yy265: yych = *++p; - if (yych == 'T') goto yy263; - if (yych == 't') goto yy263; + if (yych == 'T') goto yy270; + if (yych == 't') goto yy270; goto yy31; -yy259: +yy266: yych = *++p; if (yych <= 'G') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'H') goto yy34; - if (yych == 'h') goto yy34; + if (yych <= 'H') goto yy41; + if (yych == 'h') goto yy41; goto yy31; } -yy260: +yy267: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy261: +yy268: yych = *++p; - if (yych == 'W') goto yy262; + if (yych == 'W') goto yy269; if (yych != 'w') goto yy31; -yy262: +yy269: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy263: +yy270: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy264: +yy271: yych = *++p; - if (yych == 'E') goto yy265; + if (yych == 'E') goto yy272; if (yych != 'e') goto yy31; -yy265: +yy272: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy266: +yy273: yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; + if (yych == 'N') goto yy41; + if (yych == 'n') goto yy41; goto yy31; -yy267: +yy274: yych = *++p; if (yych <= 'P') { - if (yych == 'M') goto yy298; + if (yych == 'M') goto yy305; if (yych <= 'O') goto yy31; - goto yy297; + goto yy304; } else { if (yych <= 'm') { if (yych <= 'l') goto yy31; - goto yy298; + goto yy305; } else { - if (yych == 'p') goto yy297; + if (yych == 'p') goto yy304; goto yy31; } } -yy268: +yy275: yych = *++p; if (yych <= 'Q') { if (yych <= '-') { if (yych <= ',') goto yy31; - goto yy290; + goto yy297; } else { - if (yych == 'N') goto yy291; + if (yych == 'N') goto yy298; goto yy31; } } else { if (yych <= 'n') { - if (yych <= 'R') goto yy289; + if (yych <= 'R') goto yy296; if (yych <= 'm') goto yy31; - goto yy291; + goto yy298; } else { - if (yych == 'r') goto yy289; + if (yych == 'r') goto yy296; goto yy31; } } -yy269: +yy276: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy270: +yy277: yych = *++p; - if (yych == 'S') goto yy285; - if (yych == 's') goto yy285; + if (yych == 'S') goto yy292; + if (yych == 's') goto yy292; goto yy31; -yy271: +yy278: yych = *++p; switch (yych) { case 'G': - case 'g': goto yy276; + case 'g': goto yy283; case 'I': - case 'i': goto yy275; + case 'i': goto yy282; case 'P': - case 'p': goto yy277; + case 'p': goto yy284; case 'R': - case 'r': goto yy278; + case 'r': goto yy285; default: goto yy31; } -yy272: +yy279: yych = *++p; - if (yych == 'Q') goto yy274; - if (yych == 'q') goto yy274; + if (yych == 'Q') goto yy281; + if (yych == 'q') goto yy281; goto yy31; -yy273: +yy280: yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; + if (yych == 'D') goto yy41; + if (yych == 'd') goto yy41; goto yy31; -yy274: +yy281: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy275: +yy282: yych = *++p; - if (yych == 'L') goto yy283; - if (yych == 'l') goto yy283; + if (yych == 'L') goto yy290; + if (yych == 'l') goto yy290; goto yy31; -yy276: +yy283: yych = *++p; - if (yych == 'N') goto yy281; - if (yych == 'n') goto yy281; + if (yych == 'N') goto yy288; + if (yych == 'n') goto yy288; goto yy31; -yy277: +yy284: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy278: +yy285: yych = *++p; - if (yych == 'K') goto yy279; + if (yych == 'K') goto yy286; if (yych != 'k') goto yy31; -yy279: +yy286: yych = *++p; - if (yych == 'E') goto yy280; + if (yych == 'E') goto yy287; if (yych != 'e') goto yy31; -yy280: +yy287: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy281: +yy288: yych = *++p; - if (yych == 'E') goto yy282; + if (yych == 'E') goto yy289; if (yych != 'e') goto yy31; -yy282: +yy289: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy283: +yy290: yych = *++p; - if (yych == 'T') goto yy284; + if (yych == 'T') goto yy291; if (yych != 't') goto yy31; -yy284: +yy291: yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; + if (yych == 'O') goto yy41; + if (yych == 'o') goto yy41; goto yy31; -yy285: +yy292: yych = *++p; - if (yych == 'S') goto yy286; + if (yych == 'S') goto yy293; if (yych != 's') goto yy31; -yy286: +yy293: yych = *++p; - if (yych == 'A') goto yy287; + if (yych == 'A') goto yy294; if (yych != 'a') goto yy31; -yy287: +yy294: yych = *++p; - if (yych == 'G') goto yy288; + if (yych == 'G') goto yy295; if (yych != 'g') goto yy31; -yy288: +yy295: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy289: +yy296: yych = *++p; - if (yych == 'P') goto yy296; - if (yych == 'p') goto yy296; + if (yych == 'P') goto yy303; + if (yych == 'p') goto yy303; goto yy31; -yy290: +yy297: yych = *++p; - if (yych == 'H') goto yy293; - if (yych == 'h') goto yy293; + if (yych == 'H') goto yy300; + if (yych == 'h') goto yy300; goto yy31; -yy291: +yy298: yych = *++p; - if (yych == 'I') goto yy292; + if (yych == 'I') goto yy299; if (yych != 'i') goto yy31; -yy292: +yy299: yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; + if (yych == 'M') goto yy41; + if (yych == 'm') goto yy41; goto yy31; -yy293: +yy300: yych = *++p; - if (yych == 'E') goto yy294; + if (yych == 'E') goto yy301; if (yych != 'e') goto yy31; -yy294: +yy301: yych = *++p; - if (yych == 'L') goto yy295; + if (yych == 'L') goto yy302; if (yych != 'l') goto yy31; -yy295: +yy302: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy296: +yy303: yych = *++p; if (yych <= 'R') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych <= 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; } -yy297: +yy304: yych = *++p; - if (yych == 'D') goto yy301; - if (yych == 'd') goto yy301; + if (yych == 'D') goto yy308; + if (yych == 'd') goto yy308; goto yy31; -yy298: +yy305: yych = *++p; - if (yych == 'B') goto yy299; + if (yych == 'B') goto yy306; if (yych != 'b') goto yy31; -yy299: +yy306: yych = *++p; - if (yych == 'L') goto yy300; + if (yych == 'L') goto yy307; if (yych != 'l') goto yy31; -yy300: +yy307: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy301: +yy308: yych = *++p; - if (yych == 'A') goto yy302; + if (yych == 'A') goto yy309; if (yych != 'a') goto yy31; -yy302: +yy309: yych = *++p; - if (yych == 'T') goto yy303; + if (yych == 'T') goto yy310; if (yych != 't') goto yy31; -yy303: +yy310: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy304: +yy311: yych = *++p; - if (yych == 'A') goto yy309; - if (yych == 'a') goto yy309; + if (yych == 'A') goto yy316; + if (yych == 'a') goto yy316; goto yy31; -yy305: +yy312: yych = *++p; - if (yych == 'S') goto yy306; + if (yych == 'S') goto yy313; if (yych != 's') goto yy31; -yy306: +yy313: yych = *++p; - if (yych == 'T') goto yy307; + if (yych == 'T') goto yy314; if (yych != 't') goto yy31; -yy307: +yy314: yych = *++p; - if (yych == 'F') goto yy308; + if (yych == 'F') goto yy315; if (yych != 'f') goto yy31; -yy308: +yy315: yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; + if (yych == 'M') goto yy41; + if (yych == 'm') goto yy41; goto yy31; -yy309: +yy316: yych = *++p; - if (yych == 'P') goto yy310; + if (yych == 'P') goto yy317; if (yych != 'p') goto yy31; -yy310: +yy317: yych = *++p; if (yych <= 'R') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych <= 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; } -yy311: +yy318: yych = *++p; - if (yych == 'M') goto yy334; - if (yych == 'm') goto yy334; + if (yych == 'M') goto yy341; + if (yych == 'm') goto yy341; goto yy31; -yy312: +yy319: yych = *++p; if (yych <= 'I') { - if (yych == 'C') goto yy323; + if (yych == 'C') goto yy330; if (yych <= 'H') goto yy31; - goto yy322; + goto yy329; } else { if (yych <= 'c') { if (yych <= 'b') goto yy31; - goto yy323; + goto yy330; } else { - if (yych == 'i') goto yy322; + if (yych == 'i') goto yy329; goto yy31; } } -yy313: +yy320: yych = *++p; if (yych <= 'P') { - if (yych == 'N') goto yy34; + if (yych == 'N') goto yy41; if (yych <= 'O') goto yy31; - goto yy34; + goto yy41; } else { if (yych <= 'n') { if (yych <= 'm') goto yy31; - goto yy34; + goto yy41; } else { - if (yych == 'p') goto yy34; + if (yych == 'p') goto yy41; goto yy31; } } -yy314: +yy321: yych = *++p; if (yych <= 'O') { - if (yych == 'A') goto yy320; + if (yych == 'A') goto yy327; if (yych <= 'N') goto yy31; - goto yy321; + goto yy328; } else { if (yych <= 'a') { if (yych <= '`') goto yy31; - goto yy320; + goto yy327; } else { - if (yych == 'o') goto yy321; + if (yych == 'o') goto yy328; goto yy31; } } -yy315: +yy322: yych = *++p; - if (yych == 'F') goto yy319; - if (yych == 'f') goto yy319; + if (yych == 'F') goto yy326; + if (yych == 'f') goto yy326; goto yy31; -yy316: +yy323: yych = *++p; if (yych <= '@') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'A') goto yy318; - if (yych == 'a') goto yy318; + if (yych <= 'A') goto yy325; + if (yych == 'a') goto yy325; goto yy31; } -yy317: +yy324: yych = *++p; - if (yych == 'X') goto yy34; - if (yych == 'x') goto yy34; + if (yych == 'X') goto yy41; + if (yych == 'x') goto yy41; goto yy31; -yy318: +yy325: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy319: +yy326: yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; + if (yych == 'O') goto yy41; + if (yych == 'o') goto yy41; goto yy31; -yy320: +yy327: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy321: +yy328: yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; + if (yych == 'N') goto yy41; + if (yych == 'n') goto yy41; goto yy31; -yy322: +yy329: yych = *++p; - if (yych == 'S') goto yy324; - if (yych == 's') goto yy324; + if (yych == 'S') goto yy331; + if (yych == 's') goto yy331; goto yy31; -yy323: +yy330: yych = *++p; if (yych <= ':') { - if (yych == '6') goto yy34; + if (yych == '6') goto yy41; if (yych <= '9') goto yy31; - goto yy35; + goto yy42; } else { if (yych <= 'S') { if (yych <= 'R') goto yy31; - goto yy34; + goto yy41; } else { - if (yych == 's') goto yy34; + if (yych == 's') goto yy41; goto yy31; } } -yy324: +yy331: yych = *++p; - if (yych == '.') goto yy325; - if (yych == ':') goto yy35; + if (yych == '.') goto yy332; + if (yych == ':') goto yy42; goto yy31; -yy325: +yy332: yych = *++p; if (yych <= 'X') { if (yych <= 'K') { - if (yych == 'B') goto yy328; + if (yych == 'B') goto yy335; goto yy31; } else { - if (yych <= 'L') goto yy326; + if (yych <= 'L') goto yy333; if (yych <= 'W') goto yy31; - goto yy327; + goto yy334; } } else { if (yych <= 'k') { - if (yych == 'b') goto yy328; + if (yych == 'b') goto yy335; goto yy31; } else { - if (yych <= 'l') goto yy326; - if (yych == 'x') goto yy327; + if (yych <= 'l') goto yy333; + if (yych == 'x') goto yy334; goto yy31; } } -yy326: +yy333: yych = *++p; - if (yych == 'W') goto yy333; - if (yych == 'w') goto yy333; + if (yych == 'W') goto yy340; + if (yych == 'w') goto yy340; goto yy31; -yy327: +yy334: yych = *++p; - if (yych == 'P') goto yy331; - if (yych == 'p') goto yy331; + if (yych == 'P') goto yy338; + if (yych == 'p') goto yy338; goto yy31; -yy328: +yy335: yych = *++p; - if (yych == 'E') goto yy329; + if (yych == 'E') goto yy336; if (yych != 'e') goto yy31; -yy329: +yy336: yych = *++p; - if (yych == 'E') goto yy330; + if (yych == 'E') goto yy337; if (yych != 'e') goto yy31; -yy330: +yy337: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy331: +yy338: yych = *++p; - if (yych == 'C') goto yy332; + if (yych == 'C') goto yy339; if (yych != 'c') goto yy31; -yy332: +yy339: yych = *++p; if (yych <= 'R') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych <= 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; } -yy333: +yy340: yych = *++p; - if (yych == 'Z') goto yy34; - if (yych == 'z') goto yy34; + if (yych == 'Z') goto yy41; + if (yych == 'z') goto yy41; goto yy31; -yy334: +yy341: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy335: +yy342: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy336: +yy343: yych = *++p; - if (yych == 'T') goto yy339; - if (yych == 't') goto yy339; + if (yych == 'T') goto yy346; + if (yych == 't') goto yy346; goto yy31; -yy337: +yy344: yych = *++p; if (yych != '2') goto yy31; yych = *++p; - if (yych == '3') goto yy34; + if (yych == '3') goto yy41; goto yy31; -yy339: +yy346: yych = *++p; - if (yych == 'P') goto yy340; + if (yych == 'P') goto yy347; if (yych != 'p') goto yy31; -yy340: +yy347: yych = *++p; if (yych <= 'R') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych <= 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; } -yy341: +yy348: yych = *++p; - if (yych == 'A') goto yy357; - if (yych == 'a') goto yy357; + if (yych == 'A') goto yy364; + if (yych == 'a') goto yy364; goto yy31; -yy342: +yy349: yych = *++p; if (yych <= 'Z') { - if (yych == 'T') goto yy34; + if (yych == 'T') goto yy41; if (yych <= 'Y') goto yy31; - goto yy348; + goto yy355; } else { if (yych <= 't') { if (yych <= 's') goto yy31; - goto yy34; + goto yy41; } else { - if (yych == 'z') goto yy348; + if (yych == 'z') goto yy355; goto yy31; } } -yy343: +yy350: yych = *++p; if (yych <= 'O') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'P') goto yy345; - if (yych == 'p') goto yy345; + if (yych <= 'P') goto yy352; + if (yych == 'p') goto yy352; goto yy31; } -yy344: +yy351: yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; + if (yych == 'O') goto yy41; + if (yych == 'o') goto yy41; goto yy31; -yy345: +yy352: yych = *++p; - if (yych == 'H') goto yy346; + if (yych == 'H') goto yy353; if (yych != 'h') goto yy31; -yy346: +yy353: yych = *++p; - if (yych == 'E') goto yy347; + if (yych == 'E') goto yy354; if (yych != 'e') goto yy31; -yy347: +yy354: yych = *++p; - if (yych == 'R') goto yy34; - if (yych == 'r') goto yy34; + if (yych == 'R') goto yy41; + if (yych == 'r') goto yy41; goto yy31; -yy348: +yy355: yych = *++p; - if (yych == 'M') goto yy349; + if (yych == 'M') goto yy356; if (yych != 'm') goto yy31; -yy349: +yy356: yych = *++p; - if (yych == 'O') goto yy350; + if (yych == 'O') goto yy357; if (yych != 'o') goto yy31; -yy350: +yy357: yych = *++p; - if (yych == 'P') goto yy351; + if (yych == 'P') goto yy358; if (yych != 'p') goto yy31; -yy351: +yy358: yych = *++p; - if (yych == 'R') goto yy352; + if (yych == 'R') goto yy359; if (yych != 'r') goto yy31; -yy352: +yy359: yych = *++p; - if (yych == 'O') goto yy353; + if (yych == 'O') goto yy360; if (yych != 'o') goto yy31; -yy353: +yy360: yych = *++p; - if (yych == 'J') goto yy354; + if (yych == 'J') goto yy361; if (yych != 'j') goto yy31; -yy354: +yy361: yych = *++p; - if (yych == 'E') goto yy355; + if (yych == 'E') goto yy362; if (yych != 'e') goto yy31; -yy355: +yy362: yych = *++p; - if (yych == 'C') goto yy356; + if (yych == 'C') goto yy363; if (yych != 'c') goto yy31; -yy356: +yy363: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy357: +yy364: yych = *++p; - if (yych == 'L') goto yy358; + if (yych == 'L') goto yy365; if (yych != 'l') goto yy31; -yy358: +yy365: yych = *++p; - if (yych == 'K') goto yy34; - if (yych == 'k') goto yy34; + if (yych == 'K') goto yy41; + if (yych == 'k') goto yy41; goto yy31; -yy359: +yy366: yych = *++p; if (yych <= 'S') { if (yych <= 'M') { - if (yych == 'L') goto yy369; + if (yych == 'L') goto yy376; goto yy31; } else { - if (yych <= 'N') goto yy370; + if (yych <= 'N') goto yy377; if (yych <= 'R') goto yy31; - goto yy371; + goto yy378; } } else { if (yych <= 'm') { - if (yych == 'l') goto yy369; + if (yych == 'l') goto yy376; goto yy31; } else { - if (yych <= 'n') goto yy370; - if (yych == 's') goto yy371; + if (yych <= 'n') goto yy377; + if (yych == 's') goto yy378; goto yy31; } } -yy360: +yy367: yych = *++p; - if (yych == 'E') goto yy368; - if (yych == 'e') goto yy368; + if (yych == 'E') goto yy375; + if (yych == 'e') goto yy375; goto yy31; -yy361: +yy368: yych = *++p; - if (yych == 'C') goto yy363; - if (yych == 'c') goto yy363; + if (yych == 'C') goto yy370; + if (yych == 'c') goto yy370; goto yy31; -yy362: +yy369: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy363: +yy370: yych = *++p; - if (yych == 'E') goto yy364; + if (yych == 'E') goto yy371; if (yych != 'e') goto yy31; -yy364: +yy371: yych = *++p; - if (yych == 'T') goto yy365; + if (yych == 'T') goto yy372; if (yych != 't') goto yy31; -yy365: +yy372: yych = *++p; - if (yych == 'I') goto yy366; + if (yych == 'I') goto yy373; if (yych != 'i') goto yy31; -yy366: +yy373: yych = *++p; - if (yych == 'M') goto yy367; + if (yych == 'M') goto yy374; if (yych != 'm') goto yy31; -yy367: +yy374: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy368: +yy375: yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; + if (yych == 'D') goto yy41; + if (yych == 'd') goto yy41; goto yy31; -yy369: +yy376: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy370: +yy377: yych = *++p; - if (yych == 'G') goto yy372; - if (yych == 'g') goto yy372; + if (yych == 'G') goto yy379; + if (yych == 'g') goto yy379; goto yy31; -yy371: +yy378: yych = *++p; - if (yych == 'H') goto yy34; - if (yych == 'h') goto yy34; + if (yych == 'H') goto yy41; + if (yych == 'h') goto yy41; goto yy31; -yy372: +yy379: yych = *++p; - if (yych == 'E') goto yy373; + if (yych == 'E') goto yy380; if (yych != 'e') goto yy31; -yy373: +yy380: yych = *++p; - if (yych == 'R') goto yy34; - if (yych == 'r') goto yy34; + if (yych == 'R') goto yy41; + if (yych == 'r') goto yy41; goto yy31; -yy374: +yy381: yych = *++p; - if (yych == 'T') goto yy392; - if (yych == 't') goto yy392; + if (yych == 'T') goto yy399; + if (yych == 't') goto yy399; goto yy31; -yy375: +yy382: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy376: +yy383: yych = *++p; - if (yych == 'M') goto yy34; - if (yych == 'm') goto yy34; + if (yych == 'M') goto yy41; + if (yych == 'm') goto yy41; goto yy31; -yy377: +yy384: yych = *++p; if (yych <= 'S') { - if (yych == 'P') goto yy34; + if (yych == 'P') goto yy41; if (yych <= 'R') goto yy31; - goto yy34; + goto yy41; } else { if (yych <= 'p') { if (yych <= 'o') goto yy31; - goto yy34; + goto yy41; } else { - if (yych == 's') goto yy34; + if (yych == 's') goto yy41; goto yy31; } } -yy378: +yy385: yych = *++p; - if (yych == 'I') goto yy386; - if (yych == 'i') goto yy386; + if (yych == 'I') goto yy393; + if (yych == 'i') goto yy393; goto yy31; -yy379: +yy386: yych = *++p; - if (yych == 'A') goto yy385; - if (yych == 'a') goto yy385; + if (yych == 'A') goto yy392; + if (yych == 'a') goto yy392; goto yy31; -yy380: +yy387: yych = *++p; - if (yych == 'O') goto yy383; - if (yych == 'o') goto yy383; + if (yych == 'O') goto yy390; + if (yych == 'o') goto yy390; goto yy31; -yy381: +yy388: yych = *++p; - if (yych == 'A') goto yy382; + if (yych == 'A') goto yy389; if (yych != 'a') goto yy31; -yy382: +yy389: yych = *++p; if (yych <= 'R') { - if (yych == ':') goto yy35; + if (yych == ':') goto yy42; goto yy31; } else { - if (yych <= 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych <= 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; } -yy383: +yy390: yych = *++p; - if (yych == 'U') goto yy384; + if (yych == 'U') goto yy391; if (yych != 'u') goto yy31; -yy384: +yy391: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy385: +yy392: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy386: +yy393: yych = *++p; - if (yych == 'U') goto yy387; + if (yych == 'U') goto yy394; if (yych != 'u') goto yy31; -yy387: +yy394: yych = *++p; - if (yych == 'M') goto yy388; + if (yych == 'M') goto yy395; if (yych != 'm') goto yy31; -yy388: +yy395: yych = *++p; - if (yych == 'X') goto yy389; + if (yych == 'X') goto yy396; if (yych != 'x') goto yy31; -yy389: +yy396: yych = *++p; - if (yych == 'T') goto yy390; + if (yych == 'T') goto yy397; if (yych != 't') goto yy31; -yy390: +yy397: yych = *++p; - if (yych == 'R') goto yy391; + if (yych == 'R') goto yy398; if (yych != 'r') goto yy31; -yy391: +yy398: yych = *++p; - if (yych == 'A') goto yy34; - if (yych == 'a') goto yy34; + if (yych == 'A') goto yy41; + if (yych == 'a') goto yy41; goto yy31; -yy392: +yy399: yych = *++p; - if (yych == 'A') goto yy393; + if (yych == 'A') goto yy400; if (yych != 'a') goto yy31; -yy393: +yy400: yych = *++p; - if (yych == 'C') goto yy394; + if (yych == 'C') goto yy401; if (yych != 'c') goto yy31; -yy394: +yy401: yych = *++p; - if (yych == 'H') goto yy395; + if (yych == 'H') goto yy402; if (yych != 'h') goto yy31; -yy395: +yy402: yych = *++p; - if (yych == 'M') goto yy396; + if (yych == 'M') goto yy403; if (yych != 'm') goto yy31; -yy396: +yy403: yych = *++p; - if (yych == 'E') goto yy397; + if (yych == 'E') goto yy404; if (yych != 'e') goto yy31; -yy397: +yy404: yych = *++p; - if (yych == 'N') goto yy398; + if (yych == 'N') goto yy405; if (yych != 'n') goto yy31; -yy398: +yy405: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy399: +yy406: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy400: +yy407: yych = *++p; if (yych <= 'V') { - if (yych == 'R') goto yy34; + if (yych == 'R') goto yy41; if (yych <= 'U') goto yy31; } else { if (yych <= 'r') { if (yych <= 'q') goto yy31; - goto yy34; + goto yy41; } else { if (yych != 'v') goto yy31; } } yych = *++p; - if (yych == 'A') goto yy402; + if (yych == 'A') goto yy409; if (yych != 'a') goto yy31; -yy402: +yy409: yych = *++p; - if (yych == 'S') goto yy403; + if (yych == 'S') goto yy410; if (yych != 's') goto yy31; -yy403: +yy410: yych = *++p; - if (yych == 'C') goto yy404; + if (yych == 'C') goto yy411; if (yych != 'c') goto yy31; -yy404: +yy411: yych = *++p; - if (yych == 'R') goto yy405; + if (yych == 'R') goto yy412; if (yych != 'r') goto yy31; -yy405: +yy412: yych = *++p; - if (yych == 'I') goto yy406; + if (yych == 'I') goto yy413; if (yych != 'i') goto yy31; -yy406: +yy413: yych = *++p; - if (yych == 'P') goto yy407; + if (yych == 'P') goto yy414; if (yych != 'p') goto yy31; -yy407: +yy414: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy408: +yy415: yych = *++p; - if (yych == 'B') goto yy34; - if (yych == 'b') goto yy34; + if (yych == 'B') goto yy41; + if (yych == 'b') goto yy41; goto yy31; -yy409: +yy416: yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; + if (yych == 'N') goto yy41; + if (yych == 'n') goto yy41; goto yy31; -yy410: +yy417: yych = *++p; - if (yych == 'N') goto yy417; - if (yych == 'n') goto yy417; + if (yych == 'N') goto yy424; + if (yych == 'n') goto yy424; goto yy31; -yy411: +yy418: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy412: +yy419: yych = *++p; - if (yych == 'C') goto yy416; - if (yych == 'c') goto yy416; + if (yych == 'C') goto yy423; + if (yych == 'c') goto yy423; goto yy31; -yy413: +yy420: yych = *++p; if (yych <= 'V') { - if (yych == 'T') goto yy415; + if (yych == 'T') goto yy422; if (yych <= 'U') goto yy31; - goto yy34; + goto yy41; } else { if (yych <= 't') { if (yych <= 's') goto yy31; - goto yy415; + goto yy422; } else { - if (yych == 'v') goto yy34; + if (yych == 'v') goto yy41; goto yy31; } } -yy414: +yy421: yych = *++p; - if (yych == 'I') goto yy34; - if (yych == 'i') goto yy34; + if (yych == 'I') goto yy41; + if (yych == 'i') goto yy41; goto yy31; -yy415: +yy422: yych = *++p; - if (yych == 'A') goto yy34; - if (yych == 'a') goto yy34; + if (yych == 'A') goto yy41; + if (yych == 'a') goto yy41; goto yy31; -yy416: +yy423: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy417: +yy424: yych = *++p; - if (yych == 'A') goto yy418; + if (yych == 'A') goto yy425; if (yych != 'a') goto yy31; -yy418: +yy425: yych = *++p; if (yych != '-') goto yy31; yych = *++p; - if (yych == 'P') goto yy420; + if (yych == 'P') goto yy427; if (yych != 'p') goto yy31; -yy420: +yy427: yych = *++p; - if (yych == 'L') goto yy421; + if (yych == 'L') goto yy428; if (yych != 'l') goto yy31; -yy421: +yy428: yych = *++p; - if (yych == 'A') goto yy422; + if (yych == 'A') goto yy429; if (yych != 'a') goto yy31; -yy422: +yy429: yych = *++p; - if (yych == 'Y') goto yy423; + if (yych == 'Y') goto yy430; if (yych != 'y') goto yy31; -yy423: +yy430: yych = *++p; if (yych <= 'S') { - if (yych == 'C') goto yy424; + if (yych == 'C') goto yy431; if (yych <= 'R') goto yy31; - goto yy425; + goto yy432; } else { if (yych <= 'c') { if (yych <= 'b') goto yy31; } else { - if (yych == 's') goto yy425; + if (yych == 's') goto yy432; goto yy31; } } -yy424: +yy431: yych = *++p; - if (yych == 'O') goto yy430; - if (yych == 'o') goto yy430; + if (yych == 'O') goto yy437; + if (yych == 'o') goto yy437; goto yy31; -yy425: +yy432: yych = *++p; - if (yych == 'I') goto yy426; + if (yych == 'I') goto yy433; if (yych != 'i') goto yy31; -yy426: +yy433: yych = *++p; - if (yych == 'N') goto yy427; + if (yych == 'N') goto yy434; if (yych != 'n') goto yy31; -yy427: +yy434: yych = *++p; - if (yych == 'G') goto yy428; + if (yych == 'G') goto yy435; if (yych != 'g') goto yy31; -yy428: +yy435: yych = *++p; - if (yych == 'L') goto yy429; + if (yych == 'L') goto yy436; if (yych != 'l') goto yy31; -yy429: +yy436: yych = *++p; - if (yych == 'E') goto yy34; - if (yych == 'e') goto yy34; + if (yych == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; -yy430: +yy437: yych = *++p; - if (yych == 'N') goto yy431; + if (yych == 'N') goto yy438; if (yych != 'n') goto yy31; -yy431: +yy438: yych = *++p; - if (yych == 'T') goto yy432; + if (yych == 'T') goto yy439; if (yych != 't') goto yy31; -yy432: +yy439: yych = *++p; - if (yych == 'A') goto yy433; + if (yych == 'A') goto yy440; if (yych != 'a') goto yy31; -yy433: +yy440: yych = *++p; - if (yych == 'I') goto yy434; + if (yych == 'I') goto yy441; if (yych != 'i') goto yy31; -yy434: +yy441: yych = *++p; - if (yych == 'N') goto yy435; + if (yych == 'N') goto yy442; if (yych != 'n') goto yy31; -yy435: +yy442: yych = *++p; - if (yych == 'E') goto yy436; + if (yych == 'E') goto yy443; if (yych != 'e') goto yy31; -yy436: +yy443: yych = *++p; - if (yych == 'R') goto yy34; - if (yych == 'r') goto yy34; + if (yych == 'R') goto yy41; + if (yych == 'r') goto yy41; goto yy31; -yy437: +yy444: yych = *++p; - if (yych == 'S') goto yy34; - if (yych == 's') goto yy34; + if (yych == 'S') goto yy41; + if (yych == 's') goto yy41; goto yy31; -yy438: +yy445: yych = *++p; if (yych <= 'N') { if (yych <= 'A') { if (yych <= '@') goto yy31; - goto yy460; + goto yy467; } else { if (yych <= 'L') goto yy31; - if (yych <= 'M') goto yy461; - goto yy462; + if (yych <= 'M') goto yy468; + goto yy469; } } else { if (yych <= 'l') { - if (yych == 'a') goto yy460; + if (yych == 'a') goto yy467; goto yy31; } else { - if (yych <= 'm') goto yy461; - if (yych <= 'n') goto yy462; + if (yych <= 'm') goto yy468; + if (yych <= 'n') goto yy469; goto yy31; } } -yy439: +yy446: yych = *++p; - if (yych == 'R') goto yy447; - if (yych == 'r') goto yy447; + if (yych == 'R') goto yy454; + if (yych == 'r') goto yy454; goto yy31; -yy440: +yy447: yych = *++p; if (yych <= 'P') { - if (yych == 'L') goto yy444; + if (yych == 'L') goto yy451; if (yych <= 'O') goto yy31; - goto yy34; + goto yy41; } else { if (yych <= 'l') { if (yych <= 'k') goto yy31; - goto yy444; + goto yy451; } else { - if (yych == 'p') goto yy34; + if (yych == 'p') goto yy41; goto yy31; } } -yy441: +yy448: yych = *++p; - if (yych == 'I') goto yy443; - if (yych == 'i') goto yy443; + if (yych == 'I') goto yy450; + if (yych == 'i') goto yy450; goto yy31; -yy442: +yy449: yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; + if (yych == 'D') goto yy41; + if (yych == 'd') goto yy41; goto yy31; -yy443: +yy450: yych = *++p; - if (yych == 'D') goto yy34; - if (yych == 'd') goto yy34; + if (yych == 'D') goto yy41; + if (yych == 'd') goto yy41; goto yy31; -yy444: +yy451: yych = *++p; - if (yych == 'L') goto yy445; + if (yych == 'L') goto yy452; if (yych != 'l') goto yy31; -yy445: +yy452: yych = *++p; - if (yych == 'T') goto yy446; + if (yych == 'T') goto yy453; if (yych != 't') goto yy31; -yy446: +yy453: yych = *++p; - if (yych == 'O') goto yy34; - if (yych == 'o') goto yy34; + if (yych == 'O') goto yy41; + if (yych == 'o') goto yy41; goto yy31; -yy447: +yy454: yych = *++p; - if (yych == 'O') goto yy448; + if (yych == 'O') goto yy455; if (yych != 'o') goto yy31; -yy448: +yy455: yych = *++p; - if (yych == 'M') goto yy449; + if (yych == 'M') goto yy456; if (yych != 'm') goto yy31; -yy449: +yy456: yych = *++p; - if (yych == 'E') goto yy450; + if (yych == 'E') goto yy457; if (yych != 'e') goto yy31; -yy450: +yy457: yych = *++p; - if (yych == '-') goto yy451; - if (yych == ':') goto yy35; + if (yych == '-') goto yy458; + if (yych == ':') goto yy42; goto yy31; -yy451: +yy458: yych = *++p; - if (yych == 'E') goto yy452; + if (yych == 'E') goto yy459; if (yych != 'e') goto yy31; -yy452: +yy459: yych = *++p; - if (yych == 'X') goto yy453; + if (yych == 'X') goto yy460; if (yych != 'x') goto yy31; -yy453: +yy460: yych = *++p; - if (yych == 'T') goto yy454; + if (yych == 'T') goto yy461; if (yych != 't') goto yy31; -yy454: +yy461: yych = *++p; - if (yych == 'E') goto yy455; + if (yych == 'E') goto yy462; if (yych != 'e') goto yy31; -yy455: +yy462: yych = *++p; - if (yych == 'N') goto yy456; + if (yych == 'N') goto yy463; if (yych != 'n') goto yy31; -yy456: +yy463: yych = *++p; - if (yych == 'S') goto yy457; + if (yych == 'S') goto yy464; if (yych != 's') goto yy31; -yy457: +yy464: yych = *++p; - if (yych == 'I') goto yy458; + if (yych == 'I') goto yy465; if (yych != 'i') goto yy31; -yy458: +yy465: yych = *++p; - if (yych == 'O') goto yy459; + if (yych == 'O') goto yy466; if (yych != 'o') goto yy31; -yy459: +yy466: yych = *++p; - if (yych == 'N') goto yy34; - if (yych == 'n') goto yy34; + if (yych == 'N') goto yy41; + if (yych == 'n') goto yy41; goto yy31; -yy460: +yy467: yych = *++p; - if (yych == 'P') goto yy34; - if (yych == 'p') goto yy34; + if (yych == 'P') goto yy41; + if (yych == 'p') goto yy41; goto yy31; -yy461: +yy468: yych = *++p; - if (yych == '-') goto yy466; + if (yych == '-') goto yy473; goto yy31; -yy462: +yy469: yych = *++p; - if (yych == 'T') goto yy463; + if (yych == 'T') goto yy470; if (yych != 't') goto yy31; -yy463: +yy470: yych = *++p; - if (yych == 'E') goto yy464; + if (yych == 'E') goto yy471; if (yych != 'e') goto yy31; -yy464: +yy471: yych = *++p; - if (yych == 'N') goto yy465; + if (yych == 'N') goto yy472; if (yych != 'n') goto yy31; -yy465: +yy472: yych = *++p; - if (yych == 'T') goto yy34; - if (yych == 't') goto yy34; + if (yych == 'T') goto yy41; + if (yych == 't') goto yy41; goto yy31; -yy466: +yy473: yych = *++p; - if (yych == 'E') goto yy467; + if (yych == 'E') goto yy474; if (yych != 'e') goto yy31; -yy467: +yy474: yych = *++p; - if (yych == 'V') goto yy468; + if (yych == 'V') goto yy475; if (yych != 'v') goto yy31; -yy468: +yy475: yych = *++p; - if (yych == 'E') goto yy469; + if (yych == 'E') goto yy476; if (yych != 'e') goto yy31; -yy469: +yy476: yych = *++p; - if (yych == 'N') goto yy470; + if (yych == 'N') goto yy477; if (yych != 'n') goto yy31; -yy470: +yy477: yych = *++p; - if (yych == 'T') goto yy471; + if (yych == 'T') goto yy478; if (yych != 't') goto yy31; -yy471: +yy478: yych = *++p; - if (yych == 'B') goto yy472; + if (yych == 'B') goto yy479; if (yych != 'b') goto yy31; -yy472: +yy479: yych = *++p; - if (yych == 'R') goto yy473; + if (yych == 'R') goto yy480; if (yych != 'r') goto yy31; -yy473: +yy480: yych = *++p; - if (yych == 'I') goto yy474; + if (yych == 'I') goto yy481; if (yych != 'i') goto yy31; -yy474: +yy481: yych = *++p; - if (yych == 'T') goto yy475; + if (yych == 'T') goto yy482; if (yych != 't') goto yy31; -yy475: +yy482: yych = *++p; - if (yych == 'E') goto yy476; + if (yych == 'E') goto yy483; if (yych != 'e') goto yy31; -yy476: +yy483: yych = *++p; if (yych != '-') goto yy31; yych = *++p; - if (yych == 'A') goto yy478; + if (yych == 'A') goto yy485; if (yych != 'a') goto yy31; -yy478: +yy485: yych = *++p; - if (yych == 'T') goto yy479; + if (yych == 'T') goto yy486; if (yych != 't') goto yy31; -yy479: +yy486: yych = *++p; - if (yych == 'T') goto yy480; + if (yych == 'T') goto yy487; if (yych != 't') goto yy31; -yy480: +yy487: yych = *++p; - if (yych == 'E') goto yy481; + if (yych == 'E') goto yy488; if (yych != 'e') goto yy31; -yy481: +yy488: yych = *++p; - if (yych == 'N') goto yy482; + if (yych == 'N') goto yy489; if (yych != 'n') goto yy31; -yy482: +yy489: yych = *++p; - if (yych == 'D') goto yy483; + if (yych == 'D') goto yy490; if (yych != 'd') goto yy31; -yy483: +yy490: yych = *++p; - if (yych == 'E') goto yy484; + if (yych == 'E') goto yy491; if (yych != 'e') goto yy31; -yy484: +yy491: ++p; - if ((yych = *p) == 'E') goto yy34; - if (yych == 'e') goto yy34; + if ((yych = *p) == 'E') goto yy41; + if (yych == 'e') goto yy41; goto yy31; } @@ -2943,2929 +3039,3088 @@ bufsize_t _scan_autolink_uri(const unsigned char *p) 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 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, }; - yych = *p; - switch (yych) { - case '\n': goto yy487; - case 'A': - case 'a': goto yy491; - case 'B': - case 'b': goto yy509; - case 'C': - case 'c': goto yy488; - case 'D': - case 'd': goto yy489; - case 'E': - case 'e': goto yy510; - case 'F': - case 'f': goto yy492; - case 'G': - case 'g': goto yy493; - case 'H': - case 'h': goto yy494; - case 'I': - case 'i': goto yy495; - case 'J': - case 'j': goto yy490; - case 'K': - case 'k': goto yy511; - case 'L': - case 'l': goto yy496; - case 'M': - case 'm': goto yy497; - case 'N': - case 'n': goto yy498; - case 'O': - case 'o': goto yy499; - case 'P': - case 'p': goto yy500; - case 'Q': - case 'q': goto yy512; - case 'R': - case 'r': goto yy501; - case 'S': - case 's': goto yy502; - case 'T': - case 't': goto yy503; - case 'U': - case 'u': goto yy504; - case 'V': - case 'v': goto yy505; - case 'W': - case 'w': goto yy506; - case 'X': - case 'x': goto yy507; - case 'Y': - case 'y': goto yy513; - case 'Z': - case 'z': goto yy508; - default: goto yy514; + yych = *(marker = p); + if (yych <= 'c') { + if (yych <= 'M') { + if (yych <= 'E') { + if (yych <= 'A') { + if (yych == '\n') goto yy494; + if (yych <= '@') goto yy521; + goto yy498; + } else { + if (yych <= 'B') goto yy516; + if (yych <= 'C') goto yy495; + if (yych <= 'D') goto yy496; + goto yy517; + } + } else { + if (yych <= 'I') { + if (yych <= 'F') goto yy499; + if (yych <= 'G') goto yy500; + if (yych <= 'H') goto yy501; + goto yy502; + } else { + if (yych <= 'J') goto yy497; + if (yych <= 'K') goto yy518; + if (yych <= 'L') goto yy503; + goto yy504; + } + } + } else { + if (yych <= 'U') { + if (yych <= 'Q') { + if (yych <= 'N') goto yy505; + if (yych <= 'O') goto yy506; + if (yych <= 'P') goto yy507; + goto yy519; + } else { + if (yych <= 'R') goto yy508; + if (yych <= 'S') goto yy509; + if (yych <= 'T') goto yy510; + goto yy511; + } + } else { + if (yych <= 'Y') { + if (yych <= 'V') goto yy512; + if (yych <= 'W') goto yy513; + if (yych <= 'X') goto yy514; + goto yy520; + } else { + if (yych <= '`') { + if (yych <= 'Z') goto yy515; + goto yy521; + } else { + if (yych <= 'a') goto yy498; + if (yych <= 'b') goto yy516; + goto yy495; + } + } + } + } + } else { + if (yych <= 't') { + if (yych <= 'k') { + if (yych <= 'g') { + if (yych <= 'd') goto yy496; + if (yych <= 'e') goto yy517; + if (yych <= 'f') goto yy499; + goto yy500; + } else { + if (yych <= 'h') goto yy501; + if (yych <= 'i') goto yy502; + if (yych <= 'j') goto yy497; + goto yy518; + } + } else { + if (yych <= 'o') { + if (yych <= 'l') goto yy503; + if (yych <= 'm') goto yy504; + if (yych <= 'n') goto yy505; + goto yy506; + } else { + if (yych <= 'q') { + if (yych <= 'p') goto yy507; + goto yy519; + } else { + if (yych <= 'r') goto yy508; + if (yych <= 's') goto yy509; + goto yy510; + } + } + } + } else { + if (yych <= 0xC1) { + if (yych <= 'x') { + if (yych <= 'u') goto yy511; + if (yych <= 'v') goto yy512; + if (yych <= 'w') goto yy513; + goto yy514; + } else { + if (yych <= 'y') goto yy520; + if (yych <= 'z') goto yy515; + if (yych <= 0x7F) goto yy521; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy522; + if (yych <= 0xE0) goto yy524; + if (yych <= 0xEC) goto yy525; + goto yy529; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy525; + goto yy526; + } else { + if (yych <= 0xF3) goto yy527; + if (yych <= 0xF4) goto yy528; + } + } + } + } } -yy487: +yy494: { return 0; } -yy488: +yy495: yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy927; + case 'a': goto yy948; case 'H': - case 'h': goto yy926; + case 'h': goto yy947; case 'I': - case 'i': goto yy929; + case 'i': goto yy950; case 'O': - case 'o': goto yy925; + case 'o': goto yy946; case 'R': - case 'r': goto yy928; + case 'r': goto yy949; case 'V': - case 'v': goto yy924; - default: goto yy487; + case 'v': goto yy945; + default: goto yy494; } -yy489: +yy496: yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy900; + case 'a': goto yy921; case 'I': - case 'i': goto yy899; + case 'i': goto yy920; case 'L': - case 'l': goto yy897; + case 'l': goto yy918; case 'N': - case 'n': goto yy898; + case 'n': goto yy919; case 'O': - case 'o': goto yy901; + case 'o': goto yy922; case 'T': - case 't': goto yy896; + case 't': goto yy917; case 'V': - case 'v': goto yy895; - default: goto yy487; + case 'v': goto yy916; + default: goto yy494; } -yy490: +yy497: yych = *(marker = ++p); if (yych <= 'M') { - if (yych == 'A') goto yy887; - if (yych <= 'L') goto yy487; - goto yy886; + if (yych == 'A') goto yy908; + if (yych <= 'L') goto yy494; + goto yy907; } else { if (yych <= 'a') { - if (yych <= '`') goto yy487; - goto yy887; + if (yych <= '`') goto yy494; + goto yy908; } else { - if (yych == 'm') goto yy886; - goto yy487; + if (yych == 'm') goto yy907; + goto yy494; } } -yy491: +yy498: yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy868; + case 'a': goto yy889; case 'B': - case 'b': goto yy867; + case 'b': goto yy888; case 'C': - case 'c': goto yy866; + case 'c': goto yy887; case 'D': - case 'd': goto yy865; + case 'd': goto yy886; case 'F': - case 'f': goto yy864; + case 'f': goto yy885; case 'I': - case 'i': goto yy863; + case 'i': goto yy884; case 'P': - case 'p': goto yy862; + case 'p': goto yy883; case 'T': - case 't': goto yy861; + case 't': goto yy882; case 'W': - case 'w': goto yy519; - default: goto yy487; + case 'w': goto yy533; + default: goto yy494; } -yy492: +yy499: yych = *(marker = ++p); if (yych <= 'T') { if (yych <= 'E') { - if (yych == 'A') goto yy848; - if (yych <= 'D') goto yy487; - goto yy847; + if (yych == 'A') goto yy869; + if (yych <= 'D') goto yy494; + goto yy868; } else { - if (yych == 'I') goto yy846; - if (yych <= 'S') goto yy487; - goto yy849; + if (yych == 'I') goto yy867; + if (yych <= 'S') goto yy494; + goto yy870; } } else { if (yych <= 'e') { - if (yych == 'a') goto yy848; - if (yych <= 'd') goto yy487; - goto yy847; + if (yych == 'a') goto yy869; + if (yych <= 'd') goto yy494; + goto yy868; } else { if (yych <= 'i') { - if (yych <= 'h') goto yy487; - goto yy846; + if (yych <= 'h') goto yy494; + goto yy867; } else { - if (yych == 't') goto yy849; - goto yy487; + if (yych == 't') goto yy870; + goto yy494; } } } -yy493: +yy500: yych = *(marker = ++p); switch (yych) { case 'E': - case 'e': goto yy831; + case 'e': goto yy852; case 'G': - case 'g': goto yy519; + case 'g': goto yy533; case 'I': - case 'i': goto yy829; + case 'i': goto yy850; case 'O': - case 'o': goto yy830; + case 'o': goto yy851; case 'T': - case 't': goto yy828; - default: goto yy487; + case 't': goto yy849; + default: goto yy494; } -yy494: +yy501: yych = *(marker = ++p); if (yych <= 'S') { if (yych <= '3') { - if (yych <= '2') goto yy487; - goto yy824; + if (yych <= '2') goto yy494; + goto yy845; } else { - if (yych == 'C') goto yy822; - goto yy487; + if (yych == 'C') goto yy843; + goto yy494; } } else { if (yych <= 'c') { - if (yych <= 'T') goto yy823; - if (yych <= 'b') goto yy487; - goto yy822; + if (yych <= 'T') goto yy844; + if (yych <= 'b') goto yy494; + goto yy843; } else { - if (yych == 't') goto yy823; - goto yy487; + if (yych == 't') goto yy844; + goto yy494; } } -yy495: +yy502: yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy804; + case 'a': goto yy825; case 'C': - case 'c': goto yy801; + case 'c': goto yy822; case 'M': - case 'm': goto yy803; + case 'm': goto yy824; case 'N': - case 'n': goto yy802; + case 'n': goto yy823; case 'P': - case 'p': goto yy800; + case 'p': goto yy821; case 'R': - case 'r': goto yy799; + case 'r': goto yy820; case 'T': - case 't': goto yy798; - default: goto yy487; + case 't': goto yy819; + default: goto yy494; } -yy496: +yy503: yych = *(marker = ++p); if (yych <= 'D') { - if (yych == 'A') goto yy792; - if (yych <= 'C') goto yy487; - goto yy791; + if (yych == 'A') goto yy813; + if (yych <= 'C') goto yy494; + goto yy812; } else { if (yych <= 'a') { - if (yych <= '`') goto yy487; - goto yy792; + if (yych <= '`') goto yy494; + goto yy813; } else { - if (yych == 'd') goto yy791; - goto yy487; + if (yych == 'd') goto yy812; + goto yy494; } } -yy497: +yy504: yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy758; + case 'a': goto yy779; case 'E': - case 'e': goto yy757; + case 'e': goto yy778; case 'I': - case 'i': goto yy760; + case 'i': goto yy781; case 'M': - case 'm': goto yy756; + case 'm': goto yy777; case 'S': - case 's': goto yy755; + case 's': goto yy776; case 'T': - case 't': goto yy759; + case 't': goto yy780; case 'U': - case 'u': goto yy754; + case 'u': goto yy775; case 'V': - case 'v': goto yy753; - default: goto yy487; + case 'v': goto yy774; + default: goto yy494; } -yy498: +yy505: yych = *(marker = ++p); switch (yych) { case 'E': - case 'e': goto yy748; + case 'e': goto yy769; case 'F': - case 'f': goto yy747; + case 'f': goto yy768; case 'I': - case 'i': goto yy746; + case 'i': goto yy767; case 'N': - case 'n': goto yy745; + case 'n': goto yy766; case 'O': - case 'o': goto yy744; - default: goto yy487; + case 'o': goto yy765; + default: goto yy494; } -yy499: +yy506: yych = *(marker = ++p); if (yych <= 'P') { - if (yych == 'I') goto yy730; - if (yych <= 'O') goto yy487; - goto yy731; + if (yych == 'I') goto yy751; + if (yych <= 'O') goto yy494; + goto yy752; } else { if (yych <= 'i') { - if (yych <= 'h') goto yy487; - goto yy730; + if (yych <= 'h') goto yy494; + goto yy751; } else { - if (yych == 'p') goto yy731; - goto yy487; + if (yych == 'p') goto yy752; + goto yy494; } } -yy500: +yy507: yych = *(marker = ++p); if (yych <= 'S') { if (yych <= 'L') { - if (yych == 'A') goto yy712; - if (yych <= 'K') goto yy487; - goto yy711; + if (yych == 'A') goto yy733; + if (yych <= 'K') goto yy494; + goto yy732; } else { if (yych <= 'O') { - if (yych <= 'N') goto yy487; - goto yy713; + if (yych <= 'N') goto yy494; + goto yy734; } else { - if (yych <= 'Q') goto yy487; - if (yych <= 'R') goto yy710; - goto yy709; + if (yych <= 'Q') goto yy494; + if (yych <= 'R') goto yy731; + goto yy730; } } } else { if (yych <= 'n') { if (yych <= 'a') { - if (yych <= '`') goto yy487; - goto yy712; + if (yych <= '`') goto yy494; + goto yy733; } else { - if (yych == 'l') goto yy711; - goto yy487; + if (yych == 'l') goto yy732; + goto yy494; } } else { if (yych <= 'q') { - if (yych <= 'o') goto yy713; - goto yy487; + if (yych <= 'o') goto yy734; + goto yy494; } else { - if (yych <= 'r') goto yy710; - if (yych <= 's') goto yy709; - goto yy487; + if (yych <= 'r') goto yy731; + if (yych <= 's') goto yy730; + goto yy494; } } } -yy501: +yy508: yych = *(marker = ++p); if (yych <= 'T') { if (yych <= 'L') { - if (yych == 'E') goto yy699; - goto yy487; + if (yych == 'E') goto yy720; + goto yy494; } else { - if (yych <= 'M') goto yy698; - if (yych <= 'R') goto yy487; - if (yych <= 'S') goto yy697; - goto yy696; + if (yych <= 'M') goto yy719; + if (yych <= 'R') goto yy494; + if (yych <= 'S') goto yy718; + goto yy717; } } else { if (yych <= 'm') { - if (yych == 'e') goto yy699; - if (yych <= 'l') goto yy487; - goto yy698; + if (yych == 'e') goto yy720; + if (yych <= 'l') goto yy494; + goto yy719; } else { - if (yych <= 'r') goto yy487; - if (yych <= 's') goto yy697; - if (yych <= 't') goto yy696; - goto yy487; + if (yych <= 'r') goto yy494; + if (yych <= 's') goto yy718; + if (yych <= 't') goto yy717; + goto yy494; } } -yy502: +yy509: yych = *(marker = ++p); switch (yych) { case 'E': - case 'e': goto yy652; + case 'e': goto yy673; case 'F': - case 'f': goto yy651; + case 'f': goto yy672; case 'G': - case 'g': goto yy650; + case 'g': goto yy671; case 'H': - case 'h': goto yy655; + case 'h': goto yy676; case 'I': - case 'i': goto yy654; + case 'i': goto yy675; case 'K': - case 'k': goto yy649; + case 'k': goto yy670; case 'M': - case 'm': goto yy648; + case 'm': goto yy669; case 'N': - case 'n': goto yy653; + case 'n': goto yy674; case 'O': - case 'o': goto yy647; + case 'o': goto yy668; case 'P': - case 'p': goto yy646; + case 'p': goto yy667; case 'S': - case 's': goto yy645; + case 's': goto yy666; case 'T': - case 't': goto yy644; + case 't': goto yy665; case 'V': - case 'v': goto yy643; - default: goto yy487; + case 'v': goto yy664; + default: goto yy494; } -yy503: +yy510: yych = *(marker = ++p); switch (yych) { case 'A': - case 'a': goto yy619; + case 'a': goto yy640; case 'E': - case 'e': goto yy615; + case 'e': goto yy636; case 'F': - case 'f': goto yy618; + case 'f': goto yy639; case 'H': - case 'h': goto yy614; + case 'h': goto yy635; case 'I': - case 'i': goto yy616; + case 'i': goto yy637; case 'N': - case 'n': goto yy617; + case 'n': goto yy638; case 'V': - case 'v': goto yy519; - default: goto yy487; + case 'v': goto yy533; + default: goto yy494; } -yy504: +yy511: yych = *(marker = ++p); if (yych <= 'T') { if (yych <= 'N') { - if (yych == 'D') goto yy606; - if (yych <= 'M') goto yy487; - goto yy605; + if (yych == 'D') goto yy627; + if (yych <= 'M') goto yy494; + goto yy626; } else { - if (yych == 'R') goto yy607; - if (yych <= 'S') goto yy487; - goto yy604; + if (yych == 'R') goto yy628; + if (yych <= 'S') goto yy494; + goto yy625; } } else { if (yych <= 'n') { - if (yych == 'd') goto yy606; - if (yych <= 'm') goto yy487; - goto yy605; + if (yych == 'd') goto yy627; + if (yych <= 'm') goto yy494; + goto yy626; } else { if (yych <= 'r') { - if (yych <= 'q') goto yy487; - goto yy607; + if (yych <= 'q') goto yy494; + goto yy628; } else { - if (yych == 't') goto yy604; - goto yy487; + if (yych == 't') goto yy625; + goto yy494; } } } -yy505: +yy512: yych = *(marker = ++p); if (yych <= 'I') { - if (yych == 'E') goto yy588; - if (yych <= 'H') goto yy487; - goto yy587; + if (yych == 'E') goto yy609; + if (yych <= 'H') goto yy494; + goto yy608; } else { if (yych <= 'e') { - if (yych <= 'd') goto yy487; - goto yy588; + if (yych <= 'd') goto yy494; + goto yy609; } else { - if (yych == 'i') goto yy587; - goto yy487; + if (yych == 'i') goto yy608; + goto yy494; } } -yy506: +yy513: yych = *(marker = ++p); if (yych <= 'Y') { if (yych <= 'R') { - if (yych == 'E') goto yy577; - goto yy487; + if (yych == 'E') goto yy598; + goto yy494; } else { - if (yych <= 'S') goto yy578; - if (yych <= 'T') goto yy576; - if (yych <= 'X') goto yy487; - goto yy575; + if (yych <= 'S') goto yy599; + if (yych <= 'T') goto yy597; + if (yych <= 'X') goto yy494; + goto yy596; } } else { if (yych <= 's') { - if (yych == 'e') goto yy577; - if (yych <= 'r') goto yy487; - goto yy578; + if (yych == 'e') goto yy598; + if (yych <= 'r') goto yy494; + goto yy599; } else { - if (yych <= 't') goto yy576; - if (yych == 'y') goto yy575; - goto yy487; + if (yych <= 't') goto yy597; + if (yych == 'y') goto yy596; + goto yy494; } } -yy507: +yy514: yych = *(marker = ++p); if (yych <= 'R') { if (yych <= 'F') { - if (yych == 'C') goto yy554; - if (yych <= 'E') goto yy487; - goto yy552; + if (yych == 'C') goto yy575; + if (yych <= 'E') goto yy494; + goto yy573; } else { - if (yych == 'M') goto yy553; - if (yych <= 'Q') goto yy487; - goto yy551; + if (yych == 'M') goto yy574; + if (yych <= 'Q') goto yy494; + goto yy572; } } else { if (yych <= 'f') { - if (yych == 'c') goto yy554; - if (yych <= 'e') goto yy487; - goto yy552; + if (yych == 'c') goto yy575; + if (yych <= 'e') goto yy494; + goto yy573; } else { if (yych <= 'm') { - if (yych <= 'l') goto yy487; - goto yy553; + if (yych <= 'l') goto yy494; + goto yy574; } else { - if (yych == 'r') goto yy551; - goto yy487; + if (yych == 'r') goto yy572; + goto yy494; } } } -yy508: +yy515: yych = *(marker = ++p); - if (yych == '3') goto yy546; - goto yy487; -yy509: + if (yych == '3') goto yy567; + goto yy494; +yy516: yych = *(marker = ++p); if (yych <= 'O') { if (yych <= 'H') { - if (yych == 'E') goto yy536; - goto yy487; + if (yych == 'E') goto yy557; + goto yy494; } else { - if (yych <= 'I') goto yy535; - if (yych <= 'N') goto yy487; - goto yy534; + if (yych <= 'I') goto yy556; + if (yych <= 'N') goto yy494; + goto yy555; } } else { if (yych <= 'h') { - if (yych == 'e') goto yy536; - goto yy487; + if (yych == 'e') goto yy557; + goto yy494; } else { - if (yych <= 'i') goto yy535; - if (yych == 'o') goto yy534; - goto yy487; + if (yych <= 'i') goto yy556; + if (yych == 'o') goto yy555; + goto yy494; } } -yy510: +yy517: yych = *(marker = ++p); - if (yych == 'D') goto yy532; - if (yych == 'd') goto yy532; - goto yy487; -yy511: + if (yych == 'D') goto yy553; + if (yych == 'd') goto yy553; + goto yy494; +yy518: yych = *(marker = ++p); - if (yych == 'E') goto yy527; - if (yych == 'e') goto yy527; - goto yy487; -yy512: + if (yych == 'E') goto yy548; + if (yych == 'e') goto yy548; + goto yy494; +yy519: yych = *(marker = ++p); - if (yych == 'U') goto yy524; - if (yych == 'u') goto yy524; - goto yy487; -yy513: + if (yych == 'U') goto yy545; + if (yych == 'u') goto yy545; + goto yy494; +yy520: yych = *(marker = ++p); - if (yych == 'M') goto yy515; - if (yych == 'm') goto yy515; - goto yy487; -yy514: + if (yych == 'M') goto yy530; + if (yych == 'm') goto yy530; + goto yy494; +yy521: yych = *++p; - goto yy487; -yy515: + goto yy494; +yy522: yych = *++p; - if (yych == 'S') goto yy517; - if (yych == 's') goto yy517; -yy516: + if (yych <= 0x7F) goto yy523; + if (yych <= 0xBF) goto yy521; +yy523: p = marker; - goto yy487; -yy517: - yych = *++p; - if (yych == 'G') goto yy518; - if (yych != 'g') goto yy516; -yy518: - yych = *++p; - if (yych == 'R') goto yy519; - if (yych != 'r') goto yy516; -yy519: - yych = *++p; - if (yych != ':') goto yy516; -yy520: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy520; - } - if (yych <= '=') goto yy516; - ++p; - { return (bufsize_t)(p - start); } + goto yy494; yy524: yych = *++p; - if (yych == 'E') goto yy525; - if (yych != 'e') goto yy516; + if (yych <= 0x9F) goto yy523; + if (yych <= 0xBF) goto yy522; + goto yy523; yy525: yych = *++p; - if (yych == 'R') goto yy526; - if (yych != 'r') goto yy516; + if (yych <= 0x7F) goto yy523; + if (yych <= 0xBF) goto yy522; + goto yy523; yy526: yych = *++p; - if (yych == 'Y') goto yy519; - if (yych == 'y') goto yy519; - goto yy516; + if (yych <= 0x8F) goto yy523; + if (yych <= 0xBF) goto yy525; + goto yy523; yy527: yych = *++p; - if (yych == 'Y') goto yy528; - if (yych != 'y') goto yy516; + if (yych <= 0x7F) goto yy523; + if (yych <= 0xBF) goto yy525; + goto yy523; yy528: yych = *++p; - if (yych == 'P') goto yy529; - if (yych != 'p') goto yy516; + if (yych <= 0x7F) goto yy523; + if (yych <= 0x8F) goto yy525; + goto yy523; yy529: yych = *++p; - if (yych == 'A') goto yy530; - if (yych != 'a') goto yy516; + if (yych <= 0x7F) goto yy523; + if (yych <= 0x9F) goto yy522; + goto yy523; yy530: yych = *++p; - if (yych == 'R') goto yy531; - if (yych != 'r') goto yy516; + if (yych == 'S') goto yy531; + if (yych != 's') goto yy523; yy531: yych = *++p; - if (yych == 'C') goto yy519; - if (yych == 'c') goto yy519; - goto yy516; + if (yych == 'G') goto yy532; + if (yych != 'g') goto yy523; yy532: yych = *++p; - if (yych != '2') goto yy516; + if (yych == 'R') goto yy533; + if (yych != 'r') goto yy523; +yy533: yych = *++p; - if (yych == 'K') goto yy519; - if (yych == 'k') goto yy519; - goto yy516; + if (yych != ':') goto yy523; yy534: - yych = *++p; - if (yych == 'L') goto yy545; - if (yych == 'l') goto yy545; - goto yy516; -yy535: - yych = *++p; - if (yych == 'T') goto yy541; - if (yych == 't') goto yy541; - goto yy516; + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy534; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '<') goto yy523; + if (yych <= '>') goto yy543; + goto yy523; + } else { + if (yych <= 0xDF) goto yy536; + if (yych <= 0xE0) goto yy537; + goto yy538; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy542; + if (yych <= 0xEF) goto yy538; + goto yy539; + } else { + if (yych <= 0xF3) goto yy540; + if (yych <= 0xF4) goto yy541; + goto yy523; + } + } yy536: - yych = *++p; - if (yych == 'S') goto yy537; - if (yych != 's') goto yy516; + ++p; + yych = *p; + if (yych <= 0x7F) goto yy523; + if (yych <= 0xBF) goto yy534; + goto yy523; yy537: - yych = *++p; - if (yych == 'H') goto yy538; - if (yych != 'h') goto yy516; + ++p; + yych = *p; + if (yych <= 0x9F) goto yy523; + if (yych <= 0xBF) goto yy536; + goto yy523; yy538: - yych = *++p; - if (yych == 'A') goto yy539; - if (yych != 'a') goto yy516; + ++p; + yych = *p; + if (yych <= 0x7F) goto yy523; + if (yych <= 0xBF) goto yy536; + goto yy523; yy539: - yych = *++p; - if (yych == 'R') goto yy540; - if (yych != 'r') goto yy516; + ++p; + yych = *p; + if (yych <= 0x8F) goto yy523; + if (yych <= 0xBF) goto yy538; + goto yy523; yy540: - yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + ++p; + yych = *p; + if (yych <= 0x7F) goto yy523; + if (yych <= 0xBF) goto yy538; + goto yy523; yy541: - yych = *++p; - if (yych == 'C') goto yy542; - if (yych != 'c') goto yy516; + ++p; + yych = *p; + if (yych <= 0x7F) goto yy523; + if (yych <= 0x8F) goto yy538; + goto yy523; yy542: - yych = *++p; - if (yych == 'O') goto yy543; - if (yych != 'o') goto yy516; + ++p; + yych = *p; + if (yych <= 0x7F) goto yy523; + if (yych <= 0x9F) goto yy536; + goto yy523; yy543: - yych = *++p; - if (yych == 'I') goto yy544; - if (yych != 'i') goto yy516; -yy544: - yych = *++p; - if (yych == 'N') goto yy519; - if (yych == 'n') goto yy519; - goto yy516; + ++p; + { return (bufsize_t)(p - start); } yy545: yych = *++p; - if (yych == 'O') goto yy519; - if (yych == 'o') goto yy519; - goto yy516; + if (yych == 'E') goto yy546; + if (yych != 'e') goto yy523; yy546: yych = *++p; - if (yych != '9') goto yy516; + if (yych == 'R') goto yy547; + if (yych != 'r') goto yy523; +yy547: yych = *++p; - if (yych != '.') goto yy516; + if (yych == 'Y') goto yy533; + if (yych == 'y') goto yy533; + goto yy523; +yy548: yych = *++p; - if (yych != '5') goto yy516; + if (yych == 'Y') goto yy549; + if (yych != 'y') goto yy523; +yy549: yych = *++p; - if (yych != '0') goto yy516; + if (yych == 'P') goto yy550; + if (yych != 'p') goto yy523; +yy550: yych = *++p; - if (yych <= 'Q') goto yy516; - if (yych <= 'S') goto yy519; - if (yych <= 'q') goto yy516; - if (yych <= 's') goto yy519; - goto yy516; + if (yych == 'A') goto yy551; + if (yych != 'a') goto yy523; yy551: yych = *++p; - if (yych == 'I') goto yy519; - if (yych == 'i') goto yy519; - goto yy516; + if (yych == 'R') goto yy552; + if (yych != 'r') goto yy523; yy552: yych = *++p; - if (yych == 'I') goto yy573; - if (yych == 'i') goto yy573; - goto yy516; + if (yych == 'C') goto yy533; + if (yych == 'c') goto yy533; + goto yy523; yy553: yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy563; - if (yych <= 'O') goto yy516; - goto yy564; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy516; - goto yy563; - } else { - if (yych == 'p') goto yy564; - goto yy516; - } - } -yy554: + if (yych != '2') goto yy523; yych = *++p; - if (yych == 'O') goto yy555; - if (yych != 'o') goto yy516; + if (yych == 'K') goto yy533; + if (yych == 'k') goto yy533; + goto yy523; yy555: yych = *++p; - if (yych == 'N') goto yy556; - if (yych != 'n') goto yy516; + if (yych == 'L') goto yy566; + if (yych == 'l') goto yy566; + goto yy523; yy556: yych = *++p; - if (yych == '-') goto yy557; - if (yych == ':') goto yy520; - goto yy516; + if (yych == 'T') goto yy562; + if (yych == 't') goto yy562; + goto yy523; yy557: yych = *++p; - if (yych == 'U') goto yy558; - if (yych != 'u') goto yy516; + if (yych == 'S') goto yy558; + if (yych != 's') goto yy523; yy558: yych = *++p; - if (yych == 'S') goto yy559; - if (yych != 's') goto yy516; + if (yych == 'H') goto yy559; + if (yych != 'h') goto yy523; yy559: yych = *++p; - if (yych == 'E') goto yy560; - if (yych != 'e') goto yy516; + if (yych == 'A') goto yy560; + if (yych != 'a') goto yy523; yy560: yych = *++p; if (yych == 'R') goto yy561; - if (yych != 'r') goto yy516; + if (yych != 'r') goto yy523; yy561: yych = *++p; - if (yych == 'I') goto yy562; - if (yych != 'i') goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy562: yych = *++p; - if (yych == 'D') goto yy519; - if (yych == 'd') goto yy519; - goto yy516; + if (yych == 'C') goto yy563; + if (yych != 'c') goto yy523; yy563: yych = *++p; - if (yych == 'R') goto yy565; - if (yych == 'r') goto yy565; - goto yy516; + if (yych == 'O') goto yy564; + if (yych != 'o') goto yy523; yy564: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'I') goto yy565; + if (yych != 'i') goto yy523; yy565: yych = *++p; - if (yych == 'P') goto yy566; - if (yych != 'p') goto yy516; + if (yych == 'N') goto yy533; + if (yych == 'n') goto yy533; + goto yy523; yy566: yych = *++p; - if (yych == 'C') goto yy567; - if (yych != 'c') goto yy516; + if (yych == 'O') goto yy533; + if (yych == 'o') goto yy533; + goto yy523; yy567: yych = *++p; - if (yych != '.') goto yy516; + if (yych != '9') goto yy523; yych = *++p; - if (yych == 'B') goto yy569; - if (yych != 'b') goto yy516; -yy569: + if (yych != '.') goto yy523; yych = *++p; - if (yych == 'E') goto yy570; - if (yych != 'e') goto yy516; -yy570: + if (yych != '5') goto yy523; yych = *++p; - if (yych == 'E') goto yy571; - if (yych != 'e') goto yy516; -yy571: + if (yych != '0') goto yy523; yych = *++p; - if (yych == 'P') goto yy572; - if (yych != 'p') goto yy516; + if (yych <= 'Q') goto yy523; + if (yych <= 'S') goto yy533; + if (yych <= 'q') goto yy523; + if (yych <= 's') goto yy533; + goto yy523; yy572: yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; - } + if (yych == 'I') goto yy533; + if (yych == 'i') goto yy533; + goto yy523; yy573: yych = *++p; - if (yych == 'R') goto yy574; - if (yych != 'r') goto yy516; + if (yych == 'I') goto yy594; + if (yych == 'i') goto yy594; + goto yy523; yy574: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych <= 'P') { + if (yych == 'L') goto yy584; + if (yych <= 'O') goto yy523; + goto yy585; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy523; + goto yy584; + } else { + if (yych == 'p') goto yy585; + goto yy523; + } + } yy575: yych = *++p; - if (yych == 'C') goto yy583; - if (yych == 'c') goto yy583; - goto yy516; + if (yych == 'O') goto yy576; + if (yych != 'o') goto yy523; yy576: yych = *++p; - if (yych == 'A') goto yy582; - if (yych == 'a') goto yy582; - goto yy516; + if (yych == 'N') goto yy577; + if (yych != 'n') goto yy523; yy577: yych = *++p; - if (yych == 'B') goto yy579; - if (yych == 'b') goto yy579; - goto yy516; + if (yych == '-') goto yy578; + if (yych == ':') goto yy534; + goto yy523; yy578: yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; - } + if (yych == 'U') goto yy579; + if (yych != 'u') goto yy523; yy579: yych = *++p; - if (yych == 'C') goto yy580; - if (yych != 'c') goto yy516; + if (yych == 'S') goto yy580; + if (yych != 's') goto yy523; yy580: yych = *++p; - if (yych == 'A') goto yy581; - if (yych != 'a') goto yy516; + if (yych == 'E') goto yy581; + if (yych != 'e') goto yy523; yy581: yych = *++p; - if (yych == 'L') goto yy519; - if (yych == 'l') goto yy519; - goto yy516; + if (yych == 'R') goto yy582; + if (yych != 'r') goto yy523; yy582: yych = *++p; - if (yych == 'I') goto yy519; - if (yych == 'i') goto yy519; - goto yy516; + if (yych == 'I') goto yy583; + if (yych != 'i') goto yy523; yy583: yych = *++p; - if (yych == 'I') goto yy584; - if (yych != 'i') goto yy516; + if (yych == 'D') goto yy533; + if (yych == 'd') goto yy533; + goto yy523; yy584: yych = *++p; - if (yych == 'W') goto yy585; - if (yych != 'w') goto yy516; + if (yych == 'R') goto yy586; + if (yych == 'r') goto yy586; + goto yy523; yy585: yych = *++p; - if (yych == 'Y') goto yy586; - if (yych != 'y') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy586: yych = *++p; - if (yych == 'G') goto yy519; - if (yych == 'g') goto yy519; - goto yy516; + if (yych == 'P') goto yy587; + if (yych != 'p') goto yy523; yy587: yych = *++p; - if (yych == 'E') goto yy596; - if (yych == 'e') goto yy596; - goto yy516; + if (yych == 'C') goto yy588; + if (yych != 'c') goto yy523; yy588: yych = *++p; - if (yych <= 'N') { - if (yych <= 'L') goto yy516; - if (yych >= 'N') goto yy590; - } else { - if (yych <= 'l') goto yy516; - if (yych <= 'm') goto yy589; - if (yych <= 'n') goto yy590; - goto yy516; - } -yy589: + if (yych != '.') goto yy523; yych = *++p; - if (yych == 'M') goto yy595; - if (yych == 'm') goto yy595; - goto yy516; + if (yych == 'B') goto yy590; + if (yych != 'b') goto yy523; yy590: yych = *++p; - if (yych == 'T') goto yy591; - if (yych != 't') goto yy516; + if (yych == 'E') goto yy591; + if (yych != 'e') goto yy523; yy591: yych = *++p; - if (yych == 'R') goto yy592; - if (yych != 'r') goto yy516; + if (yych == 'E') goto yy592; + if (yych != 'e') goto yy523; yy592: yych = *++p; - if (yych == 'I') goto yy593; - if (yych != 'i') goto yy516; + if (yych == 'P') goto yy593; + if (yych != 'p') goto yy523; yy593: yych = *++p; - if (yych == 'L') goto yy594; - if (yych != 'l') goto yy516; + if (yych <= 'R') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; + } yy594: yych = *++p; - if (yych == 'O') goto yy519; - if (yych == 'o') goto yy519; - goto yy516; + if (yych == 'R') goto yy595; + if (yych != 'r') goto yy523; yy595: yych = *++p; - if (yych == 'I') goto yy519; - if (yych == 'i') goto yy519; - goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy596: yych = *++p; - if (yych == 'W') goto yy597; - if (yych != 'w') goto yy516; + if (yych == 'C') goto yy604; + if (yych == 'c') goto yy604; + goto yy523; yy597: yych = *++p; - if (yych != '-') goto yy516; + if (yych == 'A') goto yy603; + if (yych == 'a') goto yy603; + goto yy523; +yy598: yych = *++p; - if (yych == 'S') goto yy599; - if (yych != 's') goto yy516; + if (yych == 'B') goto yy600; + if (yych == 'b') goto yy600; + goto yy523; yy599: yych = *++p; - if (yych == 'O') goto yy600; - if (yych != 'o') goto yy516; + if (yych <= 'R') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; + } yy600: yych = *++p; - if (yych == 'U') goto yy601; - if (yych != 'u') goto yy516; + if (yych == 'C') goto yy601; + if (yych != 'c') goto yy523; yy601: yych = *++p; - if (yych == 'R') goto yy602; - if (yych != 'r') goto yy516; + if (yych == 'A') goto yy602; + if (yych != 'a') goto yy523; yy602: yych = *++p; - if (yych == 'C') goto yy603; - if (yych != 'c') goto yy516; + if (yych == 'L') goto yy533; + if (yych == 'l') goto yy533; + goto yy523; yy603: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'I') goto yy533; + if (yych == 'i') goto yy533; + goto yy523; yy604: yych = *++p; - if (yych == '2') goto yy611; - goto yy516; + if (yych == 'I') goto yy605; + if (yych != 'i') goto yy523; yy605: yych = *++p; - if (yych == 'R') goto yy608; - if (yych == 'r') goto yy608; - goto yy516; + if (yych == 'W') goto yy606; + if (yych != 'w') goto yy523; yy606: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'Y') goto yy607; + if (yych != 'y') goto yy523; yy607: yych = *++p; - if (yych == 'N') goto yy519; - if (yych == 'n') goto yy519; - goto yy516; + if (yych == 'G') goto yy533; + if (yych == 'g') goto yy533; + goto yy523; yy608: yych = *++p; - if (yych == 'E') goto yy609; - if (yych != 'e') goto yy516; + if (yych == 'E') goto yy617; + if (yych == 'e') goto yy617; + goto yy523; yy609: yych = *++p; - if (yych == 'A') goto yy610; - if (yych != 'a') goto yy516; + if (yych <= 'N') { + if (yych <= 'L') goto yy523; + if (yych >= 'N') goto yy611; + } else { + if (yych <= 'l') goto yy523; + if (yych <= 'm') goto yy610; + if (yych <= 'n') goto yy611; + goto yy523; + } yy610: yych = *++p; - if (yych == 'L') goto yy519; - if (yych == 'l') goto yy519; - goto yy516; + if (yych == 'M') goto yy616; + if (yych == 'm') goto yy616; + goto yy523; yy611: yych = *++p; - if (yych != '0') goto yy516; + if (yych == 'T') goto yy612; + if (yych != 't') goto yy523; +yy612: yych = *++p; - if (yych != '0') goto yy516; + if (yych == 'R') goto yy613; + if (yych != 'r') goto yy523; +yy613: yych = *++p; - if (yych == '4') goto yy519; - goto yy516; + if (yych == 'I') goto yy614; + if (yych != 'i') goto yy523; yy614: yych = *++p; - if (yych == 'I') goto yy633; - if (yych == 'i') goto yy633; - goto yy516; + if (yych == 'L') goto yy615; + if (yych != 'l') goto yy523; yy615: yych = *++p; - if (yych <= 'L') { - if (yych == 'A') goto yy625; - if (yych <= 'K') goto yy516; - goto yy624; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy516; - goto yy625; - } else { - if (yych == 'l') goto yy624; - goto yy516; - } - } + if (yych == 'O') goto yy533; + if (yych == 'o') goto yy533; + goto yy523; yy616: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'I') goto yy533; + if (yych == 'i') goto yy533; + goto yy523; yy617: yych = *++p; - if (yych == '3') goto yy621; - goto yy516; + if (yych == 'W') goto yy618; + if (yych != 'w') goto yy523; yy618: yych = *++p; - if (yych == 'T') goto yy620; - if (yych == 't') goto yy620; - goto yy516; -yy619: + if (yych != '-') goto yy523; yych = *++p; - if (yych == 'G') goto yy519; - if (yych == 'g') goto yy519; - goto yy516; + if (yych == 'S') goto yy620; + if (yych != 's') goto yy523; yy620: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'O') goto yy621; + if (yych != 'o') goto yy523; yy621: yych = *++p; - if (yych != '2') goto yy516; + if (yych == 'U') goto yy622; + if (yych != 'u') goto yy523; +yy622: yych = *++p; - if (yych != '7') goto yy516; + if (yych == 'R') goto yy623; + if (yych != 'r') goto yy523; +yy623: yych = *++p; - if (yych == '0') goto yy519; - goto yy516; + if (yych == 'C') goto yy624; + if (yych != 'c') goto yy523; yy624: yych = *++p; - if (yych <= 'M') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'N') goto yy631; - if (yych == 'n') goto yy631; - goto yy516; - } + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy625: yych = *++p; - if (yych == 'M') goto yy626; - if (yych != 'm') goto yy516; + if (yych == '2') goto yy632; + goto yy523; yy626: yych = *++p; - if (yych == 'S') goto yy627; - if (yych != 's') goto yy516; + if (yych == 'R') goto yy629; + if (yych == 'r') goto yy629; + goto yy523; yy627: yych = *++p; - if (yych == 'P') goto yy628; - if (yych != 'p') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy628: yych = *++p; - if (yych == 'E') goto yy629; - if (yych != 'e') goto yy516; + if (yych == 'N') goto yy533; + if (yych == 'n') goto yy533; + goto yy523; yy629: yych = *++p; - if (yych == 'A') goto yy630; - if (yych != 'a') goto yy516; + if (yych == 'E') goto yy630; + if (yych != 'e') goto yy523; yy630: yych = *++p; - if (yych == 'K') goto yy519; - if (yych == 'k') goto yy519; - goto yy516; + if (yych == 'A') goto yy631; + if (yych != 'a') goto yy523; yy631: yych = *++p; - if (yych == 'E') goto yy632; - if (yych != 'e') goto yy516; + if (yych == 'L') goto yy533; + if (yych == 'l') goto yy533; + goto yy523; yy632: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; -yy633: + if (yych != '0') goto yy523; yych = *++p; - if (yych <= 'S') { - if (yych == 'N') goto yy634; - if (yych <= 'R') goto yy516; - goto yy635; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy516; - } else { - if (yych == 's') goto yy635; - goto yy516; - } - } -yy634: + if (yych != '0') goto yy523; yych = *++p; - if (yych == 'G') goto yy642; - if (yych == 'g') goto yy642; - goto yy516; + if (yych == '4') goto yy533; + goto yy523; yy635: yych = *++p; - if (yych == 'M') goto yy636; - if (yych != 'm') goto yy516; + if (yych == 'I') goto yy654; + if (yych == 'i') goto yy654; + goto yy523; yy636: yych = *++p; - if (yych == 'E') goto yy637; - if (yych != 'e') goto yy516; + if (yych <= 'L') { + if (yych == 'A') goto yy646; + if (yych <= 'K') goto yy523; + goto yy645; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy523; + goto yy646; + } else { + if (yych == 'l') goto yy645; + goto yy523; + } + } yy637: yych = *++p; - if (yych == 'S') goto yy638; - if (yych != 's') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy638: yych = *++p; - if (yych == 'S') goto yy639; - if (yych != 's') goto yy516; + if (yych == '3') goto yy642; + goto yy523; yy639: yych = *++p; - if (yych == 'A') goto yy640; - if (yych != 'a') goto yy516; + if (yych == 'T') goto yy641; + if (yych == 't') goto yy641; + goto yy523; yy640: yych = *++p; - if (yych == 'G') goto yy641; - if (yych != 'g') goto yy516; + if (yych == 'G') goto yy533; + if (yych == 'g') goto yy533; + goto yy523; yy641: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy642: yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; -yy643: + if (yych != '2') goto yy523; yych = *++p; - if (yych == 'N') goto yy519; - if (yych == 'n') goto yy519; - goto yy516; -yy644: + if (yych != '7') goto yy523; yych = *++p; - if (yych == 'E') goto yy694; - if (yych == 'e') goto yy694; - goto yy516; + if (yych == '0') goto yy533; + goto yy523; yy645: yych = *++p; - if (yych == 'H') goto yy519; - if (yych == 'h') goto yy519; - goto yy516; + if (yych <= 'M') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'N') goto yy652; + if (yych == 'n') goto yy652; + goto yy523; + } yy646: yych = *++p; - if (yych == 'O') goto yy690; - if (yych == 'o') goto yy690; - goto yy516; + if (yych == 'M') goto yy647; + if (yych != 'm') goto yy523; yy647: yych = *++p; - if (yych <= 'L') { - if (yych == 'A') goto yy680; - if (yych <= 'K') goto yy516; - goto yy681; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy516; - goto yy680; - } else { - if (yych == 'l') goto yy681; - goto yy516; - } - } + if (yych == 'S') goto yy648; + if (yych != 's') goto yy523; yy648: yych = *++p; - if (yych <= 'S') { - if (yych == 'B') goto yy519; - if (yych <= 'R') goto yy516; - goto yy519; - } else { - if (yych <= 'b') { - if (yych <= 'a') goto yy516; - goto yy519; - } else { - if (yych == 's') goto yy519; - goto yy516; - } - } + if (yych == 'P') goto yy649; + if (yych != 'p') goto yy523; yy649: yych = *++p; - if (yych == 'Y') goto yy678; - if (yych == 'y') goto yy678; - goto yy516; + if (yych == 'E') goto yy650; + if (yych != 'e') goto yy523; yy650: yych = *++p; - if (yych == 'N') goto yy519; - if (yych == 'n') goto yy519; - goto yy516; + if (yych == 'A') goto yy651; + if (yych != 'a') goto yy523; yy651: yych = *++p; - if (yych == 'T') goto yy677; - if (yych == 't') goto yy677; - goto yy516; + if (yych == 'K') goto yy533; + if (yych == 'k') goto yy533; + goto yy523; yy652: yych = *++p; - if (yych <= 'S') { - if (yych <= 'C') { - if (yych <= 'B') goto yy516; - goto yy664; - } else { - if (yych <= 'Q') goto yy516; - if (yych <= 'R') goto yy662; - goto yy663; - } - } else { - if (yych <= 'q') { - if (yych == 'c') goto yy664; - goto yy516; - } else { - if (yych <= 'r') goto yy662; - if (yych <= 's') goto yy663; - goto yy516; - } - } + if (yych == 'E') goto yy653; + if (yych != 'e') goto yy523; yy653: yych = *++p; - if (yych == 'M') goto yy661; - if (yych == 'm') goto yy661; - goto yy516; + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; yy654: yych = *++p; - if (yych <= 'P') { - if (yych == 'E') goto yy658; - if (yych <= 'O') goto yy516; - goto yy659; + if (yych <= 'S') { + if (yych == 'N') goto yy655; + if (yych <= 'R') goto yy523; + goto yy656; } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy516; - goto yy658; + if (yych <= 'n') { + if (yych <= 'm') goto yy523; } else { - if (yych == 'p') goto yy659; - goto yy516; + if (yych == 's') goto yy656; + goto yy523; } } yy655: yych = *++p; - if (yych == 'T') goto yy656; - if (yych != 't') goto yy516; + if (yych == 'G') goto yy663; + if (yych == 'g') goto yy663; + goto yy523; yy656: yych = *++p; - if (yych == 'T') goto yy657; - if (yych != 't') goto yy516; + if (yych == 'M') goto yy657; + if (yych != 'm') goto yy523; yy657: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'E') goto yy658; + if (yych != 'e') goto yy523; yy658: yych = *++p; - if (yych == 'V') goto yy660; - if (yych == 'v') goto yy660; - goto yy516; + if (yych == 'S') goto yy659; + if (yych != 's') goto yy523; yy659: yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; - } + if (yych == 'S') goto yy660; + if (yych != 's') goto yy523; yy660: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'A') goto yy661; + if (yych != 'a') goto yy523; yy661: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'G') goto yy662; + if (yych != 'g') goto yy523; yy662: yych = *++p; - if (yych == 'V') goto yy674; - if (yych == 'v') goto yy674; - goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy663: yych = *++p; - if (yych == 'S') goto yy671; - if (yych == 's') goto yy671; - goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy664: yych = *++p; - if (yych == 'O') goto yy665; - if (yych != 'o') goto yy516; + if (yych == 'N') goto yy533; + if (yych == 'n') goto yy533; + goto yy523; yy665: yych = *++p; - if (yych == 'N') goto yy666; - if (yych != 'n') goto yy516; + if (yych == 'E') goto yy715; + if (yych == 'e') goto yy715; + goto yy523; yy666: yych = *++p; - if (yych == 'D') goto yy667; - if (yych != 'd') goto yy516; + if (yych == 'H') goto yy533; + if (yych == 'h') goto yy533; + goto yy523; yy667: yych = *++p; - if (yych == 'L') goto yy668; - if (yych != 'l') goto yy516; + if (yych == 'O') goto yy711; + if (yych == 'o') goto yy711; + goto yy523; yy668: yych = *++p; - if (yych == 'I') goto yy669; - if (yych != 'i') goto yy516; + if (yych <= 'L') { + if (yych == 'A') goto yy701; + if (yych <= 'K') goto yy523; + goto yy702; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy523; + goto yy701; + } else { + if (yych == 'l') goto yy702; + goto yy523; + } + } yy669: yych = *++p; - if (yych == 'F') goto yy670; - if (yych != 'f') goto yy516; + if (yych <= 'S') { + if (yych == 'B') goto yy533; + if (yych <= 'R') goto yy523; + goto yy533; + } else { + if (yych <= 'b') { + if (yych <= 'a') goto yy523; + goto yy533; + } else { + if (yych == 's') goto yy533; + goto yy523; + } + } yy670: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'Y') goto yy699; + if (yych == 'y') goto yy699; + goto yy523; yy671: yych = *++p; - if (yych == 'I') goto yy672; - if (yych != 'i') goto yy516; + if (yych == 'N') goto yy533; + if (yych == 'n') goto yy533; + goto yy523; yy672: yych = *++p; - if (yych == 'O') goto yy673; - if (yych != 'o') goto yy516; + if (yych == 'T') goto yy698; + if (yych == 't') goto yy698; + goto yy523; yy673: yych = *++p; - if (yych == 'N') goto yy519; - if (yych == 'n') goto yy519; - goto yy516; + if (yych <= 'S') { + if (yych <= 'C') { + if (yych <= 'B') goto yy523; + goto yy685; + } else { + if (yych <= 'Q') goto yy523; + if (yych <= 'R') goto yy683; + goto yy684; + } + } else { + if (yych <= 'q') { + if (yych == 'c') goto yy685; + goto yy523; + } else { + if (yych <= 'r') goto yy683; + if (yych <= 's') goto yy684; + goto yy523; + } + } yy674: yych = *++p; - if (yych == 'I') goto yy675; - if (yych != 'i') goto yy516; + if (yych == 'M') goto yy682; + if (yych == 'm') goto yy682; + goto yy523; yy675: yych = *++p; - if (yych == 'C') goto yy676; - if (yych != 'c') goto yy516; + if (yych <= 'P') { + if (yych == 'E') goto yy679; + if (yych <= 'O') goto yy523; + goto yy680; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy523; + goto yy679; + } else { + if (yych == 'p') goto yy680; + goto yy523; + } + } yy676: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'T') goto yy677; + if (yych != 't') goto yy523; yy677: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'T') goto yy678; + if (yych != 't') goto yy523; yy678: yych = *++p; - if (yych == 'P') goto yy679; - if (yych != 'p') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy679: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'V') goto yy681; + if (yych == 'v') goto yy681; + goto yy523; yy680: yych = *++p; - if (yych == 'P') goto yy684; - if (yych == 'p') goto yy684; - goto yy516; + if (yych <= 'R') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; + } yy681: yych = *++p; - if (yych == 'D') goto yy682; - if (yych != 'd') goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy682: yych = *++p; - if (yych == 'A') goto yy683; - if (yych != 'a') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy683: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; + if (yych == 'V') goto yy695; + if (yych == 'v') goto yy695; + goto yy523; yy684: yych = *++p; - if (yych != '.') goto yy516; + if (yych == 'S') goto yy692; + if (yych == 's') goto yy692; + goto yy523; +yy685: yych = *++p; - if (yych == 'B') goto yy686; - if (yych != 'b') goto yy516; + if (yych == 'O') goto yy686; + if (yych != 'o') goto yy523; yy686: yych = *++p; - if (yych == 'E') goto yy687; - if (yych != 'e') goto yy516; + if (yych == 'N') goto yy687; + if (yych != 'n') goto yy523; yy687: yych = *++p; - if (yych == 'E') goto yy688; - if (yych != 'e') goto yy516; + if (yych == 'D') goto yy688; + if (yych != 'd') goto yy523; yy688: yych = *++p; - if (yych == 'P') goto yy689; - if (yych != 'p') goto yy516; + if (yych == 'L') goto yy689; + if (yych != 'l') goto yy523; yy689: yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; - } + if (yych == 'I') goto yy690; + if (yych != 'i') goto yy523; yy690: yych = *++p; - if (yych == 'T') goto yy691; - if (yych != 't') goto yy516; + if (yych == 'F') goto yy691; + if (yych != 'f') goto yy523; yy691: yych = *++p; - if (yych == 'I') goto yy692; - if (yych != 'i') goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy692: yych = *++p; - if (yych == 'F') goto yy693; - if (yych != 'f') goto yy516; + if (yych == 'I') goto yy693; + if (yych != 'i') goto yy523; yy693: yych = *++p; - if (yych == 'Y') goto yy519; - if (yych == 'y') goto yy519; - goto yy516; + if (yych == 'O') goto yy694; + if (yych != 'o') goto yy523; yy694: yych = *++p; - if (yych == 'A') goto yy695; - if (yych != 'a') goto yy516; + if (yych == 'N') goto yy533; + if (yych == 'n') goto yy533; + goto yy523; yy695: yych = *++p; - if (yych == 'M') goto yy519; - if (yych == 'm') goto yy519; - goto yy516; + if (yych == 'I') goto yy696; + if (yych != 'i') goto yy523; yy696: yych = *++p; - if (yych <= 'S') { - if (yych == 'M') goto yy708; - if (yych <= 'R') goto yy516; - goto yy707; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy516; - goto yy708; - } else { - if (yych == 's') goto yy707; - goto yy516; - } - } + if (yych == 'C') goto yy697; + if (yych != 'c') goto yy523; yy697: yych = *++p; - if (yych == 'Y') goto yy705; - if (yych == 'y') goto yy705; - goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy698: yych = *++p; - if (yych == 'I') goto yy519; - if (yych == 'i') goto yy519; - goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy699: yych = *++p; - if (yych == 'S') goto yy700; - if (yych != 's') goto yy516; + if (yych == 'P') goto yy700; + if (yych != 'p') goto yy523; yy700: yych = *++p; - if (yych <= 'N') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'O') goto yy701; - if (yych != 'o') goto yy516; - } + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy701: yych = *++p; - if (yych == 'U') goto yy702; - if (yych != 'u') goto yy516; + if (yych == 'P') goto yy705; + if (yych == 'p') goto yy705; + goto yy523; yy702: yych = *++p; - if (yych == 'R') goto yy703; - if (yych != 'r') goto yy516; + if (yych == 'D') goto yy703; + if (yych != 'd') goto yy523; yy703: yych = *++p; - if (yych == 'C') goto yy704; - if (yych != 'c') goto yy516; + if (yych == 'A') goto yy704; + if (yych != 'a') goto yy523; yy704: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; yy705: yych = *++p; - if (yych == 'N') goto yy706; - if (yych != 'n') goto yy516; -yy706: + if (yych != '.') goto yy523; yych = *++p; - if (yych == 'C') goto yy519; - if (yych == 'c') goto yy519; - goto yy516; + if (yych == 'B') goto yy707; + if (yych != 'b') goto yy523; yy707: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'E') goto yy708; + if (yych != 'e') goto yy523; yy708: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'E') goto yy709; + if (yych != 'e') goto yy523; yy709: yych = *++p; - if (yych == 'Y') goto yy729; - if (yych == 'y') goto yy729; - goto yy516; + if (yych == 'P') goto yy710; + if (yych != 'p') goto yy523; yy710: yych = *++p; - if (yych <= 'O') { - if (yych == 'E') goto yy726; - if (yych <= 'N') goto yy516; - goto yy727; + if (yych <= 'R') { + if (yych == ':') goto yy534; + goto yy523; } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy516; - goto yy726; - } else { - if (yych == 'o') goto yy727; - goto yy516; - } + if (yych <= 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; } yy711: yych = *++p; - if (yych == 'A') goto yy721; - if (yych == 'a') goto yy721; - goto yy516; + if (yych == 'T') goto yy712; + if (yych != 't') goto yy523; yy712: yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy714; - if (yych <= 'O') goto yy516; - goto yy715; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy516; - goto yy714; - } else { - if (yych == 'p') goto yy715; - goto yy516; - } - } + if (yych == 'I') goto yy713; + if (yych != 'i') goto yy523; yy713: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'F') goto yy714; + if (yych != 'f') goto yy523; yy714: yych = *++p; - if (yych == 'M') goto yy519; - if (yych == 'm') goto yy519; - goto yy516; + if (yych == 'Y') goto yy533; + if (yych == 'y') goto yy533; + goto yy523; yy715: yych = *++p; if (yych == 'A') goto yy716; - if (yych != 'a') goto yy516; + if (yych != 'a') goto yy523; yy716: yych = *++p; - if (yych == 'R') goto yy717; - if (yych != 'r') goto yy516; + if (yych == 'M') goto yy533; + if (yych == 'm') goto yy533; + goto yy523; yy717: yych = *++p; - if (yych == 'A') goto yy718; - if (yych != 'a') goto yy516; + if (yych <= 'S') { + if (yych == 'M') goto yy729; + if (yych <= 'R') goto yy523; + goto yy728; + } else { + if (yych <= 'm') { + if (yych <= 'l') goto yy523; + goto yy729; + } else { + if (yych == 's') goto yy728; + goto yy523; + } + } yy718: yych = *++p; - if (yych == 'Z') goto yy719; - if (yych != 'z') goto yy516; + if (yych == 'Y') goto yy726; + if (yych == 'y') goto yy726; + goto yy523; yy719: yych = *++p; - if (yych == 'Z') goto yy720; - if (yych != 'z') goto yy516; + if (yych == 'I') goto yy533; + if (yych == 'i') goto yy533; + goto yy523; yy720: yych = *++p; - if (yych == 'I') goto yy519; - if (yych == 'i') goto yy519; - goto yy516; + if (yych == 'S') goto yy721; + if (yych != 's') goto yy523; yy721: yych = *++p; - if (yych == 'T') goto yy722; - if (yych != 't') goto yy516; + if (yych <= 'N') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'O') goto yy722; + if (yych != 'o') goto yy523; + } yy722: yych = *++p; - if (yych == 'F') goto yy723; - if (yych != 'f') goto yy516; + if (yych == 'U') goto yy723; + if (yych != 'u') goto yy523; yy723: yych = *++p; - if (yych == 'O') goto yy724; - if (yych != 'o') goto yy516; + if (yych == 'R') goto yy724; + if (yych != 'r') goto yy523; yy724: yych = *++p; - if (yych == 'R') goto yy725; - if (yych != 'r') goto yy516; + if (yych == 'C') goto yy725; + if (yych != 'c') goto yy523; yy725: yych = *++p; - if (yych == 'M') goto yy519; - if (yych == 'm') goto yy519; - goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy726: yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; + if (yych == 'N') goto yy727; + if (yych != 'n') goto yy523; yy727: yych = *++p; - if (yych == 'X') goto yy728; - if (yych != 'x') goto yy516; + if (yych == 'C') goto yy533; + if (yych == 'c') goto yy533; + goto yy523; yy728: yych = *++p; - if (yych == 'Y') goto yy519; - if (yych == 'y') goto yy519; - goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy729: yych = *++p; - if (yych == 'C') goto yy519; - if (yych == 'c') goto yy519; - goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy730: yych = *++p; - if (yych == 'D') goto yy519; - if (yych == 'd') goto yy519; - goto yy516; + if (yych == 'Y') goto yy750; + if (yych == 'y') goto yy750; + goto yy523; yy731: yych = *++p; - if (yych == 'A') goto yy732; - if (yych != 'a') goto yy516; + if (yych <= 'O') { + if (yych == 'E') goto yy747; + if (yych <= 'N') goto yy523; + goto yy748; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy523; + goto yy747; + } else { + if (yych == 'o') goto yy748; + goto yy523; + } + } yy732: yych = *++p; - if (yych == 'Q') goto yy733; - if (yych != 'q') goto yy516; + if (yych == 'A') goto yy742; + if (yych == 'a') goto yy742; + goto yy523; yy733: yych = *++p; - if (yych == 'U') goto yy734; - if (yych != 'u') goto yy516; + if (yych <= 'P') { + if (yych == 'L') goto yy735; + if (yych <= 'O') goto yy523; + goto yy736; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy523; + goto yy735; + } else { + if (yych == 'p') goto yy736; + goto yy523; + } + } yy734: yych = *++p; - if (yych == 'E') goto yy735; - if (yych != 'e') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy735: yych = *++p; - if (yych == 'L') goto yy736; - if (yych != 'l') goto yy516; + if (yych == 'M') goto yy533; + if (yych == 'm') goto yy533; + goto yy523; yy736: yych = *++p; - if (yych == 'O') goto yy737; - if (yych != 'o') goto yy516; + if (yych == 'A') goto yy737; + if (yych != 'a') goto yy523; yy737: yych = *++p; - if (yych == 'C') goto yy738; - if (yych != 'c') goto yy516; + if (yych == 'R') goto yy738; + if (yych != 'r') goto yy523; yy738: yych = *++p; - if (yych == 'K') goto yy739; - if (yych != 'k') goto yy516; + if (yych == 'A') goto yy739; + if (yych != 'a') goto yy523; yy739: yych = *++p; - if (yych == 'T') goto yy740; - if (yych != 't') goto yy516; + if (yych == 'Z') goto yy740; + if (yych != 'z') goto yy523; yy740: yych = *++p; - if (yych == 'O') goto yy741; - if (yych != 'o') goto yy516; + if (yych == 'Z') goto yy741; + if (yych != 'z') goto yy523; yy741: yych = *++p; - if (yych == 'K') goto yy742; - if (yych != 'k') goto yy516; + if (yych == 'I') goto yy533; + if (yych == 'i') goto yy533; + goto yy523; yy742: yych = *++p; - if (yych == 'E') goto yy743; - if (yych != 'e') goto yy516; + if (yych == 'T') goto yy743; + if (yych != 't') goto yy523; yy743: yych = *++p; - if (yych == 'N') goto yy519; - if (yych == 'n') goto yy519; - goto yy516; + if (yych == 'F') goto yy744; + if (yych != 'f') goto yy523; yy744: yych = *++p; - if (yych == 'T') goto yy751; - if (yych == 't') goto yy751; - goto yy516; + if (yych == 'O') goto yy745; + if (yych != 'o') goto yy523; yy745: yych = *++p; - if (yych == 'T') goto yy750; - if (yych == 't') goto yy750; - goto yy516; + if (yych == 'R') goto yy746; + if (yych != 'r') goto yy523; yy746: yych = *++p; - if (yych <= 'G') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'H') goto yy519; - if (yych == 'h') goto yy519; - goto yy516; - } + if (yych == 'M') goto yy533; + if (yych == 'm') goto yy533; + goto yy523; yy747: yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy748: yych = *++p; - if (yych == 'W') goto yy749; - if (yych != 'w') goto yy516; + if (yych == 'X') goto yy749; + if (yych != 'x') goto yy523; yy749: yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; + if (yych == 'Y') goto yy533; + if (yych == 'y') goto yy533; + goto yy523; yy750: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'C') goto yy533; + if (yych == 'c') goto yy533; + goto yy523; yy751: yych = *++p; - if (yych == 'E') goto yy752; - if (yych != 'e') goto yy516; + if (yych == 'D') goto yy533; + if (yych == 'd') goto yy533; + goto yy523; yy752: yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; + if (yych == 'A') goto yy753; + if (yych != 'a') goto yy523; yy753: yych = *++p; - if (yych == 'N') goto yy519; - if (yych == 'n') goto yy519; - goto yy516; + if (yych == 'Q') goto yy754; + if (yych != 'q') goto yy523; yy754: yych = *++p; - if (yych <= 'P') { - if (yych == 'M') goto yy785; - if (yych <= 'O') goto yy516; - goto yy784; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy516; - goto yy785; - } else { - if (yych == 'p') goto yy784; - goto yy516; - } - } + if (yych == 'U') goto yy755; + if (yych != 'u') goto yy523; yy755: yych = *++p; - if (yych <= 'Q') { - if (yych <= '-') { - if (yych <= ',') goto yy516; - goto yy777; - } else { - if (yych == 'N') goto yy778; - goto yy516; - } - } else { - if (yych <= 'n') { - if (yych <= 'R') goto yy776; - if (yych <= 'm') goto yy516; - goto yy778; - } else { - if (yych == 'r') goto yy776; - goto yy516; - } - } + if (yych == 'E') goto yy756; + if (yych != 'e') goto yy523; yy756: yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; + if (yych == 'L') goto yy757; + if (yych != 'l') goto yy523; yy757: yych = *++p; - if (yych == 'S') goto yy772; - if (yych == 's') goto yy772; - goto yy516; + if (yych == 'O') goto yy758; + if (yych != 'o') goto yy523; yy758: yych = *++p; - switch (yych) { - case 'G': - case 'g': goto yy763; - case 'I': - case 'i': goto yy762; - case 'P': - case 'p': goto yy764; - case 'R': - case 'r': goto yy765; - default: goto yy516; - } + if (yych == 'C') goto yy759; + if (yych != 'c') goto yy523; yy759: yych = *++p; - if (yych == 'Q') goto yy761; - if (yych == 'q') goto yy761; - goto yy516; + if (yych == 'K') goto yy760; + if (yych != 'k') goto yy523; yy760: yych = *++p; - if (yych == 'D') goto yy519; - if (yych == 'd') goto yy519; - goto yy516; + if (yych == 'T') goto yy761; + if (yych != 't') goto yy523; yy761: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'O') goto yy762; + if (yych != 'o') goto yy523; yy762: yych = *++p; - if (yych == 'L') goto yy770; - if (yych == 'l') goto yy770; - goto yy516; + if (yych == 'K') goto yy763; + if (yych != 'k') goto yy523; yy763: yych = *++p; - if (yych == 'N') goto yy768; - if (yych == 'n') goto yy768; - goto yy516; + if (yych == 'E') goto yy764; + if (yych != 'e') goto yy523; yy764: yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; + if (yych == 'N') goto yy533; + if (yych == 'n') goto yy533; + goto yy523; yy765: yych = *++p; - if (yych == 'K') goto yy766; - if (yych != 'k') goto yy516; + if (yych == 'T') goto yy772; + if (yych == 't') goto yy772; + goto yy523; yy766: yych = *++p; - if (yych == 'E') goto yy767; - if (yych != 'e') goto yy516; + if (yych == 'T') goto yy771; + if (yych == 't') goto yy771; + goto yy523; yy767: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; + if (yych <= 'G') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'H') goto yy533; + if (yych == 'h') goto yy533; + goto yy523; + } yy768: yych = *++p; - if (yych == 'E') goto yy769; - if (yych != 'e') goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy769: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; + if (yych == 'W') goto yy770; + if (yych != 'w') goto yy523; yy770: yych = *++p; - if (yych == 'T') goto yy771; - if (yych != 't') goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy771: yych = *++p; - if (yych == 'O') goto yy519; - if (yych == 'o') goto yy519; - goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy772: yych = *++p; - if (yych == 'S') goto yy773; - if (yych != 's') goto yy516; + if (yych == 'E') goto yy773; + if (yych != 'e') goto yy523; yy773: yych = *++p; - if (yych == 'A') goto yy774; - if (yych != 'a') goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy774: yych = *++p; - if (yych == 'G') goto yy775; - if (yych != 'g') goto yy516; + if (yych == 'N') goto yy533; + if (yych == 'n') goto yy533; + goto yy523; yy775: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; -yy776: - yych = *++p; - if (yych == 'P') goto yy783; - if (yych == 'p') goto yy783; - goto yy516; -yy777: + if (yych <= 'P') { + if (yych == 'M') goto yy806; + if (yych <= 'O') goto yy523; + goto yy805; + } else { + if (yych <= 'm') { + if (yych <= 'l') goto yy523; + goto yy806; + } else { + if (yych == 'p') goto yy805; + goto yy523; + } + } +yy776: + yych = *++p; + if (yych <= 'Q') { + if (yych <= '-') { + if (yych <= ',') goto yy523; + goto yy798; + } else { + if (yych == 'N') goto yy799; + goto yy523; + } + } else { + if (yych <= 'n') { + if (yych <= 'R') goto yy797; + if (yych <= 'm') goto yy523; + goto yy799; + } else { + if (yych == 'r') goto yy797; + goto yy523; + } + } +yy777: yych = *++p; - if (yych == 'H') goto yy780; - if (yych == 'h') goto yy780; - goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy778: yych = *++p; - if (yych == 'I') goto yy779; - if (yych != 'i') goto yy516; + if (yych == 'S') goto yy793; + if (yych == 's') goto yy793; + goto yy523; yy779: yych = *++p; - if (yych == 'M') goto yy519; - if (yych == 'm') goto yy519; - goto yy516; + switch (yych) { + case 'G': + case 'g': goto yy784; + case 'I': + case 'i': goto yy783; + case 'P': + case 'p': goto yy785; + case 'R': + case 'r': goto yy786; + default: goto yy523; + } yy780: yych = *++p; - if (yych == 'E') goto yy781; - if (yych != 'e') goto yy516; + if (yych == 'Q') goto yy782; + if (yych == 'q') goto yy782; + goto yy523; yy781: yych = *++p; - if (yych == 'L') goto yy782; - if (yych != 'l') goto yy516; + if (yych == 'D') goto yy533; + if (yych == 'd') goto yy533; + goto yy523; yy782: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy783: yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; - } + if (yych == 'L') goto yy791; + if (yych == 'l') goto yy791; + goto yy523; yy784: yych = *++p; - if (yych == 'D') goto yy788; - if (yych == 'd') goto yy788; - goto yy516; + if (yych == 'N') goto yy789; + if (yych == 'n') goto yy789; + goto yy523; yy785: yych = *++p; - if (yych == 'B') goto yy786; - if (yych != 'b') goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy786: yych = *++p; - if (yych == 'L') goto yy787; - if (yych != 'l') goto yy516; + if (yych == 'K') goto yy787; + if (yych != 'k') goto yy523; yy787: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'E') goto yy788; + if (yych != 'e') goto yy523; yy788: yych = *++p; - if (yych == 'A') goto yy789; - if (yych != 'a') goto yy516; + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; yy789: yych = *++p; - if (yych == 'T') goto yy790; - if (yych != 't') goto yy516; + if (yych == 'E') goto yy790; + if (yych != 'e') goto yy523; yy790: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; yy791: yych = *++p; - if (yych == 'A') goto yy796; - if (yych == 'a') goto yy796; - goto yy516; + if (yych == 'T') goto yy792; + if (yych != 't') goto yy523; yy792: yych = *++p; - if (yych == 'S') goto yy793; - if (yych != 's') goto yy516; + if (yych == 'O') goto yy533; + if (yych == 'o') goto yy533; + goto yy523; yy793: yych = *++p; - if (yych == 'T') goto yy794; - if (yych != 't') goto yy516; + if (yych == 'S') goto yy794; + if (yych != 's') goto yy523; yy794: yych = *++p; - if (yych == 'F') goto yy795; - if (yych != 'f') goto yy516; + if (yych == 'A') goto yy795; + if (yych != 'a') goto yy523; yy795: yych = *++p; - if (yych == 'M') goto yy519; - if (yych == 'm') goto yy519; - goto yy516; + if (yych == 'G') goto yy796; + if (yych != 'g') goto yy523; yy796: yych = *++p; - if (yych == 'P') goto yy797; - if (yych != 'p') goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy797: yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; - } + if (yych == 'P') goto yy804; + if (yych == 'p') goto yy804; + goto yy523; yy798: yych = *++p; - if (yych == 'M') goto yy821; - if (yych == 'm') goto yy821; - goto yy516; + if (yych == 'H') goto yy801; + if (yych == 'h') goto yy801; + goto yy523; yy799: yych = *++p; - if (yych <= 'I') { - if (yych == 'C') goto yy810; - if (yych <= 'H') goto yy516; - goto yy809; - } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy516; - goto yy810; - } else { - if (yych == 'i') goto yy809; - goto yy516; - } - } + if (yych == 'I') goto yy800; + if (yych != 'i') goto yy523; yy800: yych = *++p; - if (yych <= 'P') { - if (yych == 'N') goto yy519; - if (yych <= 'O') goto yy516; - goto yy519; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy516; - goto yy519; - } else { - if (yych == 'p') goto yy519; - goto yy516; - } - } + if (yych == 'M') goto yy533; + if (yych == 'm') goto yy533; + goto yy523; yy801: yych = *++p; - if (yych <= 'O') { - if (yych == 'A') goto yy807; - if (yych <= 'N') goto yy516; - goto yy808; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy516; - goto yy807; - } else { - if (yych == 'o') goto yy808; - goto yy516; - } - } + if (yych == 'E') goto yy802; + if (yych != 'e') goto yy523; yy802: yych = *++p; - if (yych == 'F') goto yy806; - if (yych == 'f') goto yy806; - goto yy516; + if (yych == 'L') goto yy803; + if (yych != 'l') goto yy523; yy803: yych = *++p; - if (yych <= '@') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'A') goto yy805; - if (yych == 'a') goto yy805; - goto yy516; - } + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy804: yych = *++p; - if (yych == 'X') goto yy519; - if (yych == 'x') goto yy519; - goto yy516; + if (yych <= 'R') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; + } yy805: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'D') goto yy809; + if (yych == 'd') goto yy809; + goto yy523; yy806: yych = *++p; - if (yych == 'O') goto yy519; - if (yych == 'o') goto yy519; - goto yy516; + if (yych == 'B') goto yy807; + if (yych != 'b') goto yy523; yy807: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'L') goto yy808; + if (yych != 'l') goto yy523; yy808: yych = *++p; - if (yych == 'N') goto yy519; - if (yych == 'n') goto yy519; - goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy809: yych = *++p; - if (yych == 'S') goto yy811; - if (yych == 's') goto yy811; - goto yy516; + if (yych == 'A') goto yy810; + if (yych != 'a') goto yy523; yy810: yych = *++p; - if (yych <= ':') { - if (yych == '6') goto yy519; - if (yych <= '9') goto yy516; - goto yy520; - } else { - if (yych <= 'S') { - if (yych <= 'R') goto yy516; - goto yy519; - } else { - if (yych == 's') goto yy519; - goto yy516; - } - } + if (yych == 'T') goto yy811; + if (yych != 't') goto yy523; yy811: yych = *++p; - if (yych == '.') goto yy812; - if (yych == ':') goto yy520; - goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy812: yych = *++p; - if (yych <= 'X') { - if (yych <= 'K') { - if (yych == 'B') goto yy815; - goto yy516; - } else { - if (yych <= 'L') goto yy813; - if (yych <= 'W') goto yy516; - goto yy814; - } - } else { - if (yych <= 'k') { - if (yych == 'b') goto yy815; - goto yy516; - } else { - if (yych <= 'l') goto yy813; - if (yych == 'x') goto yy814; - goto yy516; - } - } + if (yych == 'A') goto yy817; + if (yych == 'a') goto yy817; + goto yy523; yy813: yych = *++p; - if (yych == 'W') goto yy820; - if (yych == 'w') goto yy820; - goto yy516; + if (yych == 'S') goto yy814; + if (yych != 's') goto yy523; yy814: yych = *++p; - if (yych == 'P') goto yy818; - if (yych == 'p') goto yy818; - goto yy516; + if (yych == 'T') goto yy815; + if (yych != 't') goto yy523; yy815: yych = *++p; - if (yych == 'E') goto yy816; - if (yych != 'e') goto yy516; + if (yych == 'F') goto yy816; + if (yych != 'f') goto yy523; yy816: yych = *++p; - if (yych == 'E') goto yy817; - if (yych != 'e') goto yy516; + if (yych == 'M') goto yy533; + if (yych == 'm') goto yy533; + goto yy523; yy817: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'P') goto yy818; + if (yych != 'p') goto yy523; yy818: - yych = *++p; - if (yych == 'C') goto yy819; - if (yych != 'c') goto yy516; -yy819: yych = *++p; if (yych <= 'R') { - if (yych == ':') goto yy520; - goto yy516; + if (yych == ':') goto yy534; + goto yy523; } else { - if (yych <= 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; + if (yych <= 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; } +yy819: + yych = *++p; + if (yych == 'M') goto yy842; + if (yych == 'm') goto yy842; + goto yy523; yy820: yych = *++p; - if (yych == 'Z') goto yy519; - if (yych == 'z') goto yy519; - goto yy516; + if (yych <= 'I') { + if (yych == 'C') goto yy831; + if (yych <= 'H') goto yy523; + goto yy830; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy523; + goto yy831; + } else { + if (yych == 'i') goto yy830; + goto yy523; + } + } yy821: yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; + if (yych <= 'P') { + if (yych == 'N') goto yy533; + if (yych <= 'O') goto yy523; + goto yy533; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy523; + goto yy533; + } else { + if (yych == 'p') goto yy533; + goto yy523; + } + } yy822: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych <= 'O') { + if (yych == 'A') goto yy828; + if (yych <= 'N') goto yy523; + goto yy829; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy523; + goto yy828; + } else { + if (yych == 'o') goto yy829; + goto yy523; + } + } yy823: yych = *++p; - if (yych == 'T') goto yy826; - if (yych == 't') goto yy826; - goto yy516; + if (yych == 'F') goto yy827; + if (yych == 'f') goto yy827; + goto yy523; yy824: yych = *++p; - if (yych != '2') goto yy516; + if (yych <= '@') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'A') goto yy826; + if (yych == 'a') goto yy826; + goto yy523; + } +yy825: yych = *++p; - if (yych == '3') goto yy519; - goto yy516; + if (yych == 'X') goto yy533; + if (yych == 'x') goto yy533; + goto yy523; yy826: yych = *++p; - if (yych == 'P') goto yy827; - if (yych != 'p') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy827: yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; - } + if (yych == 'O') goto yy533; + if (yych == 'o') goto yy533; + goto yy523; yy828: yych = *++p; - if (yych == 'A') goto yy844; - if (yych == 'a') goto yy844; - goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy829: yych = *++p; - if (yych <= 'Z') { - if (yych == 'T') goto yy519; - if (yych <= 'Y') goto yy516; - goto yy835; - } else { - if (yych <= 't') { - if (yych <= 's') goto yy516; - goto yy519; - } else { - if (yych == 'z') goto yy835; - goto yy516; - } - } + if (yych == 'N') goto yy533; + if (yych == 'n') goto yy533; + goto yy523; yy830: yych = *++p; - if (yych <= 'O') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'P') goto yy832; - if (yych == 'p') goto yy832; - goto yy516; - } + if (yych == 'S') goto yy832; + if (yych == 's') goto yy832; + goto yy523; yy831: yych = *++p; - if (yych == 'O') goto yy519; - if (yych == 'o') goto yy519; - goto yy516; + if (yych <= ':') { + if (yych == '6') goto yy533; + if (yych <= '9') goto yy523; + goto yy534; + } else { + if (yych <= 'S') { + if (yych <= 'R') goto yy523; + goto yy533; + } else { + if (yych == 's') goto yy533; + goto yy523; + } + } yy832: yych = *++p; - if (yych == 'H') goto yy833; - if (yych != 'h') goto yy516; + if (yych == '.') goto yy833; + if (yych == ':') goto yy534; + goto yy523; yy833: yych = *++p; - if (yych == 'E') goto yy834; - if (yych != 'e') goto yy516; + if (yych <= 'X') { + if (yych <= 'K') { + if (yych == 'B') goto yy836; + goto yy523; + } else { + if (yych <= 'L') goto yy834; + if (yych <= 'W') goto yy523; + goto yy835; + } + } else { + if (yych <= 'k') { + if (yych == 'b') goto yy836; + goto yy523; + } else { + if (yych <= 'l') goto yy834; + if (yych == 'x') goto yy835; + goto yy523; + } + } yy834: yych = *++p; - if (yych == 'R') goto yy519; - if (yych == 'r') goto yy519; - goto yy516; + if (yych == 'W') goto yy841; + if (yych == 'w') goto yy841; + goto yy523; yy835: yych = *++p; - if (yych == 'M') goto yy836; - if (yych != 'm') goto yy516; + if (yych == 'P') goto yy839; + if (yych == 'p') goto yy839; + goto yy523; yy836: yych = *++p; - if (yych == 'O') goto yy837; - if (yych != 'o') goto yy516; + if (yych == 'E') goto yy837; + if (yych != 'e') goto yy523; yy837: yych = *++p; - if (yych == 'P') goto yy838; - if (yych != 'p') goto yy516; + if (yych == 'E') goto yy838; + if (yych != 'e') goto yy523; yy838: yych = *++p; - if (yych == 'R') goto yy839; - if (yych != 'r') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy839: yych = *++p; - if (yych == 'O') goto yy840; - if (yych != 'o') goto yy516; + if (yych == 'C') goto yy840; + if (yych != 'c') goto yy523; yy840: yych = *++p; - if (yych == 'J') goto yy841; - if (yych != 'j') goto yy516; + if (yych <= 'R') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; + } yy841: yych = *++p; - if (yych == 'E') goto yy842; - if (yych != 'e') goto yy516; + if (yych == 'Z') goto yy533; + if (yych == 'z') goto yy533; + goto yy523; yy842: yych = *++p; - if (yych == 'C') goto yy843; - if (yych != 'c') goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy843: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy844: yych = *++p; - if (yych == 'L') goto yy845; - if (yych != 'l') goto yy516; + if (yych == 'T') goto yy847; + if (yych == 't') goto yy847; + goto yy523; yy845: yych = *++p; - if (yych == 'K') goto yy519; - if (yych == 'k') goto yy519; - goto yy516; -yy846: + if (yych != '2') goto yy523; yych = *++p; - if (yych <= 'S') { - if (yych <= 'M') { - if (yych == 'L') goto yy856; - goto yy516; - } else { - if (yych <= 'N') goto yy857; - if (yych <= 'R') goto yy516; - goto yy858; - } - } else { - if (yych <= 'm') { - if (yych == 'l') goto yy856; - goto yy516; - } else { - if (yych <= 'n') goto yy857; - if (yych == 's') goto yy858; - goto yy516; - } - } + if (yych == '3') goto yy533; + goto yy523; yy847: yych = *++p; - if (yych == 'E') goto yy855; - if (yych == 'e') goto yy855; - goto yy516; + if (yych == 'P') goto yy848; + if (yych != 'p') goto yy523; yy848: yych = *++p; - if (yych == 'C') goto yy850; - if (yych == 'c') goto yy850; - goto yy516; + if (yych <= 'R') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; + } yy849: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'A') goto yy865; + if (yych == 'a') goto yy865; + goto yy523; yy850: yych = *++p; - if (yych == 'E') goto yy851; - if (yych != 'e') goto yy516; + if (yych <= 'Z') { + if (yych == 'T') goto yy533; + if (yych <= 'Y') goto yy523; + goto yy856; + } else { + if (yych <= 't') { + if (yych <= 's') goto yy523; + goto yy533; + } else { + if (yych == 'z') goto yy856; + goto yy523; + } + } yy851: yych = *++p; - if (yych == 'T') goto yy852; - if (yych != 't') goto yy516; + if (yych <= 'O') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'P') goto yy853; + if (yych == 'p') goto yy853; + goto yy523; + } yy852: yych = *++p; - if (yych == 'I') goto yy853; - if (yych != 'i') goto yy516; + if (yych == 'O') goto yy533; + if (yych == 'o') goto yy533; + goto yy523; yy853: yych = *++p; - if (yych == 'M') goto yy854; - if (yych != 'm') goto yy516; + if (yych == 'H') goto yy854; + if (yych != 'h') goto yy523; yy854: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'E') goto yy855; + if (yych != 'e') goto yy523; yy855: yych = *++p; - if (yych == 'D') goto yy519; - if (yych == 'd') goto yy519; - goto yy516; + if (yych == 'R') goto yy533; + if (yych == 'r') goto yy533; + goto yy523; yy856: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'M') goto yy857; + if (yych != 'm') goto yy523; yy857: yych = *++p; - if (yych == 'G') goto yy859; - if (yych == 'g') goto yy859; - goto yy516; + if (yych == 'O') goto yy858; + if (yych != 'o') goto yy523; yy858: yych = *++p; - if (yych == 'H') goto yy519; - if (yych == 'h') goto yy519; - goto yy516; + if (yych == 'P') goto yy859; + if (yych != 'p') goto yy523; yy859: yych = *++p; - if (yych == 'E') goto yy860; - if (yych != 'e') goto yy516; + if (yych == 'R') goto yy860; + if (yych != 'r') goto yy523; yy860: yych = *++p; - if (yych == 'R') goto yy519; - if (yych == 'r') goto yy519; - goto yy516; + if (yych == 'O') goto yy861; + if (yych != 'o') goto yy523; yy861: yych = *++p; - if (yych == 'T') goto yy879; - if (yych == 't') goto yy879; - goto yy516; + if (yych == 'J') goto yy862; + if (yych != 'j') goto yy523; yy862: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; + if (yych == 'E') goto yy863; + if (yych != 'e') goto yy523; yy863: yych = *++p; - if (yych == 'M') goto yy519; - if (yych == 'm') goto yy519; - goto yy516; + if (yych == 'C') goto yy864; + if (yych != 'c') goto yy523; yy864: yych = *++p; - if (yych <= 'S') { - if (yych == 'P') goto yy519; - if (yych <= 'R') goto yy516; - goto yy519; - } else { - if (yych <= 'p') { - if (yych <= 'o') goto yy516; - goto yy519; - } else { - if (yych == 's') goto yy519; - goto yy516; - } - } + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; yy865: yych = *++p; - if (yych == 'I') goto yy873; - if (yych == 'i') goto yy873; - goto yy516; + if (yych == 'L') goto yy866; + if (yych != 'l') goto yy523; yy866: yych = *++p; - if (yych == 'A') goto yy872; - if (yych == 'a') goto yy872; - goto yy516; + if (yych == 'K') goto yy533; + if (yych == 'k') goto yy533; + goto yy523; yy867: yych = *++p; - if (yych == 'O') goto yy870; - if (yych == 'o') goto yy870; - goto yy516; + if (yych <= 'S') { + if (yych <= 'M') { + if (yych == 'L') goto yy877; + goto yy523; + } else { + if (yych <= 'N') goto yy878; + if (yych <= 'R') goto yy523; + goto yy879; + } + } else { + if (yych <= 'm') { + if (yych == 'l') goto yy877; + goto yy523; + } else { + if (yych <= 'n') goto yy878; + if (yych == 's') goto yy879; + goto yy523; + } + } yy868: yych = *++p; - if (yych == 'A') goto yy869; - if (yych != 'a') goto yy516; + if (yych == 'E') goto yy876; + if (yych == 'e') goto yy876; + goto yy523; yy869: yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy520; - goto yy516; - } else { - if (yych <= 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; - } + if (yych == 'C') goto yy871; + if (yych == 'c') goto yy871; + goto yy523; yy870: yych = *++p; - if (yych == 'U') goto yy871; - if (yych != 'u') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy871: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; + if (yych == 'E') goto yy872; + if (yych != 'e') goto yy523; yy872: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'T') goto yy873; + if (yych != 't') goto yy523; yy873: yych = *++p; - if (yych == 'U') goto yy874; - if (yych != 'u') goto yy516; + if (yych == 'I') goto yy874; + if (yych != 'i') goto yy523; yy874: yych = *++p; if (yych == 'M') goto yy875; - if (yych != 'm') goto yy516; + if (yych != 'm') goto yy523; yy875: yych = *++p; - if (yych == 'X') goto yy876; - if (yych != 'x') goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy876: yych = *++p; - if (yych == 'T') goto yy877; - if (yych != 't') goto yy516; + if (yych == 'D') goto yy533; + if (yych == 'd') goto yy533; + goto yy523; yy877: yych = *++p; - if (yych == 'R') goto yy878; - if (yych != 'r') goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy878: yych = *++p; - if (yych == 'A') goto yy519; - if (yych == 'a') goto yy519; - goto yy516; + if (yych == 'G') goto yy880; + if (yych == 'g') goto yy880; + goto yy523; yy879: yych = *++p; - if (yych == 'A') goto yy880; - if (yych != 'a') goto yy516; + if (yych == 'H') goto yy533; + if (yych == 'h') goto yy533; + goto yy523; yy880: yych = *++p; - if (yych == 'C') goto yy881; - if (yych != 'c') goto yy516; + if (yych == 'E') goto yy881; + if (yych != 'e') goto yy523; yy881: yych = *++p; - if (yych == 'H') goto yy882; - if (yych != 'h') goto yy516; + if (yych == 'R') goto yy533; + if (yych == 'r') goto yy533; + goto yy523; yy882: yych = *++p; - if (yych == 'M') goto yy883; - if (yych != 'm') goto yy516; + if (yych == 'T') goto yy900; + if (yych == 't') goto yy900; + goto yy523; yy883: yych = *++p; - if (yych == 'E') goto yy884; - if (yych != 'e') goto yy516; + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; yy884: yych = *++p; - if (yych == 'N') goto yy885; - if (yych != 'n') goto yy516; + if (yych == 'M') goto yy533; + if (yych == 'm') goto yy533; + goto yy523; yy885: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; -yy886: - yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; -yy887: - yych = *++p; - if (yych <= 'V') { - if (yych == 'R') goto yy519; - if (yych <= 'U') goto yy516; + if (yych <= 'S') { + if (yych == 'P') goto yy533; + if (yych <= 'R') goto yy523; + goto yy533; } else { - if (yych <= 'r') { - if (yych <= 'q') goto yy516; - goto yy519; + if (yych <= 'p') { + if (yych <= 'o') goto yy523; + goto yy533; } else { - if (yych != 'v') goto yy516; + if (yych == 's') goto yy533; + goto yy523; } } +yy886: + yych = *++p; + if (yych == 'I') goto yy894; + if (yych == 'i') goto yy894; + goto yy523; +yy887: yych = *++p; - if (yych == 'A') goto yy889; - if (yych != 'a') goto yy516; + if (yych == 'A') goto yy893; + if (yych == 'a') goto yy893; + goto yy523; +yy888: + yych = *++p; + if (yych == 'O') goto yy891; + if (yych == 'o') goto yy891; + goto yy523; yy889: yych = *++p; - if (yych == 'S') goto yy890; - if (yych != 's') goto yy516; + if (yych == 'A') goto yy890; + if (yych != 'a') goto yy523; yy890: yych = *++p; - if (yych == 'C') goto yy891; - if (yych != 'c') goto yy516; + if (yych <= 'R') { + if (yych == ':') goto yy534; + goto yy523; + } else { + if (yych <= 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; + } yy891: yych = *++p; - if (yych == 'R') goto yy892; - if (yych != 'r') goto yy516; + if (yych == 'U') goto yy892; + if (yych != 'u') goto yy523; yy892: yych = *++p; - if (yych == 'I') goto yy893; - if (yych != 'i') goto yy516; + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; yy893: yych = *++p; - if (yych == 'P') goto yy894; - if (yych != 'p') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy894: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; + if (yych == 'U') goto yy895; + if (yych != 'u') goto yy523; yy895: yych = *++p; - if (yych == 'B') goto yy519; - if (yych == 'b') goto yy519; - goto yy516; + if (yych == 'M') goto yy896; + if (yych != 'm') goto yy523; yy896: yych = *++p; - if (yych == 'N') goto yy519; - if (yych == 'n') goto yy519; - goto yy516; + if (yych == 'X') goto yy897; + if (yych != 'x') goto yy523; yy897: yych = *++p; - if (yych == 'N') goto yy904; - if (yych == 'n') goto yy904; - goto yy516; + if (yych == 'T') goto yy898; + if (yych != 't') goto yy523; yy898: yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; + if (yych == 'R') goto yy899; + if (yych != 'r') goto yy523; yy899: yych = *++p; - if (yych == 'C') goto yy903; - if (yych == 'c') goto yy903; - goto yy516; + if (yych == 'A') goto yy533; + if (yych == 'a') goto yy533; + goto yy523; yy900: yych = *++p; - if (yych <= 'V') { - if (yych == 'T') goto yy902; - if (yych <= 'U') goto yy516; - goto yy519; - } else { - if (yych <= 't') { - if (yych <= 's') goto yy516; - goto yy902; - } else { - if (yych == 'v') goto yy519; - goto yy516; - } - } + if (yych == 'A') goto yy901; + if (yych != 'a') goto yy523; yy901: yych = *++p; - if (yych == 'I') goto yy519; - if (yych == 'i') goto yy519; - goto yy516; + if (yych == 'C') goto yy902; + if (yych != 'c') goto yy523; yy902: yych = *++p; - if (yych == 'A') goto yy519; - if (yych == 'a') goto yy519; - goto yy516; + if (yych == 'H') goto yy903; + if (yych != 'h') goto yy523; yy903: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; + if (yych == 'M') goto yy904; + if (yych != 'm') goto yy523; yy904: yych = *++p; - if (yych == 'A') goto yy905; - if (yych != 'a') goto yy516; + if (yych == 'E') goto yy905; + if (yych != 'e') goto yy523; yy905: yych = *++p; - if (yych != '-') goto yy516; + if (yych == 'N') goto yy906; + if (yych != 'n') goto yy523; +yy906: yych = *++p; - if (yych == 'P') goto yy907; - if (yych != 'p') goto yy516; + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; yy907: yych = *++p; - if (yych == 'L') goto yy908; - if (yych != 'l') goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy908: yych = *++p; - if (yych == 'A') goto yy909; - if (yych != 'a') goto yy516; -yy909: - yych = *++p; - if (yych == 'Y') goto yy910; - if (yych != 'y') goto yy516; -yy910: - yych = *++p; - if (yych <= 'S') { - if (yych == 'C') goto yy911; - if (yych <= 'R') goto yy516; - goto yy912; + if (yych <= 'V') { + if (yych == 'R') goto yy533; + if (yych <= 'U') goto yy523; } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy516; + if (yych <= 'r') { + if (yych <= 'q') goto yy523; + goto yy533; } else { - if (yych == 's') goto yy912; - goto yy516; + if (yych != 'v') goto yy523; } } + yych = *++p; + if (yych == 'A') goto yy910; + if (yych != 'a') goto yy523; +yy910: + yych = *++p; + if (yych == 'S') goto yy911; + if (yych != 's') goto yy523; yy911: yych = *++p; - if (yych == 'O') goto yy917; - if (yych == 'o') goto yy917; - goto yy516; + if (yych == 'C') goto yy912; + if (yych != 'c') goto yy523; yy912: yych = *++p; - if (yych == 'I') goto yy913; - if (yych != 'i') goto yy516; + if (yych == 'R') goto yy913; + if (yych != 'r') goto yy523; yy913: yych = *++p; - if (yych == 'N') goto yy914; - if (yych != 'n') goto yy516; + if (yych == 'I') goto yy914; + if (yych != 'i') goto yy523; yy914: yych = *++p; - if (yych == 'G') goto yy915; - if (yych != 'g') goto yy516; + if (yych == 'P') goto yy915; + if (yych != 'p') goto yy523; yy915: yych = *++p; - if (yych == 'L') goto yy916; - if (yych != 'l') goto yy516; + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; yy916: yych = *++p; - if (yych == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; + if (yych == 'B') goto yy533; + if (yych == 'b') goto yy533; + goto yy523; yy917: yych = *++p; - if (yych == 'N') goto yy918; - if (yych != 'n') goto yy516; + if (yych == 'N') goto yy533; + if (yych == 'n') goto yy533; + goto yy523; yy918: yych = *++p; - if (yych == 'T') goto yy919; - if (yych != 't') goto yy516; + if (yych == 'N') goto yy925; + if (yych == 'n') goto yy925; + goto yy523; yy919: yych = *++p; - if (yych == 'A') goto yy920; - if (yych != 'a') goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy920: yych = *++p; - if (yych == 'I') goto yy921; - if (yych != 'i') goto yy516; + if (yych == 'C') goto yy924; + if (yych == 'c') goto yy924; + goto yy523; yy921: yych = *++p; - if (yych == 'N') goto yy922; - if (yych != 'n') goto yy516; + if (yych <= 'V') { + if (yych == 'T') goto yy923; + if (yych <= 'U') goto yy523; + goto yy533; + } else { + if (yych <= 't') { + if (yych <= 's') goto yy523; + goto yy923; + } else { + if (yych == 'v') goto yy533; + goto yy523; + } + } yy922: yych = *++p; - if (yych == 'E') goto yy923; - if (yych != 'e') goto yy516; + if (yych == 'I') goto yy533; + if (yych == 'i') goto yy533; + goto yy523; yy923: yych = *++p; - if (yych == 'R') goto yy519; - if (yych == 'r') goto yy519; - goto yy516; + if (yych == 'A') goto yy533; + if (yych == 'a') goto yy533; + goto yy523; yy924: yych = *++p; - if (yych == 'S') goto yy519; - if (yych == 's') goto yy519; - goto yy516; + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; yy925: yych = *++p; - if (yych <= 'N') { - if (yych <= 'A') { - if (yych <= '@') goto yy516; - goto yy947; - } else { - if (yych <= 'L') goto yy516; - if (yych <= 'M') goto yy948; - goto yy949; - } - } else { - if (yych <= 'l') { - if (yych == 'a') goto yy947; - goto yy516; - } else { - if (yych <= 'm') goto yy948; - if (yych <= 'n') goto yy949; - goto yy516; - } - } + if (yych == 'A') goto yy926; + if (yych != 'a') goto yy523; yy926: yych = *++p; - if (yych == 'R') goto yy934; - if (yych == 'r') goto yy934; - goto yy516; -yy927: + if (yych != '-') goto yy523; yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy931; - if (yych <= 'O') goto yy516; - goto yy519; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy516; - goto yy931; - } else { - if (yych == 'p') goto yy519; - goto yy516; - } - } + if (yych == 'P') goto yy928; + if (yych != 'p') goto yy523; yy928: yych = *++p; - if (yych == 'I') goto yy930; - if (yych == 'i') goto yy930; - goto yy516; + if (yych == 'L') goto yy929; + if (yych != 'l') goto yy523; yy929: yych = *++p; - if (yych == 'D') goto yy519; - if (yych == 'd') goto yy519; - goto yy516; + if (yych == 'A') goto yy930; + if (yych != 'a') goto yy523; yy930: yych = *++p; - if (yych == 'D') goto yy519; - if (yych == 'd') goto yy519; - goto yy516; + if (yych == 'Y') goto yy931; + if (yych != 'y') goto yy523; yy931: yych = *++p; - if (yych == 'L') goto yy932; - if (yych != 'l') goto yy516; + if (yych <= 'S') { + if (yych == 'C') goto yy932; + if (yych <= 'R') goto yy523; + goto yy933; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy523; + } else { + if (yych == 's') goto yy933; + goto yy523; + } + } yy932: yych = *++p; - if (yych == 'T') goto yy933; - if (yych != 't') goto yy516; + if (yych == 'O') goto yy938; + if (yych == 'o') goto yy938; + goto yy523; yy933: yych = *++p; - if (yych == 'O') goto yy519; - if (yych == 'o') goto yy519; - goto yy516; + if (yych == 'I') goto yy934; + if (yych != 'i') goto yy523; yy934: yych = *++p; - if (yych == 'O') goto yy935; - if (yych != 'o') goto yy516; + if (yych == 'N') goto yy935; + if (yych != 'n') goto yy523; yy935: yych = *++p; - if (yych == 'M') goto yy936; - if (yych != 'm') goto yy516; + if (yych == 'G') goto yy936; + if (yych != 'g') goto yy523; yy936: yych = *++p; - if (yych == 'E') goto yy937; - if (yych != 'e') goto yy516; + if (yych == 'L') goto yy937; + if (yych != 'l') goto yy523; yy937: yych = *++p; - if (yych == '-') goto yy938; - if (yych == ':') goto yy520; - goto yy516; + if (yych == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; yy938: yych = *++p; - if (yych == 'E') goto yy939; - if (yych != 'e') goto yy516; + if (yych == 'N') goto yy939; + if (yych != 'n') goto yy523; yy939: yych = *++p; - if (yych == 'X') goto yy940; - if (yych != 'x') goto yy516; + if (yych == 'T') goto yy940; + if (yych != 't') goto yy523; yy940: yych = *++p; - if (yych == 'T') goto yy941; - if (yych != 't') goto yy516; + if (yych == 'A') goto yy941; + if (yych != 'a') goto yy523; yy941: yych = *++p; - if (yych == 'E') goto yy942; - if (yych != 'e') goto yy516; + if (yych == 'I') goto yy942; + if (yych != 'i') goto yy523; yy942: yych = *++p; if (yych == 'N') goto yy943; - if (yych != 'n') goto yy516; + if (yych != 'n') goto yy523; yy943: yych = *++p; - if (yych == 'S') goto yy944; - if (yych != 's') goto yy516; + if (yych == 'E') goto yy944; + if (yych != 'e') goto yy523; yy944: yych = *++p; - if (yych == 'I') goto yy945; - if (yych != 'i') goto yy516; + if (yych == 'R') goto yy533; + if (yych == 'r') goto yy533; + goto yy523; yy945: yych = *++p; - if (yych == 'O') goto yy946; - if (yych != 'o') goto yy516; + if (yych == 'S') goto yy533; + if (yych == 's') goto yy533; + goto yy523; yy946: yych = *++p; - if (yych == 'N') goto yy519; - if (yych == 'n') goto yy519; - goto yy516; + if (yych <= 'N') { + if (yych <= 'A') { + if (yych <= '@') goto yy523; + goto yy968; + } else { + if (yych <= 'L') goto yy523; + if (yych <= 'M') goto yy969; + goto yy970; + } + } else { + if (yych <= 'l') { + if (yych == 'a') goto yy968; + goto yy523; + } else { + if (yych <= 'm') goto yy969; + if (yych <= 'n') goto yy970; + goto yy523; + } + } yy947: yych = *++p; - if (yych == 'P') goto yy519; - if (yych == 'p') goto yy519; - goto yy516; + if (yych == 'R') goto yy955; + if (yych == 'r') goto yy955; + goto yy523; yy948: yych = *++p; - if (yych == '-') goto yy953; - goto yy516; + if (yych <= 'P') { + if (yych == 'L') goto yy952; + if (yych <= 'O') goto yy523; + goto yy533; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy523; + goto yy952; + } else { + if (yych == 'p') goto yy533; + goto yy523; + } + } yy949: yych = *++p; - if (yych == 'T') goto yy950; - if (yych != 't') goto yy516; + if (yych == 'I') goto yy951; + if (yych == 'i') goto yy951; + goto yy523; yy950: yych = *++p; - if (yych == 'E') goto yy951; - if (yych != 'e') goto yy516; + if (yych == 'D') goto yy533; + if (yych == 'd') goto yy533; + goto yy523; yy951: yych = *++p; - if (yych == 'N') goto yy952; - if (yych != 'n') goto yy516; + if (yych == 'D') goto yy533; + if (yych == 'd') goto yy533; + goto yy523; yy952: yych = *++p; - if (yych == 'T') goto yy519; - if (yych == 't') goto yy519; - goto yy516; + if (yych == 'L') goto yy953; + if (yych != 'l') goto yy523; yy953: yych = *++p; - if (yych == 'E') goto yy954; - if (yych != 'e') goto yy516; + if (yych == 'T') goto yy954; + if (yych != 't') goto yy523; yy954: yych = *++p; - if (yych == 'V') goto yy955; - if (yych != 'v') goto yy516; + if (yych == 'O') goto yy533; + if (yych == 'o') goto yy533; + goto yy523; yy955: yych = *++p; - if (yych == 'E') goto yy956; - if (yych != 'e') goto yy516; + if (yych == 'O') goto yy956; + if (yych != 'o') goto yy523; yy956: yych = *++p; - if (yych == 'N') goto yy957; - if (yych != 'n') goto yy516; + if (yych == 'M') goto yy957; + if (yych != 'm') goto yy523; yy957: yych = *++p; - if (yych == 'T') goto yy958; - if (yych != 't') goto yy516; + if (yych == 'E') goto yy958; + if (yych != 'e') goto yy523; yy958: yych = *++p; - if (yych == 'B') goto yy959; - if (yych != 'b') goto yy516; + if (yych == '-') goto yy959; + if (yych == ':') goto yy534; + goto yy523; yy959: yych = *++p; - if (yych == 'R') goto yy960; - if (yych != 'r') goto yy516; + if (yych == 'E') goto yy960; + if (yych != 'e') goto yy523; yy960: yych = *++p; - if (yych == 'I') goto yy961; - if (yych != 'i') goto yy516; + if (yych == 'X') goto yy961; + if (yych != 'x') goto yy523; yy961: yych = *++p; if (yych == 'T') goto yy962; - if (yych != 't') goto yy516; + if (yych != 't') goto yy523; yy962: yych = *++p; if (yych == 'E') goto yy963; - if (yych != 'e') goto yy516; + if (yych != 'e') goto yy523; yy963: yych = *++p; - if (yych != '-') goto yy516; + if (yych == 'N') goto yy964; + if (yych != 'n') goto yy523; +yy964: yych = *++p; - if (yych == 'A') goto yy965; - if (yych != 'a') goto yy516; + if (yych == 'S') goto yy965; + if (yych != 's') goto yy523; yy965: yych = *++p; - if (yych == 'T') goto yy966; - if (yych != 't') goto yy516; + if (yych == 'I') goto yy966; + if (yych != 'i') goto yy523; yy966: yych = *++p; - if (yych == 'T') goto yy967; - if (yych != 't') goto yy516; + if (yych == 'O') goto yy967; + if (yych != 'o') goto yy523; yy967: yych = *++p; - if (yych == 'E') goto yy968; - if (yych != 'e') goto yy516; + if (yych == 'N') goto yy533; + if (yych == 'n') goto yy533; + goto yy523; yy968: yych = *++p; - if (yych == 'N') goto yy969; - if (yych != 'n') goto yy516; + if (yych == 'P') goto yy533; + if (yych == 'p') goto yy533; + goto yy523; yy969: yych = *++p; - if (yych == 'D') goto yy970; - if (yych != 'd') goto yy516; + if (yych == '-') goto yy974; + goto yy523; yy970: yych = *++p; - if (yych == 'E') goto yy971; - if (yych != 'e') goto yy516; + if (yych == 'T') goto yy971; + if (yych != 't') goto yy523; yy971: - ++p; - if ((yych = *p) == 'E') goto yy519; - if (yych == 'e') goto yy519; - goto yy516; -} - -} - -// Try to match email autolink after first <, returning num of chars matched. -bufsize_t _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[] = { + yych = *++p; + if (yych == 'E') goto yy972; + if (yych != 'e') goto yy523; +yy972: + yych = *++p; + if (yych == 'N') goto yy973; + if (yych != 'n') goto yy523; +yy973: + yych = *++p; + if (yych == 'T') goto yy533; + if (yych == 't') goto yy533; + goto yy523; +yy974: + yych = *++p; + if (yych == 'E') goto yy975; + if (yych != 'e') goto yy523; +yy975: + yych = *++p; + if (yych == 'V') goto yy976; + if (yych != 'v') goto yy523; +yy976: + yych = *++p; + if (yych == 'E') goto yy977; + if (yych != 'e') goto yy523; +yy977: + yych = *++p; + if (yych == 'N') goto yy978; + if (yych != 'n') goto yy523; +yy978: + yych = *++p; + if (yych == 'T') goto yy979; + if (yych != 't') goto yy523; +yy979: + yych = *++p; + if (yych == 'B') goto yy980; + if (yych != 'b') goto yy523; +yy980: + yych = *++p; + if (yych == 'R') goto yy981; + if (yych != 'r') goto yy523; +yy981: + yych = *++p; + if (yych == 'I') goto yy982; + if (yych != 'i') goto yy523; +yy982: + yych = *++p; + if (yych == 'T') goto yy983; + if (yych != 't') goto yy523; +yy983: + yych = *++p; + if (yych == 'E') goto yy984; + if (yych != 'e') goto yy523; +yy984: + yych = *++p; + if (yych != '-') goto yy523; + yych = *++p; + if (yych == 'A') goto yy986; + if (yych != 'a') goto yy523; +yy986: + yych = *++p; + if (yych == 'T') goto yy987; + if (yych != 't') goto yy523; +yy987: + yych = *++p; + if (yych == 'T') goto yy988; + if (yych != 't') goto yy523; +yy988: + yych = *++p; + if (yych == 'E') goto yy989; + if (yych != 'e') goto yy523; +yy989: + yych = *++p; + if (yych == 'N') goto yy990; + if (yych != 'n') goto yy523; +yy990: + yych = *++p; + if (yych == 'D') goto yy991; + if (yych != 'd') goto yy523; +yy991: + yych = *++p; + if (yych == 'E') goto yy992; + if (yych != 'e') goto yy523; +yy992: + ++p; + if ((yych = *p) == 'E') goto yy533; + if (yych == 'e') goto yy533; + goto yy523; +} + +} + +// Try to match email autolink after first <, returning num of chars matched. +bufsize_t _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, @@ -5899,4903 +6154,4947 @@ bufsize_t _scan_autolink_email(const unsigned char *p) 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 yy974; - if (yych <= ' ') goto yy976; - goto yy975; + yych = *(marker = p); + if (yych <= '?') { + if (yych <= ')') { + if (yych <= ' ') { + if (yych != '\n') goto yy997; + } else { + if (yych == '"') goto yy997; + if (yych <= '\'') goto yy996; + goto yy997; + } } else { - if (yych <= '\'') { - if (yych <= '"') goto yy976; - goto yy975; + if (yych <= '9') { + if (yych == ',') goto yy997; + goto yy996; } else { - if (yych <= ')') goto yy976; - if (yych <= '+') goto yy975; - goto yy976; + if (yych == '=') goto yy996; + if (yych <= '>') goto yy997; + goto yy996; } } } else { - if (yych <= '?') { - if (yych <= '<') { - if (yych <= '9') goto yy975; - goto yy976; + if (yych <= 0xDF) { + if (yych <= ']') { + if (yych <= '@') goto yy997; + if (yych <= 'Z') goto yy996; + goto yy997; } else { - if (yych == '>') goto yy976; - goto yy975; + if (yych <= '~') goto yy996; + if (yych <= 0x7F) goto yy997; + if (yych >= 0xC2) goto yy998; } } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy976; - goto yy975; + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1000; + if (yych == 0xED) goto yy1005; + goto yy1001; } else { - if (yych <= ']') goto yy976; - if (yych <= '~') goto yy975; - goto yy976; + if (yych <= 0xF0) goto yy1002; + if (yych <= 0xF3) goto yy1003; + if (yych <= 0xF4) goto yy1004; } } } -yy974: +yy995: { return 0; } -yy975: +yy996: yych = *(marker = ++p); if (yych <= ',') { if (yych <= '"') { - if (yych == '!') goto yy980; - goto yy974; + if (yych == '!') goto yy1008; + goto yy995; } else { - if (yych <= '\'') goto yy980; - if (yych <= ')') goto yy974; - if (yych <= '+') goto yy980; - goto yy974; + if (yych <= '\'') goto yy1008; + if (yych <= ')') goto yy995; + if (yych <= '+') goto yy1008; + goto yy995; } } else { if (yych <= '>') { - if (yych <= '9') goto yy980; - if (yych == '=') goto yy980; - goto yy974; + if (yych <= '9') goto yy1008; + if (yych == '=') goto yy1008; + goto yy995; } else { - if (yych <= 'Z') goto yy980; - if (yych <= ']') goto yy974; - if (yych <= '~') goto yy980; - goto yy974; + if (yych <= 'Z') goto yy1008; + if (yych <= ']') goto yy995; + if (yych <= '~') goto yy1008; + goto yy995; } } -yy976: +yy997: yych = *++p; - goto yy974; -yy977: + goto yy995; +yy998: + yych = *++p; + if (yych <= 0x7F) goto yy999; + if (yych <= 0xBF) goto yy997; +yy999: + p = marker; + goto yy995; +yy1000: + yych = *++p; + if (yych <= 0x9F) goto yy999; + if (yych <= 0xBF) goto yy998; + goto yy999; +yy1001: + yych = *++p; + if (yych <= 0x7F) goto yy999; + if (yych <= 0xBF) goto yy998; + goto yy999; +yy1002: + yych = *++p; + if (yych <= 0x8F) goto yy999; + if (yych <= 0xBF) goto yy1001; + goto yy999; +yy1003: + yych = *++p; + if (yych <= 0x7F) goto yy999; + if (yych <= 0xBF) goto yy1001; + goto yy999; +yy1004: + yych = *++p; + if (yych <= 0x7F) goto yy999; + if (yych <= 0x8F) goto yy1001; + goto yy999; +yy1005: + yych = *++p; + if (yych <= 0x7F) goto yy999; + if (yych <= 0x9F) goto yy998; + goto yy999; +yy1006: yych = *++p; if (yych <= '@') { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy981; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1009; + goto yy999; } else { - if (yych <= 'Z') goto yy981; - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy981; + if (yych <= 'Z') goto yy1009; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1009; + goto yy999; } -yy978: - p = marker; - goto yy974; -yy979: +yy1007: ++p; yych = *p; -yy980: +yy1008: if (yybm[0+yych] & 128) { - goto yy979; + goto yy1007; } - if (yych == '@') goto yy977; - goto yy978; -yy981: + if (yych <= '>') goto yy999; + if (yych <= '@') goto yy1006; + goto yy999; +yy1009: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy983; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1011; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy983; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1011; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy983; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1011; + goto yy999; } } yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1111; - if (yych <= '/') goto yy978; - goto yy1112; + if (yych == '-') goto yy1139; + if (yych <= '/') goto yy999; + goto yy1140; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1112; + if (yych <= '@') goto yy999; + goto yy1140; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1112; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1140; + goto yy999; } } -yy983: +yy1011: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych <= '-') goto yy1111; + if (yych <= ',') goto yy999; + if (yych <= '-') goto yy1139; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1112; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1140; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1112; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1140; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1112; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1140; + goto yy999; } } -yy984: +yy1012: ++p; yych = *p; if (yych <= '@') { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy987; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1015; + goto yy999; } else { - if (yych <= 'Z') goto yy987; - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy987; - goto yy978; + if (yych <= 'Z') goto yy1015; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1015; + goto yy999; } -yy985: +yy1013: ++p; { return (bufsize_t)(p - start); } -yy987: +yy1015: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy989; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1017; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy989; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1017; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy989; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1017; + goto yy999; } } ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy990; - if (yych <= '/') goto yy978; - goto yy991; + if (yych == '-') goto yy1018; + if (yych <= '/') goto yy999; + goto yy1019; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy991; + if (yych <= '@') goto yy999; + goto yy1019; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy991; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1019; + goto yy999; } } -yy989: +yy1017: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy991; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1019; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy991; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1019; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy991; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1019; + goto yy999; } } -yy990: +yy1018: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy992; - if (yych <= '/') goto yy978; - goto yy993; + if (yych == '-') goto yy1020; + if (yych <= '/') goto yy999; + goto yy1021; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy993; + if (yych <= '@') goto yy999; + goto yy1021; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy993; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1021; + goto yy999; } } -yy991: +yy1019: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy993; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1021; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy993; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1021; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy993; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1021; + goto yy999; } } -yy992: +yy1020: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy994; - if (yych <= '/') goto yy978; - goto yy995; + if (yych == '-') goto yy1022; + if (yych <= '/') goto yy999; + goto yy1023; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy995; + if (yych <= '@') goto yy999; + goto yy1023; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy995; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1023; + goto yy999; } } -yy993: +yy1021: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy995; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1023; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy995; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1023; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy995; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1023; + goto yy999; } } -yy994: +yy1022: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy996; - if (yych <= '/') goto yy978; - goto yy997; + if (yych == '-') goto yy1024; + if (yych <= '/') goto yy999; + goto yy1025; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy997; + if (yych <= '@') goto yy999; + goto yy1025; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy997; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1025; + goto yy999; } } -yy995: +yy1023: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy997; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1025; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy997; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1025; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy997; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1025; + goto yy999; } } -yy996: +yy1024: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy998; - if (yych <= '/') goto yy978; - goto yy999; + if (yych == '-') goto yy1026; + if (yych <= '/') goto yy999; + goto yy1027; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy999; + if (yych <= '@') goto yy999; + goto yy1027; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy999; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1027; + goto yy999; } } -yy997: +yy1025: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy999; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1027; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy999; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1027; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy999; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1027; + goto yy999; } } -yy998: +yy1026: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1000; - if (yych <= '/') goto yy978; - goto yy1001; + if (yych == '-') goto yy1028; + if (yych <= '/') goto yy999; + goto yy1029; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1001; + if (yych <= '@') goto yy999; + goto yy1029; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1001; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1029; + goto yy999; } } -yy999: +yy1027: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1001; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1029; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1001; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1029; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1001; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1029; + goto yy999; } } -yy1000: +yy1028: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1002; - if (yych <= '/') goto yy978; - goto yy1003; + if (yych == '-') goto yy1030; + if (yych <= '/') goto yy999; + goto yy1031; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1003; + if (yych <= '@') goto yy999; + goto yy1031; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1003; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1031; + goto yy999; } } -yy1001: +yy1029: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1003; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1031; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1003; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1031; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1003; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1031; + goto yy999; } } -yy1002: +yy1030: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1004; - if (yych <= '/') goto yy978; - goto yy1005; + if (yych == '-') goto yy1032; + if (yych <= '/') goto yy999; + goto yy1033; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1005; + if (yych <= '@') goto yy999; + goto yy1033; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1005; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1033; + goto yy999; } } -yy1003: +yy1031: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1005; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1033; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1005; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1033; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1005; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1033; + goto yy999; } } -yy1004: +yy1032: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1006; - if (yych <= '/') goto yy978; - goto yy1007; + if (yych == '-') goto yy1034; + if (yych <= '/') goto yy999; + goto yy1035; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1007; + if (yych <= '@') goto yy999; + goto yy1035; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1007; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1035; + goto yy999; } } -yy1005: +yy1033: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1007; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1035; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1007; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1035; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1007; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1035; + goto yy999; } } -yy1006: +yy1034: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1008; - if (yych <= '/') goto yy978; - goto yy1009; + if (yych == '-') goto yy1036; + if (yych <= '/') goto yy999; + goto yy1037; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1009; + if (yych <= '@') goto yy999; + goto yy1037; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1009; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1037; + goto yy999; } } -yy1007: +yy1035: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1009; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1037; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1009; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1037; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1009; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1037; + goto yy999; } } -yy1008: +yy1036: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1010; - if (yych <= '/') goto yy978; - goto yy1011; + if (yych == '-') goto yy1038; + if (yych <= '/') goto yy999; + goto yy1039; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1011; + if (yych <= '@') goto yy999; + goto yy1039; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1011; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1039; + goto yy999; } } -yy1009: +yy1037: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1011; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1039; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1011; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1039; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1011; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1039; + goto yy999; } } -yy1010: +yy1038: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1012; - if (yych <= '/') goto yy978; - goto yy1013; + if (yych == '-') goto yy1040; + if (yych <= '/') goto yy999; + goto yy1041; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1013; + if (yych <= '@') goto yy999; + goto yy1041; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1013; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1041; + goto yy999; } } -yy1011: +yy1039: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1013; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1041; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1013; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1041; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1013; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1041; + goto yy999; } } -yy1012: +yy1040: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1014; - if (yych <= '/') goto yy978; - goto yy1015; + if (yych == '-') goto yy1042; + if (yych <= '/') goto yy999; + goto yy1043; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1015; + if (yych <= '@') goto yy999; + goto yy1043; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1015; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1043; + goto yy999; } } -yy1013: +yy1041: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1015; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1043; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1015; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1043; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1015; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1043; + goto yy999; } } -yy1014: +yy1042: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1016; - if (yych <= '/') goto yy978; - goto yy1017; + if (yych == '-') goto yy1044; + if (yych <= '/') goto yy999; + goto yy1045; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1017; + if (yych <= '@') goto yy999; + goto yy1045; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1017; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1045; + goto yy999; } } -yy1015: +yy1043: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1017; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1045; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1017; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1045; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1017; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1045; + goto yy999; } } -yy1016: +yy1044: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1018; - if (yych <= '/') goto yy978; - goto yy1019; + if (yych == '-') goto yy1046; + if (yych <= '/') goto yy999; + goto yy1047; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1019; + if (yych <= '@') goto yy999; + goto yy1047; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1019; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1047; + goto yy999; } } -yy1017: +yy1045: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1019; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1047; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1019; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1047; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1019; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1047; + goto yy999; } } -yy1018: +yy1046: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1020; - if (yych <= '/') goto yy978; - goto yy1021; + if (yych == '-') goto yy1048; + if (yych <= '/') goto yy999; + goto yy1049; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1021; + if (yych <= '@') goto yy999; + goto yy1049; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1021; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1049; + goto yy999; } } -yy1019: +yy1047: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1021; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1049; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1021; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1049; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1021; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1049; + goto yy999; } } -yy1020: +yy1048: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1022; - if (yych <= '/') goto yy978; - goto yy1023; + if (yych == '-') goto yy1050; + if (yych <= '/') goto yy999; + goto yy1051; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1023; + if (yych <= '@') goto yy999; + goto yy1051; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1023; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1051; + goto yy999; } } -yy1021: +yy1049: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1023; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1051; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1023; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1051; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1023; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1051; + goto yy999; } } -yy1022: +yy1050: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1024; - if (yych <= '/') goto yy978; - goto yy1025; + if (yych == '-') goto yy1052; + if (yych <= '/') goto yy999; + goto yy1053; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1025; + if (yych <= '@') goto yy999; + goto yy1053; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1025; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1053; + goto yy999; } } -yy1023: +yy1051: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1025; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1053; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1025; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1053; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1025; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1053; + goto yy999; } } -yy1024: +yy1052: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1026; - if (yych <= '/') goto yy978; - goto yy1027; + if (yych == '-') goto yy1054; + if (yych <= '/') goto yy999; + goto yy1055; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1027; + if (yych <= '@') goto yy999; + goto yy1055; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1027; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1055; + goto yy999; } } -yy1025: +yy1053: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1027; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1055; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1027; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1055; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1027; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1055; + goto yy999; } } -yy1026: +yy1054: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1028; - if (yych <= '/') goto yy978; - goto yy1029; + if (yych == '-') goto yy1056; + if (yych <= '/') goto yy999; + goto yy1057; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1029; + if (yych <= '@') goto yy999; + goto yy1057; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1029; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1057; + goto yy999; } } -yy1027: +yy1055: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1029; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1057; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1029; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1057; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1029; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1057; + goto yy999; } } -yy1028: +yy1056: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1030; - if (yych <= '/') goto yy978; - goto yy1031; + if (yych == '-') goto yy1058; + if (yych <= '/') goto yy999; + goto yy1059; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1031; + if (yych <= '@') goto yy999; + goto yy1059; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1031; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1059; + goto yy999; } } -yy1029: +yy1057: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1031; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1059; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1031; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1059; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1031; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1059; + goto yy999; } } -yy1030: +yy1058: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1032; - if (yych <= '/') goto yy978; - goto yy1033; + if (yych == '-') goto yy1060; + if (yych <= '/') goto yy999; + goto yy1061; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1033; + if (yych <= '@') goto yy999; + goto yy1061; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1033; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1061; + goto yy999; } } -yy1031: +yy1059: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1033; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1061; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1033; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1061; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1033; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1061; + goto yy999; } } -yy1032: +yy1060: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1034; - if (yych <= '/') goto yy978; - goto yy1035; + if (yych == '-') goto yy1062; + if (yych <= '/') goto yy999; + goto yy1063; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1035; + if (yych <= '@') goto yy999; + goto yy1063; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1035; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1063; + goto yy999; } } -yy1033: +yy1061: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1035; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1063; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1035; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1063; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1035; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1063; + goto yy999; } } -yy1034: +yy1062: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1036; - if (yych <= '/') goto yy978; - goto yy1037; + if (yych == '-') goto yy1064; + if (yych <= '/') goto yy999; + goto yy1065; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1037; + if (yych <= '@') goto yy999; + goto yy1065; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1037; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1065; + goto yy999; } } -yy1035: +yy1063: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1037; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1065; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1037; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1065; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1037; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1065; + goto yy999; } } -yy1036: +yy1064: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1038; - if (yych <= '/') goto yy978; - goto yy1039; + if (yych == '-') goto yy1066; + if (yych <= '/') goto yy999; + goto yy1067; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1039; + if (yych <= '@') goto yy999; + goto yy1067; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1039; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1067; + goto yy999; } } -yy1037: +yy1065: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1039; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1067; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1039; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1067; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1039; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1067; + goto yy999; } } -yy1038: +yy1066: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1040; - if (yych <= '/') goto yy978; - goto yy1041; + if (yych == '-') goto yy1068; + if (yych <= '/') goto yy999; + goto yy1069; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1041; + if (yych <= '@') goto yy999; + goto yy1069; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1041; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1069; + goto yy999; } } -yy1039: +yy1067: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1041; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1069; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1041; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1069; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1041; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1069; + goto yy999; } } -yy1040: +yy1068: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1042; - if (yych <= '/') goto yy978; - goto yy1043; + if (yych == '-') goto yy1070; + if (yych <= '/') goto yy999; + goto yy1071; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1043; + if (yych <= '@') goto yy999; + goto yy1071; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1043; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1071; + goto yy999; } } -yy1041: +yy1069: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1043; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1071; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1043; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1071; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1043; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1071; + goto yy999; } } -yy1042: +yy1070: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1044; - if (yych <= '/') goto yy978; - goto yy1045; + if (yych == '-') goto yy1072; + if (yych <= '/') goto yy999; + goto yy1073; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1045; + if (yych <= '@') goto yy999; + goto yy1073; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1045; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1073; + goto yy999; } } -yy1043: +yy1071: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1045; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1073; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1045; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1073; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1045; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1073; + goto yy999; } } -yy1044: +yy1072: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1046; - if (yych <= '/') goto yy978; - goto yy1047; + if (yych == '-') goto yy1074; + if (yych <= '/') goto yy999; + goto yy1075; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1047; + if (yych <= '@') goto yy999; + goto yy1075; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1047; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1075; + goto yy999; } } -yy1045: +yy1073: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1047; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1075; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1047; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1075; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1047; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1075; + goto yy999; } } -yy1046: +yy1074: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1048; - if (yych <= '/') goto yy978; - goto yy1049; + if (yych == '-') goto yy1076; + if (yych <= '/') goto yy999; + goto yy1077; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1049; + if (yych <= '@') goto yy999; + goto yy1077; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1049; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1077; + goto yy999; } } -yy1047: +yy1075: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1049; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1077; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1049; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1077; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1049; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1077; + goto yy999; } } -yy1048: +yy1076: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1050; - if (yych <= '/') goto yy978; - goto yy1051; + if (yych == '-') goto yy1078; + if (yych <= '/') goto yy999; + goto yy1079; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1051; + if (yych <= '@') goto yy999; + goto yy1079; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1051; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1079; + goto yy999; } } -yy1049: +yy1077: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1051; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1079; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1051; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1079; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1051; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1079; + goto yy999; } } -yy1050: +yy1078: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1052; - if (yych <= '/') goto yy978; - goto yy1053; + if (yych == '-') goto yy1080; + if (yych <= '/') goto yy999; + goto yy1081; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1053; + if (yych <= '@') goto yy999; + goto yy1081; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1053; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1081; + goto yy999; } } -yy1051: +yy1079: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1053; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1081; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1053; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1081; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1053; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1081; + goto yy999; } } -yy1052: +yy1080: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1054; - if (yych <= '/') goto yy978; - goto yy1055; + if (yych == '-') goto yy1082; + if (yych <= '/') goto yy999; + goto yy1083; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1055; + if (yych <= '@') goto yy999; + goto yy1083; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1055; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1083; + goto yy999; } } -yy1053: +yy1081: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1055; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1083; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1055; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1083; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1055; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1083; + goto yy999; } } -yy1054: +yy1082: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1056; - if (yych <= '/') goto yy978; - goto yy1057; + if (yych == '-') goto yy1084; + if (yych <= '/') goto yy999; + goto yy1085; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1057; + if (yych <= '@') goto yy999; + goto yy1085; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1057; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1085; + goto yy999; } } -yy1055: +yy1083: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1057; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1085; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1057; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1085; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1057; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1085; + goto yy999; } } -yy1056: +yy1084: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1058; - if (yych <= '/') goto yy978; - goto yy1059; + if (yych == '-') goto yy1086; + if (yych <= '/') goto yy999; + goto yy1087; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1059; + if (yych <= '@') goto yy999; + goto yy1087; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1059; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1087; + goto yy999; } } -yy1057: +yy1085: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1059; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1087; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1059; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1087; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1059; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1087; + goto yy999; } } -yy1058: +yy1086: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1060; - if (yych <= '/') goto yy978; - goto yy1061; + if (yych == '-') goto yy1088; + if (yych <= '/') goto yy999; + goto yy1089; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1061; + if (yych <= '@') goto yy999; + goto yy1089; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1061; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1089; + goto yy999; } } -yy1059: +yy1087: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1061; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1089; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1061; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1089; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1061; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1089; + goto yy999; } } -yy1060: +yy1088: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1062; - if (yych <= '/') goto yy978; - goto yy1063; + if (yych == '-') goto yy1090; + if (yych <= '/') goto yy999; + goto yy1091; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1063; + if (yych <= '@') goto yy999; + goto yy1091; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1063; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1091; + goto yy999; } } -yy1061: +yy1089: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1063; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1091; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1063; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1091; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1063; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1091; + goto yy999; } } -yy1062: +yy1090: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1064; - if (yych <= '/') goto yy978; - goto yy1065; + if (yych == '-') goto yy1092; + if (yych <= '/') goto yy999; + goto yy1093; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1065; + if (yych <= '@') goto yy999; + goto yy1093; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1065; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1093; + goto yy999; } } -yy1063: +yy1091: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1065; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1093; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1065; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1093; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1065; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1093; + goto yy999; } } -yy1064: +yy1092: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1066; - if (yych <= '/') goto yy978; - goto yy1067; + if (yych == '-') goto yy1094; + if (yych <= '/') goto yy999; + goto yy1095; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1067; + if (yych <= '@') goto yy999; + goto yy1095; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1067; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1095; + goto yy999; } } -yy1065: +yy1093: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1067; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1095; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1067; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1095; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1067; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1095; + goto yy999; } } -yy1066: +yy1094: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1068; - if (yych <= '/') goto yy978; - goto yy1069; + if (yych == '-') goto yy1096; + if (yych <= '/') goto yy999; + goto yy1097; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1069; + if (yych <= '@') goto yy999; + goto yy1097; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1069; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1097; + goto yy999; } } -yy1067: +yy1095: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1069; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1097; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1069; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1097; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1069; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1097; + goto yy999; } } -yy1068: +yy1096: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1070; - if (yych <= '/') goto yy978; - goto yy1071; + if (yych == '-') goto yy1098; + if (yych <= '/') goto yy999; + goto yy1099; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1071; + if (yych <= '@') goto yy999; + goto yy1099; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1071; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1099; + goto yy999; } } -yy1069: +yy1097: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1071; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1099; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1071; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1099; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1071; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1099; + goto yy999; } } -yy1070: +yy1098: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1072; - if (yych <= '/') goto yy978; - goto yy1073; + if (yych == '-') goto yy1100; + if (yych <= '/') goto yy999; + goto yy1101; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1073; + if (yych <= '@') goto yy999; + goto yy1101; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1073; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1101; + goto yy999; } } -yy1071: +yy1099: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1073; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1101; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1073; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1101; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1073; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1101; + goto yy999; } } -yy1072: +yy1100: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1074; - if (yych <= '/') goto yy978; - goto yy1075; + if (yych == '-') goto yy1102; + if (yych <= '/') goto yy999; + goto yy1103; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1075; + if (yych <= '@') goto yy999; + goto yy1103; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1075; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1103; + goto yy999; } } -yy1073: +yy1101: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1075; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1103; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1075; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1103; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1075; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1103; + goto yy999; } } -yy1074: +yy1102: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1076; - if (yych <= '/') goto yy978; - goto yy1077; + if (yych == '-') goto yy1104; + if (yych <= '/') goto yy999; + goto yy1105; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1077; + if (yych <= '@') goto yy999; + goto yy1105; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1077; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1105; + goto yy999; } } -yy1075: +yy1103: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1077; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1105; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1077; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1105; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1077; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1105; + goto yy999; } } -yy1076: +yy1104: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1078; - if (yych <= '/') goto yy978; - goto yy1079; + if (yych == '-') goto yy1106; + if (yych <= '/') goto yy999; + goto yy1107; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1079; + if (yych <= '@') goto yy999; + goto yy1107; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1079; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1107; + goto yy999; } } -yy1077: +yy1105: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1079; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1107; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1079; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1107; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1079; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1107; + goto yy999; } } -yy1078: +yy1106: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1080; - if (yych <= '/') goto yy978; - goto yy1081; + if (yych == '-') goto yy1108; + if (yych <= '/') goto yy999; + goto yy1109; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1081; + if (yych <= '@') goto yy999; + goto yy1109; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1081; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1109; + goto yy999; } } -yy1079: +yy1107: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1081; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1109; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1081; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1109; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1081; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1109; + goto yy999; } } -yy1080: +yy1108: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1082; - if (yych <= '/') goto yy978; - goto yy1083; + if (yych == '-') goto yy1110; + if (yych <= '/') goto yy999; + goto yy1111; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1083; + if (yych <= '@') goto yy999; + goto yy1111; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1083; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1111; + goto yy999; } } -yy1081: +yy1109: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1083; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1111; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1083; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1111; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1083; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1111; + goto yy999; } } -yy1082: +yy1110: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1084; - if (yych <= '/') goto yy978; - goto yy1085; + if (yych == '-') goto yy1112; + if (yych <= '/') goto yy999; + goto yy1113; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1085; + if (yych <= '@') goto yy999; + goto yy1113; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1085; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1113; + goto yy999; } } -yy1083: +yy1111: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1085; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1113; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1085; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1113; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1085; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1113; + goto yy999; } } -yy1084: +yy1112: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1086; - if (yych <= '/') goto yy978; - goto yy1087; + if (yych == '-') goto yy1114; + if (yych <= '/') goto yy999; + goto yy1115; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1087; + if (yych <= '@') goto yy999; + goto yy1115; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1087; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1115; + goto yy999; } } -yy1085: +yy1113: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1087; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1115; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1087; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1115; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1087; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1115; + goto yy999; } } -yy1086: +yy1114: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1088; - if (yych <= '/') goto yy978; - goto yy1089; + if (yych == '-') goto yy1116; + if (yych <= '/') goto yy999; + goto yy1117; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1089; + if (yych <= '@') goto yy999; + goto yy1117; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1089; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1117; + goto yy999; } } -yy1087: +yy1115: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1089; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1117; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1089; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1117; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1089; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1117; + goto yy999; } } -yy1088: +yy1116: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1090; - if (yych <= '/') goto yy978; - goto yy1091; + if (yych == '-') goto yy1118; + if (yych <= '/') goto yy999; + goto yy1119; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1091; + if (yych <= '@') goto yy999; + goto yy1119; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1091; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1119; + goto yy999; } } -yy1089: +yy1117: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1091; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1119; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1091; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1119; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1091; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1119; + goto yy999; } } -yy1090: +yy1118: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1092; - if (yych <= '/') goto yy978; - goto yy1093; + if (yych == '-') goto yy1120; + if (yych <= '/') goto yy999; + goto yy1121; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1093; + if (yych <= '@') goto yy999; + goto yy1121; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1093; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1121; + goto yy999; } } -yy1091: +yy1119: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1093; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1121; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1093; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1121; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1093; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1121; + goto yy999; } } -yy1092: +yy1120: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1094; - if (yych <= '/') goto yy978; - goto yy1095; + if (yych == '-') goto yy1122; + if (yych <= '/') goto yy999; + goto yy1123; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1095; + if (yych <= '@') goto yy999; + goto yy1123; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1095; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1123; + goto yy999; } } -yy1093: +yy1121: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1095; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1123; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1095; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1123; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1095; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1123; + goto yy999; } } -yy1094: +yy1122: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1096; - if (yych <= '/') goto yy978; - goto yy1097; + if (yych == '-') goto yy1124; + if (yych <= '/') goto yy999; + goto yy1125; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1097; + if (yych <= '@') goto yy999; + goto yy1125; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1097; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1125; + goto yy999; } } -yy1095: +yy1123: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1097; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1125; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1097; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1125; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1097; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1125; + goto yy999; } } -yy1096: +yy1124: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1098; - if (yych <= '/') goto yy978; - goto yy1099; + if (yych == '-') goto yy1126; + if (yych <= '/') goto yy999; + goto yy1127; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1099; + if (yych <= '@') goto yy999; + goto yy1127; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1099; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1127; + goto yy999; } } -yy1097: +yy1125: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1099; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1127; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1099; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1127; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1099; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1127; + goto yy999; } } -yy1098: +yy1126: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1100; - if (yych <= '/') goto yy978; - goto yy1101; + if (yych == '-') goto yy1128; + if (yych <= '/') goto yy999; + goto yy1129; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1101; + if (yych <= '@') goto yy999; + goto yy1129; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1101; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1129; + goto yy999; } } -yy1099: +yy1127: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1101; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1129; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1101; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1129; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1101; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1129; + goto yy999; } } -yy1100: +yy1128: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1102; - if (yych <= '/') goto yy978; - goto yy1103; + if (yych == '-') goto yy1130; + if (yych <= '/') goto yy999; + goto yy1131; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1103; + if (yych <= '@') goto yy999; + goto yy1131; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1103; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1131; + goto yy999; } } -yy1101: +yy1129: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1103; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1131; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1103; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1131; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1103; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1131; + goto yy999; } } -yy1102: +yy1130: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1104; - if (yych <= '/') goto yy978; - goto yy1105; + if (yych == '-') goto yy1132; + if (yych <= '/') goto yy999; + goto yy1133; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1105; + if (yych <= '@') goto yy999; + goto yy1133; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1105; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1133; + goto yy999; } } -yy1103: +yy1131: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1105; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1133; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1105; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1133; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1105; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1133; + goto yy999; } } -yy1104: +yy1132: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1106; - if (yych <= '/') goto yy978; - goto yy1107; + if (yych == '-') goto yy1134; + if (yych <= '/') goto yy999; + goto yy1135; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1107; + if (yych <= '@') goto yy999; + goto yy1135; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1107; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1135; + goto yy999; } } -yy1105: +yy1133: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1107; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1135; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1107; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1135; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1107; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1135; + goto yy999; } } -yy1106: +yy1134: ++p; yych = *p; if (yych <= '9') { - if (yych == '-') goto yy1108; - if (yych <= '/') goto yy978; - goto yy1109; + if (yych == '-') goto yy1136; + if (yych <= '/') goto yy999; + goto yy1137; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1109; + if (yych <= '@') goto yy999; + goto yy1137; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1109; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1137; + goto yy999; } } -yy1107: +yy1135: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1109; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1137; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1109; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1137; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1109; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1137; + goto yy999; } } -yy1108: +yy1136: ++p; yych = *p; if (yych <= '@') { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1110; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1138; + goto yy999; } else { - if (yych <= 'Z') goto yy1110; - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1110; - goto yy978; + if (yych <= 'Z') goto yy1138; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1138; + goto yy999; } -yy1109: +yy1137: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= '-') goto yy978; - goto yy984; + if (yych <= '-') goto yy999; + goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych >= ':') goto yy978; + if (yych <= '/') goto yy999; + if (yych >= ':') goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; } else { - if (yych <= '`') goto yy978; - if (yych >= '{') goto yy978; + if (yych <= '`') goto yy999; + if (yych >= '{') goto yy999; } } -yy1110: +yy1138: ++p; yych = *p; - if (yych == '.') goto yy984; - if (yych == '>') goto yy985; - goto yy978; -yy1111: + if (yych == '.') goto yy1012; + if (yych == '>') goto yy1013; + goto yy999; +yy1139: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1113; - if (yych <= '/') goto yy978; - goto yy1114; + if (yych == '-') goto yy1141; + if (yych <= '/') goto yy999; + goto yy1142; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1114; + if (yych <= '@') goto yy999; + goto yy1142; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1114; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1142; + goto yy999; } } -yy1112: +yy1140: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1114; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1142; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1114; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1142; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1114; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1142; + goto yy999; } } -yy1113: +yy1141: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1115; - if (yych <= '/') goto yy978; - goto yy1116; + if (yych == '-') goto yy1143; + if (yych <= '/') goto yy999; + goto yy1144; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1116; + if (yych <= '@') goto yy999; + goto yy1144; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1116; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1144; + goto yy999; } } -yy1114: +yy1142: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1116; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1144; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1116; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1144; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1116; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1144; + goto yy999; } } -yy1115: +yy1143: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1117; - if (yych <= '/') goto yy978; - goto yy1118; + if (yych == '-') goto yy1145; + if (yych <= '/') goto yy999; + goto yy1146; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1118; + if (yych <= '@') goto yy999; + goto yy1146; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1118; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1146; + goto yy999; } } -yy1116: +yy1144: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1118; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1146; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1118; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1146; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1118; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1146; + goto yy999; } } -yy1117: +yy1145: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1119; - if (yych <= '/') goto yy978; - goto yy1120; + if (yych == '-') goto yy1147; + if (yych <= '/') goto yy999; + goto yy1148; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1120; + if (yych <= '@') goto yy999; + goto yy1148; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1120; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1148; + goto yy999; } } -yy1118: +yy1146: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1120; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1148; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1120; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1148; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1120; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1148; + goto yy999; } } -yy1119: +yy1147: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1121; - if (yych <= '/') goto yy978; - goto yy1122; + if (yych == '-') goto yy1149; + if (yych <= '/') goto yy999; + goto yy1150; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1122; + if (yych <= '@') goto yy999; + goto yy1150; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1122; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1150; + goto yy999; } } -yy1120: +yy1148: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1122; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1150; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1122; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1150; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1122; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1150; + goto yy999; } } -yy1121: +yy1149: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1123; - if (yych <= '/') goto yy978; - goto yy1124; - } else { + if (yych == '-') goto yy1151; + if (yych <= '/') goto yy999; + goto yy1152; + } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1124; + if (yych <= '@') goto yy999; + goto yy1152; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1124; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1152; + goto yy999; } } -yy1122: +yy1150: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1124; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1152; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1124; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1152; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1124; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1152; + goto yy999; } } -yy1123: +yy1151: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1125; - if (yych <= '/') goto yy978; - goto yy1126; + if (yych == '-') goto yy1153; + if (yych <= '/') goto yy999; + goto yy1154; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1126; + if (yych <= '@') goto yy999; + goto yy1154; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1126; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1154; + goto yy999; } } -yy1124: +yy1152: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1126; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1154; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1126; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1154; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1126; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1154; + goto yy999; } } -yy1125: +yy1153: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1127; - if (yych <= '/') goto yy978; - goto yy1128; + if (yych == '-') goto yy1155; + if (yych <= '/') goto yy999; + goto yy1156; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1128; + if (yych <= '@') goto yy999; + goto yy1156; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1128; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1156; + goto yy999; } } -yy1126: +yy1154: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1128; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1156; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1128; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1156; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1128; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1156; + goto yy999; } } -yy1127: +yy1155: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1129; - if (yych <= '/') goto yy978; - goto yy1130; + if (yych == '-') goto yy1157; + if (yych <= '/') goto yy999; + goto yy1158; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1130; + if (yych <= '@') goto yy999; + goto yy1158; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1130; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1158; + goto yy999; } } -yy1128: +yy1156: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1130; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1158; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1130; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1158; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1130; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1158; + goto yy999; } } -yy1129: +yy1157: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1131; - if (yych <= '/') goto yy978; - goto yy1132; + if (yych == '-') goto yy1159; + if (yych <= '/') goto yy999; + goto yy1160; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1132; + if (yych <= '@') goto yy999; + goto yy1160; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1132; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1160; + goto yy999; } } -yy1130: +yy1158: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1132; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1160; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1132; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1160; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1132; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1160; + goto yy999; } } -yy1131: +yy1159: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1133; - if (yych <= '/') goto yy978; - goto yy1134; + if (yych == '-') goto yy1161; + if (yych <= '/') goto yy999; + goto yy1162; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1134; + if (yych <= '@') goto yy999; + goto yy1162; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1134; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1162; + goto yy999; } } -yy1132: +yy1160: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1134; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1162; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1134; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1162; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1134; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1162; + goto yy999; } } -yy1133: +yy1161: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1135; - if (yych <= '/') goto yy978; - goto yy1136; + if (yych == '-') goto yy1163; + if (yych <= '/') goto yy999; + goto yy1164; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1136; + if (yych <= '@') goto yy999; + goto yy1164; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1136; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1164; + goto yy999; } } -yy1134: +yy1162: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1136; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1164; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1136; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1164; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1136; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1164; + goto yy999; } } -yy1135: +yy1163: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1137; - if (yych <= '/') goto yy978; - goto yy1138; + if (yych == '-') goto yy1165; + if (yych <= '/') goto yy999; + goto yy1166; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1138; + if (yych <= '@') goto yy999; + goto yy1166; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1138; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1166; + goto yy999; } } -yy1136: +yy1164: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1138; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1166; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1138; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1166; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1138; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1166; + goto yy999; } } -yy1137: +yy1165: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1139; - if (yych <= '/') goto yy978; - goto yy1140; + if (yych == '-') goto yy1167; + if (yych <= '/') goto yy999; + goto yy1168; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1140; + if (yych <= '@') goto yy999; + goto yy1168; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1140; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1168; + goto yy999; } } -yy1138: +yy1166: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1140; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1168; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1140; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1168; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1140; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1168; + goto yy999; } } -yy1139: +yy1167: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1141; - if (yych <= '/') goto yy978; - goto yy1142; + if (yych == '-') goto yy1169; + if (yych <= '/') goto yy999; + goto yy1170; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1142; + if (yych <= '@') goto yy999; + goto yy1170; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1142; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1170; + goto yy999; } } -yy1140: +yy1168: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1142; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1170; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1142; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1170; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1142; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1170; + goto yy999; } } -yy1141: +yy1169: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1143; - if (yych <= '/') goto yy978; - goto yy1144; + if (yych == '-') goto yy1171; + if (yych <= '/') goto yy999; + goto yy1172; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1144; + if (yych <= '@') goto yy999; + goto yy1172; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1144; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1172; + goto yy999; } } -yy1142: +yy1170: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1144; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1172; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1144; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1172; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1144; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1172; + goto yy999; } } -yy1143: +yy1171: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1145; - if (yych <= '/') goto yy978; - goto yy1146; + if (yych == '-') goto yy1173; + if (yych <= '/') goto yy999; + goto yy1174; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1146; + if (yych <= '@') goto yy999; + goto yy1174; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1146; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1174; + goto yy999; } } -yy1144: +yy1172: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1146; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1174; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1146; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1174; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1146; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1174; + goto yy999; } } -yy1145: +yy1173: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1147; - if (yych <= '/') goto yy978; - goto yy1148; + if (yych == '-') goto yy1175; + if (yych <= '/') goto yy999; + goto yy1176; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1148; + if (yych <= '@') goto yy999; + goto yy1176; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1148; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1176; + goto yy999; } } -yy1146: +yy1174: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1148; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1176; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1148; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1176; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1148; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1176; + goto yy999; } } -yy1147: +yy1175: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1149; - if (yych <= '/') goto yy978; - goto yy1150; + if (yych == '-') goto yy1177; + if (yych <= '/') goto yy999; + goto yy1178; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1150; + if (yych <= '@') goto yy999; + goto yy1178; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1150; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1178; + goto yy999; } } -yy1148: +yy1176: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1150; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1178; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1150; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1178; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1150; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1178; + goto yy999; } } -yy1149: +yy1177: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1151; - if (yych <= '/') goto yy978; - goto yy1152; + if (yych == '-') goto yy1179; + if (yych <= '/') goto yy999; + goto yy1180; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1152; + if (yych <= '@') goto yy999; + goto yy1180; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1152; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1180; + goto yy999; } } -yy1150: +yy1178: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1152; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1180; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1152; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1180; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1152; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1180; + goto yy999; } } -yy1151: +yy1179: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1153; - if (yych <= '/') goto yy978; - goto yy1154; + if (yych == '-') goto yy1181; + if (yych <= '/') goto yy999; + goto yy1182; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1154; + if (yych <= '@') goto yy999; + goto yy1182; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1154; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1182; + goto yy999; } } -yy1152: +yy1180: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1154; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1182; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1154; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1182; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1154; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1182; + goto yy999; } } -yy1153: +yy1181: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1155; - if (yych <= '/') goto yy978; - goto yy1156; + if (yych == '-') goto yy1183; + if (yych <= '/') goto yy999; + goto yy1184; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1156; + if (yych <= '@') goto yy999; + goto yy1184; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1156; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1184; + goto yy999; } } -yy1154: +yy1182: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1156; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1184; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1156; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1184; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1156; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1184; + goto yy999; } } -yy1155: +yy1183: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1157; - if (yych <= '/') goto yy978; - goto yy1158; + if (yych == '-') goto yy1185; + if (yych <= '/') goto yy999; + goto yy1186; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1158; + if (yych <= '@') goto yy999; + goto yy1186; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1158; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1186; + goto yy999; } } -yy1156: +yy1184: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1158; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1186; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1158; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1186; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1158; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1186; + goto yy999; } } -yy1157: +yy1185: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1159; - if (yych <= '/') goto yy978; - goto yy1160; + if (yych == '-') goto yy1187; + if (yych <= '/') goto yy999; + goto yy1188; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1160; + if (yych <= '@') goto yy999; + goto yy1188; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1160; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1188; + goto yy999; } } -yy1158: +yy1186: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1160; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1188; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1160; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1188; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1160; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1188; + goto yy999; } } -yy1159: +yy1187: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1161; - if (yych <= '/') goto yy978; - goto yy1162; + if (yych == '-') goto yy1189; + if (yych <= '/') goto yy999; + goto yy1190; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1162; + if (yych <= '@') goto yy999; + goto yy1190; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1162; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1190; + goto yy999; } } -yy1160: +yy1188: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1162; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1190; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1162; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1190; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1162; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1190; + goto yy999; } } -yy1161: +yy1189: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1163; - if (yych <= '/') goto yy978; - goto yy1164; + if (yych == '-') goto yy1191; + if (yych <= '/') goto yy999; + goto yy1192; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1164; + if (yych <= '@') goto yy999; + goto yy1192; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1164; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1192; + goto yy999; } } -yy1162: +yy1190: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1164; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1192; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1164; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1192; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1164; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1192; + goto yy999; } } -yy1163: +yy1191: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1165; - if (yych <= '/') goto yy978; - goto yy1166; + if (yych == '-') goto yy1193; + if (yych <= '/') goto yy999; + goto yy1194; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1166; + if (yych <= '@') goto yy999; + goto yy1194; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1166; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1194; + goto yy999; } } -yy1164: +yy1192: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1166; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1194; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1166; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1194; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1166; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1194; + goto yy999; } } -yy1165: +yy1193: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1167; - if (yych <= '/') goto yy978; - goto yy1168; + if (yych == '-') goto yy1195; + if (yych <= '/') goto yy999; + goto yy1196; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1168; + if (yych <= '@') goto yy999; + goto yy1196; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1168; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1196; + goto yy999; } } -yy1166: +yy1194: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1168; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1196; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1168; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1196; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1168; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1196; + goto yy999; } } -yy1167: +yy1195: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1169; - if (yych <= '/') goto yy978; - goto yy1170; + if (yych == '-') goto yy1197; + if (yych <= '/') goto yy999; + goto yy1198; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1170; + if (yych <= '@') goto yy999; + goto yy1198; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1170; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1198; + goto yy999; } } -yy1168: +yy1196: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1170; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1198; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1170; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1198; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1170; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1198; + goto yy999; } } -yy1169: +yy1197: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1171; - if (yych <= '/') goto yy978; - goto yy1172; + if (yych == '-') goto yy1199; + if (yych <= '/') goto yy999; + goto yy1200; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1172; + if (yych <= '@') goto yy999; + goto yy1200; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1172; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1200; + goto yy999; } } -yy1170: +yy1198: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1172; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1200; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1172; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1200; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1172; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1200; + goto yy999; } } -yy1171: +yy1199: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1173; - if (yych <= '/') goto yy978; - goto yy1174; + if (yych == '-') goto yy1201; + if (yych <= '/') goto yy999; + goto yy1202; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1174; + if (yych <= '@') goto yy999; + goto yy1202; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1174; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1202; + goto yy999; } } -yy1172: +yy1200: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1174; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1202; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1174; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1202; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1174; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1202; + goto yy999; } } -yy1173: +yy1201: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1175; - if (yych <= '/') goto yy978; - goto yy1176; + if (yych == '-') goto yy1203; + if (yych <= '/') goto yy999; + goto yy1204; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1176; + if (yych <= '@') goto yy999; + goto yy1204; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1176; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1204; + goto yy999; } } -yy1174: +yy1202: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1176; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1204; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1176; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1204; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1176; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1204; + goto yy999; } } -yy1175: +yy1203: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1177; - if (yych <= '/') goto yy978; - goto yy1178; + if (yych == '-') goto yy1205; + if (yych <= '/') goto yy999; + goto yy1206; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1178; + if (yych <= '@') goto yy999; + goto yy1206; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1178; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1206; + goto yy999; } } -yy1176: +yy1204: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1178; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1206; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1178; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1206; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1178; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1206; + goto yy999; } } -yy1177: +yy1205: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1179; - if (yych <= '/') goto yy978; - goto yy1180; + if (yych == '-') goto yy1207; + if (yych <= '/') goto yy999; + goto yy1208; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1180; + if (yych <= '@') goto yy999; + goto yy1208; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1180; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1208; + goto yy999; } } -yy1178: +yy1206: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1180; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1208; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1180; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1208; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1180; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1208; + goto yy999; } } -yy1179: +yy1207: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1181; - if (yych <= '/') goto yy978; - goto yy1182; + if (yych == '-') goto yy1209; + if (yych <= '/') goto yy999; + goto yy1210; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1182; + if (yych <= '@') goto yy999; + goto yy1210; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1182; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1210; + goto yy999; } } -yy1180: +yy1208: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1182; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1210; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1182; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1210; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1182; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1210; + goto yy999; } } -yy1181: +yy1209: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1183; - if (yych <= '/') goto yy978; - goto yy1184; + if (yych == '-') goto yy1211; + if (yych <= '/') goto yy999; + goto yy1212; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1184; + if (yych <= '@') goto yy999; + goto yy1212; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1184; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1212; + goto yy999; } } -yy1182: +yy1210: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1184; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1212; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1184; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1212; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1184; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1212; + goto yy999; } } -yy1183: +yy1211: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1185; - if (yych <= '/') goto yy978; - goto yy1186; + if (yych == '-') goto yy1213; + if (yych <= '/') goto yy999; + goto yy1214; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1186; + if (yych <= '@') goto yy999; + goto yy1214; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1186; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1214; + goto yy999; } } -yy1184: +yy1212: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1186; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1214; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1186; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1214; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1186; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1214; + goto yy999; } } -yy1185: +yy1213: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1187; - if (yych <= '/') goto yy978; - goto yy1188; + if (yych == '-') goto yy1215; + if (yych <= '/') goto yy999; + goto yy1216; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1188; + if (yych <= '@') goto yy999; + goto yy1216; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1188; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1216; + goto yy999; } } -yy1186: +yy1214: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1188; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1216; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1188; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1216; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1188; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1216; + goto yy999; } } -yy1187: +yy1215: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1189; - if (yych <= '/') goto yy978; - goto yy1190; + if (yych == '-') goto yy1217; + if (yych <= '/') goto yy999; + goto yy1218; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1190; + if (yych <= '@') goto yy999; + goto yy1218; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1190; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1218; + goto yy999; } } -yy1188: +yy1216: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1190; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1218; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1190; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1218; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1190; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1218; + goto yy999; } } -yy1189: +yy1217: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1191; - if (yych <= '/') goto yy978; - goto yy1192; + if (yych == '-') goto yy1219; + if (yych <= '/') goto yy999; + goto yy1220; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1192; + if (yych <= '@') goto yy999; + goto yy1220; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1192; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1220; + goto yy999; } } -yy1190: +yy1218: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1192; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1220; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1192; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1220; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1192; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1220; + goto yy999; } } -yy1191: +yy1219: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1193; - if (yych <= '/') goto yy978; - goto yy1194; + if (yych == '-') goto yy1221; + if (yych <= '/') goto yy999; + goto yy1222; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1194; + if (yych <= '@') goto yy999; + goto yy1222; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1194; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1222; + goto yy999; } } -yy1192: +yy1220: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1194; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1222; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1194; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1222; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1194; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1222; + goto yy999; } } -yy1193: +yy1221: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1195; - if (yych <= '/') goto yy978; - goto yy1196; + if (yych == '-') goto yy1223; + if (yych <= '/') goto yy999; + goto yy1224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1196; + if (yych <= '@') goto yy999; + goto yy1224; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1196; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1224; + goto yy999; } } -yy1194: +yy1222: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1196; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1224; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1196; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1224; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1196; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1224; + goto yy999; } } -yy1195: +yy1223: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1197; - if (yych <= '/') goto yy978; - goto yy1198; + if (yych == '-') goto yy1225; + if (yych <= '/') goto yy999; + goto yy1226; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1198; + if (yych <= '@') goto yy999; + goto yy1226; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1198; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1226; + goto yy999; } } -yy1196: +yy1224: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1198; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1226; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1198; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1226; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1198; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1226; + goto yy999; } } -yy1197: +yy1225: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1199; - if (yych <= '/') goto yy978; - goto yy1200; + if (yych == '-') goto yy1227; + if (yych <= '/') goto yy999; + goto yy1228; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1200; + if (yych <= '@') goto yy999; + goto yy1228; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1200; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1228; + goto yy999; } } -yy1198: +yy1226: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1200; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1228; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1200; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1228; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1200; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1228; + goto yy999; } } -yy1199: +yy1227: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1201; - if (yych <= '/') goto yy978; - goto yy1202; + if (yych == '-') goto yy1229; + if (yych <= '/') goto yy999; + goto yy1230; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1202; + if (yych <= '@') goto yy999; + goto yy1230; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1202; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1230; + goto yy999; } } -yy1200: +yy1228: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1202; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1230; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1202; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1230; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1202; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1230; + goto yy999; } } -yy1201: +yy1229: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1203; - if (yych <= '/') goto yy978; - goto yy1204; + if (yych == '-') goto yy1231; + if (yych <= '/') goto yy999; + goto yy1232; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1204; + if (yych <= '@') goto yy999; + goto yy1232; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1204; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1232; + goto yy999; } } -yy1202: +yy1230: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1204; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1232; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1204; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1232; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1204; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1232; + goto yy999; } } -yy1203: +yy1231: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1205; - if (yych <= '/') goto yy978; - goto yy1206; + if (yych == '-') goto yy1233; + if (yych <= '/') goto yy999; + goto yy1234; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1206; + if (yych <= '@') goto yy999; + goto yy1234; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1206; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1234; + goto yy999; } } -yy1204: +yy1232: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1206; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1234; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1206; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1234; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1206; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1234; + goto yy999; } } -yy1205: +yy1233: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1207; - if (yych <= '/') goto yy978; - goto yy1208; + if (yych == '-') goto yy1235; + if (yych <= '/') goto yy999; + goto yy1236; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1208; + if (yych <= '@') goto yy999; + goto yy1236; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1208; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1236; + goto yy999; } } -yy1206: +yy1234: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1208; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1236; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1208; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1236; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1208; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1236; + goto yy999; } } -yy1207: +yy1235: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1209; - if (yych <= '/') goto yy978; - goto yy1210; + if (yych == '-') goto yy1237; + if (yych <= '/') goto yy999; + goto yy1238; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1210; + if (yych <= '@') goto yy999; + goto yy1238; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1210; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1238; + goto yy999; } } -yy1208: +yy1236: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1210; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1238; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1210; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1238; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1210; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1238; + goto yy999; } } -yy1209: +yy1237: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1211; - if (yych <= '/') goto yy978; - goto yy1212; + if (yych == '-') goto yy1239; + if (yych <= '/') goto yy999; + goto yy1240; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1212; + if (yych <= '@') goto yy999; + goto yy1240; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1212; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1240; + goto yy999; } } -yy1210: +yy1238: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1212; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1240; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1212; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1240; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1212; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1240; + goto yy999; } } -yy1211: +yy1239: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1213; - if (yych <= '/') goto yy978; - goto yy1214; + if (yych == '-') goto yy1241; + if (yych <= '/') goto yy999; + goto yy1242; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1214; + if (yych <= '@') goto yy999; + goto yy1242; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1214; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1242; + goto yy999; } } -yy1212: +yy1240: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1214; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1242; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1214; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1242; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1214; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1242; + goto yy999; } } -yy1213: +yy1241: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1215; - if (yych <= '/') goto yy978; - goto yy1216; + if (yych == '-') goto yy1243; + if (yych <= '/') goto yy999; + goto yy1244; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1216; + if (yych <= '@') goto yy999; + goto yy1244; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1216; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1244; + goto yy999; } } -yy1214: +yy1242: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1216; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1244; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1216; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1244; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1216; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1244; + goto yy999; } } -yy1215: +yy1243: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1217; - if (yych <= '/') goto yy978; - goto yy1218; + if (yych == '-') goto yy1245; + if (yych <= '/') goto yy999; + goto yy1246; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1218; + if (yych <= '@') goto yy999; + goto yy1246; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1218; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1246; + goto yy999; } } -yy1216: +yy1244: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1218; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1246; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1218; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1246; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1218; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1246; + goto yy999; } } -yy1217: +yy1245: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1219; - if (yych <= '/') goto yy978; - goto yy1220; + if (yych == '-') goto yy1247; + if (yych <= '/') goto yy999; + goto yy1248; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1220; + if (yych <= '@') goto yy999; + goto yy1248; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1220; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1248; + goto yy999; } } -yy1218: +yy1246: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1220; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1248; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1220; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1248; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1220; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1248; + goto yy999; } } -yy1219: +yy1247: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1221; - if (yych <= '/') goto yy978; - goto yy1222; + if (yych == '-') goto yy1249; + if (yych <= '/') goto yy999; + goto yy1250; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1222; + if (yych <= '@') goto yy999; + goto yy1250; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1222; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1250; + goto yy999; } } -yy1220: +yy1248: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1222; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1250; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1222; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1250; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1222; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1250; + goto yy999; } } -yy1221: +yy1249: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1223; - if (yych <= '/') goto yy978; - goto yy1224; + if (yych == '-') goto yy1251; + if (yych <= '/') goto yy999; + goto yy1252; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1224; + if (yych <= '@') goto yy999; + goto yy1252; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1224; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1252; + goto yy999; } } -yy1222: +yy1250: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1224; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1252; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1224; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1252; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1224; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1252; + goto yy999; } } -yy1223: +yy1251: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1225; - if (yych <= '/') goto yy978; - goto yy1226; + if (yych == '-') goto yy1253; + if (yych <= '/') goto yy999; + goto yy1254; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1226; + if (yych <= '@') goto yy999; + goto yy1254; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1226; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1254; + goto yy999; } } -yy1224: +yy1252: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1226; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1254; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1226; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1254; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1226; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1254; + goto yy999; } } -yy1225: +yy1253: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1227; - if (yych <= '/') goto yy978; - goto yy1228; + if (yych == '-') goto yy1255; + if (yych <= '/') goto yy999; + goto yy1256; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1228; + if (yych <= '@') goto yy999; + goto yy1256; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1228; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1256; + goto yy999; } } -yy1226: +yy1254: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1228; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1256; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1228; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1256; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1228; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1256; + goto yy999; } } -yy1227: +yy1255: yych = *++p; if (yych <= '9') { - if (yych == '-') goto yy1229; - if (yych <= '/') goto yy978; - goto yy1230; + if (yych == '-') goto yy1257; + if (yych <= '/') goto yy999; + goto yy1258; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy978; - goto yy1230; + if (yych <= '@') goto yy999; + goto yy1258; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1230; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1258; + goto yy999; } } -yy1228: +yy1256: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') goto yy978; - if (yych >= '.') goto yy984; + if (yych <= ',') goto yy999; + if (yych >= '.') goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1230; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1258; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1230; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1258; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1230; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1258; + goto yy999; } } -yy1229: +yy1257: yych = *++p; if (yych <= '@') { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1110; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1138; + goto yy999; } else { - if (yych <= 'Z') goto yy1110; - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1110; - goto yy978; + if (yych <= 'Z') goto yy1138; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1138; + goto yy999; } -yy1230: +yy1258: ++p; if ((yych = *p) <= '=') { if (yych <= '.') { - if (yych <= '-') goto yy978; - goto yy984; + if (yych <= '-') goto yy999; + goto yy1012; } else { - if (yych <= '/') goto yy978; - if (yych <= '9') goto yy1110; - goto yy978; + if (yych <= '/') goto yy999; + if (yych <= '9') goto yy1138; + goto yy999; } } else { if (yych <= 'Z') { - if (yych <= '>') goto yy985; - if (yych <= '@') goto yy978; - goto yy1110; + if (yych <= '>') goto yy1013; + if (yych <= '@') goto yy999; + goto yy1138; } else { - if (yych <= '`') goto yy978; - if (yych <= 'z') goto yy1110; - goto yy978; + if (yych <= '`') goto yy999; + if (yych <= 'z') goto yy1138; + goto yy999; } } } @@ -10817,7 +11116,7 @@ bufsize_t _scan_html_tag(const unsigned char *p) 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, + 230, 230, 230, 230, 230, 254, 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, @@ -10828,3095 +11127,7594 @@ bufsize_t _scan_html_tag(const unsigned char *p) 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, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + /* 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, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 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 yy1238; + yych = *(marker = p); + if (yych <= '`') { + if (yych <= '.') { + if (yych <= '\n') { + if (yych <= '\t') goto yy1266; + } else { + if (yych == '!') goto yy1264; + goto yy1266; + } } else { - if (yych <= '!') goto yy1236; - if (yych <= '.') goto yy1238; - goto yy1235; + if (yych <= '?') { + if (yych <= '/') goto yy1263; + if (yych <= '>') goto yy1266; + goto yy1265; + } else { + if (yych <= '@') goto yy1266; + if (yych <= 'Z') goto yy1262; + goto yy1266; + } } } else { - if (yych <= '@') { - if (yych == '?') goto yy1237; - goto yy1238; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 'z') goto yy1262; + if (yych <= 0x7F) goto yy1266; + } else { + if (yych <= 0xDF) goto yy1267; + if (yych <= 0xE0) goto yy1269; + goto yy1270; + } } else { - if (yych <= 'Z') goto yy1234; - if (yych <= '`') goto yy1238; - if (yych <= 'z') goto yy1234; - goto yy1238; + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1274; + if (yych <= 0xEF) goto yy1270; + goto yy1271; + } else { + if (yych <= 0xF3) goto yy1272; + if (yych <= 0xF4) goto yy1273; + } } } -yy1233: +yy1261: { return 0; } -yy1234: +yy1262: yych = *(marker = ++p); - if (yych <= '9') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1233; - if (yych <= '\r') goto yy1275; - goto yy1233; + if (yych <= '/') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy1261; + if (yych <= '\r') goto yy1366; + if (yych <= 0x1F) goto yy1261; + goto yy1366; } else { - if (yych <= ' ') goto yy1275; - if (yych <= '.') goto yy1233; - if (yych <= '/') goto yy1277; - goto yy1273; + if (yych == '-') goto yy1364; + if (yych <= '.') goto yy1261; + goto yy1368; } } else { if (yych <= '@') { - if (yych == '>') goto yy1243; - goto yy1233; + if (yych <= '9') goto yy1364; + if (yych == '>') goto yy1285; + goto yy1261; } else { - if (yych <= 'Z') goto yy1273; - if (yych <= '`') goto yy1233; - if (yych <= 'z') goto yy1273; - goto yy1233; + if (yych <= 'Z') goto yy1364; + if (yych <= '`') goto yy1261; + if (yych <= 'z') goto yy1364; + goto yy1261; } } -yy1235: +yy1263: yych = *(marker = ++p); - if (yych <= '@') goto yy1233; - if (yych <= 'Z') goto yy1269; - if (yych <= '`') goto yy1233; - if (yych <= 'z') goto yy1269; - goto yy1233; -yy1236: + if (yych <= '@') goto yy1261; + if (yych <= 'Z') goto yy1360; + if (yych <= '`') goto yy1261; + if (yych <= 'z') goto yy1360; + goto yy1261; +yy1264: yych = *(marker = ++p); if (yybm[256+yych] & 64) { - goto yy1246; + goto yy1295; } - if (yych == '-') goto yy1248; - if (yych == '[') goto yy1245; - goto yy1233; -yy1237: + if (yych == '-') goto yy1297; + if (yych <= '@') goto yy1261; + if (yych <= '[') goto yy1294; + goto yy1261; +yy1265: yych = *(marker = ++p); - if (yych <= 0x00) goto yy1233; - goto yy1240; -yy1238: + if (yych <= 0x00) goto yy1261; + if (yych <= 0x7F) goto yy1276; + if (yych <= 0xC1) goto yy1261; + if (yych <= 0xF4) goto yy1276; + goto yy1261; +yy1266: + yych = *++p; + goto yy1261; +yy1267: + yych = *++p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1266; +yy1268: + p = marker; + goto yy1261; +yy1269: yych = *++p; - goto yy1233; -yy1239: + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1267; + goto yy1268; +yy1270: + yych = *++p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1267; + goto yy1268; +yy1271: + yych = *++p; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1270; + goto yy1268; +yy1272: + yych = *++p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1270; + goto yy1268; +yy1273: + yych = *++p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1270; + goto yy1268; +yy1274: + yych = *++p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1267; + goto yy1268; +yy1275: ++p; yych = *p; -yy1240: +yy1276: if (yybm[256+yych] & 32) { - goto yy1239; + goto yy1275; } - if (yych >= 0x01) goto yy1242; -yy1241: - p = marker; - goto yy1233; -yy1242: + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy1268; + if (yych <= '?') goto yy1284; + goto yy1268; + } else { + if (yych <= 0xDF) goto yy1277; + if (yych <= 0xE0) goto yy1278; + goto yy1279; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1283; + if (yych <= 0xEF) goto yy1279; + goto yy1280; + } else { + if (yych <= 0xF3) goto yy1281; + if (yych <= 0xF4) goto yy1282; + goto yy1268; + } + } +yy1277: ++p; yych = *p; - if (yych <= 0x00) goto yy1241; - if (yych != '>') goto yy1239; -yy1243: + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1275; + goto yy1268; +yy1278: ++p; - { return (bufsize_t)(p - start); } -yy1245: - yych = *++p; - if (yych == 'C') goto yy1260; - if (yych == 'c') goto yy1260; - goto yy1241; -yy1246: + yych = *p; + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1277; + goto yy1268; +yy1279: ++p; yych = *p; - if (yybm[0+yych] & 1) { - goto yy1256; - } - if (yych <= '@') goto yy1241; - if (yych <= 'Z') goto yy1246; - goto yy1241; -yy1248: - yych = *++p; - if (yych != '-') goto yy1241; - yych = *++p; - if (yych == '-') goto yy1250; - if (yych == '>') goto yy1241; - goto yy1252; -yy1250: - yych = *++p; - if (yych == '-') goto yy1255; - if (yych == '>') goto yy1241; - goto yy1252; -yy1251: + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1277; + goto yy1268; +yy1280: ++p; yych = *p; -yy1252: - if (yybm[256+yych] & 128) { - goto yy1251; - } - if (yych <= 0x00) goto yy1241; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1279; + goto yy1268; +yy1281: ++p; yych = *p; - if (yybm[256+yych] & 128) { - goto yy1251; - } - if (yych <= 0x00) goto yy1241; - yych = *++p; - if (yych == '>') goto yy1243; - goto yy1241; -yy1255: - yych = *++p; - if (yych == '>') goto yy1243; - goto yy1241; -yy1256: + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1279; + goto yy1268; +yy1282: ++p; yych = *p; - if (yybm[0+yych] & 1) { - goto yy1256; - } - if (yych <= 0x00) goto yy1241; - if (yych == '>') goto yy1243; -yy1258: + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1279; + goto yy1268; +yy1283: ++p; yych = *p; - if (yybm[0+yych] & 2) { - goto yy1258; - } - if (yych <= 0x00) goto yy1241; - goto yy1243; -yy1260: - yych = *++p; - if (yych == 'D') goto yy1261; - if (yych != 'd') goto yy1241; -yy1261: - yych = *++p; - if (yych == 'A') goto yy1262; - if (yych != 'a') goto yy1241; -yy1262: - yych = *++p; - if (yych == 'T') goto yy1263; - if (yych != 't') goto yy1241; -yy1263: - yych = *++p; - if (yych == 'A') goto yy1264; - if (yych != 'a') goto yy1241; -yy1264: - yych = *++p; - if (yych != '[') goto yy1241; -yy1265: + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1277; + goto yy1268; +yy1284: ++p; yych = *p; - if (yybm[0+yych] & 4) { - goto yy1265; + if (yych <= 0xE0) { + if (yych <= '>') { + if (yych <= 0x00) goto yy1268; + if (yych <= '=') goto yy1275; + } else { + if (yych <= 0x7F) goto yy1275; + if (yych <= 0xC1) goto yy1268; + if (yych <= 0xDF) goto yy1287; + goto yy1288; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1293; + goto yy1289; + } else { + if (yych <= 0xF0) goto yy1290; + if (yych <= 0xF3) goto yy1291; + if (yych <= 0xF4) goto yy1292; + goto yy1268; + } } - if (yych <= 0x00) goto yy1241; +yy1285: + ++p; + { return (bufsize_t)(p - start); } +yy1287: ++p; yych = *p; - if (yybm[0+yych] & 4) { - goto yy1265; - } - if (yych <= 0x00) goto yy1241; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1275; + goto yy1268; +yy1288: ++p; yych = *p; - if (yych <= 0x00) goto yy1241; - if (yych == '>') goto yy1243; - goto yy1265; -yy1269: + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1287; + goto yy1268; +yy1289: ++p; yych = *p; - if (yybm[0+yych] & 8) { - goto yy1269; - } - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1241; - if (yych >= 0x0E) goto yy1241; - } else { - if (yych <= ' ') goto yy1271; - if (yych == '>') goto yy1243; - goto yy1241; - } -yy1271: + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1287; + goto yy1268; +yy1290: ++p; yych = *p; - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1241; - if (yych <= '\r') goto yy1271; - goto yy1241; - } else { - if (yych <= ' ') goto yy1271; - if (yych == '>') goto yy1243; - goto yy1241; - } -yy1273: + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1289; + goto yy1268; +yy1291: ++p; yych = *p; - if (yych <= '9') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1241; - if (yych >= 0x0E) goto yy1241; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1289; + goto yy1268; +yy1292: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1289; + goto yy1268; +yy1293: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1287; + goto yy1268; +yy1294: + yych = *++p; + if (yych == 'C') goto yy1330; + if (yych == 'c') goto yy1330; + goto yy1268; +yy1295: + ++p; + yych = *p; + if (yybm[0+yych] & 1) { + goto yy1319; + } + if (yych <= '@') goto yy1268; + if (yych <= 'Z') goto yy1295; + goto yy1268; +yy1297: + yych = *++p; + if (yych != '-') goto yy1268; + yych = *++p; + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych != '-') goto yy1301; } else { - if (yych <= ' ') goto yy1275; - if (yych <= '.') goto yy1241; - if (yych <= '/') goto yy1277; - goto yy1273; + if (yych <= '>') goto yy1268; + if (yych <= 0xC1) goto yy1301; + if (yych <= 0xDF) goto yy1302; + goto yy1303; } } else { - if (yych <= '@') { - if (yych == '>') goto yy1243; - goto yy1241; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1308; + goto yy1304; } else { - if (yych <= 'Z') goto yy1273; - if (yych <= '`') goto yy1241; - if (yych <= 'z') goto yy1273; - goto yy1241; + if (yych <= 0xF0) goto yy1305; + if (yych <= 0xF3) goto yy1306; + if (yych <= 0xF4) goto yy1307; + goto yy1301; } } -yy1275: - ++p; - yych = *p; - if (yych <= ':') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy1241; - if (yych <= '\r') goto yy1275; - if (yych <= 0x1F) goto yy1241; - goto yy1275; + yych = *++p; + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych == '-') goto yy1318; + goto yy1301; } else { - if (yych == '/') goto yy1277; - if (yych <= '9') goto yy1241; - goto yy1278; + if (yych <= '>') goto yy1268; + if (yych <= 0xC1) goto yy1301; + if (yych <= 0xDF) goto yy1302; + goto yy1303; } } else { - if (yych <= 'Z') { - if (yych == '>') goto yy1243; - if (yych <= '@') goto yy1241; - goto yy1278; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1308; + goto yy1304; } else { - if (yych <= '_') { - if (yych <= '^') goto yy1241; - goto yy1278; - } else { - if (yych <= '`') goto yy1241; - if (yych <= 'z') goto yy1278; - goto yy1241; - } + if (yych <= 0xF0) goto yy1305; + if (yych <= 0xF3) goto yy1306; + if (yych <= 0xF4) goto yy1307; + goto yy1301; } } -yy1277: - yych = *++p; - if (yych == '>') goto yy1243; - goto yy1241; -yy1278: +yy1300: ++p; yych = *p; - if (yybm[0+yych] & 16) { - goto yy1278; +yy1301: + if (yybm[256+yych] & 128) { + goto yy1300; } - if (yych <= '.') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy1241; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy1268; + if (yych <= '-') goto yy1309; + goto yy1268; } else { - if (yych != ' ') goto yy1241; + if (yych <= 0xDF) goto yy1310; + if (yych <= 0xE0) goto yy1311; + goto yy1312; } } else { - if (yych <= '<') { - if (yych <= '/') goto yy1277; - goto yy1241; + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1316; + if (yych <= 0xEF) goto yy1312; + goto yy1313; } else { - if (yych <= '=') goto yy1282; - if (yych <= '>') goto yy1243; - goto yy1241; + if (yych <= 0xF3) goto yy1314; + if (yych <= 0xF4) goto yy1315; + goto yy1268; } } -yy1280: +yy1302: + yych = *++p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1300; + goto yy1268; +yy1303: + yych = *++p; + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1302; + goto yy1268; +yy1304: + yych = *++p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1302; + goto yy1268; +yy1305: + yych = *++p; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1304; + goto yy1268; +yy1306: + yych = *++p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1304; + goto yy1268; +yy1307: + yych = *++p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1304; + goto yy1268; +yy1308: + yych = *++p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1302; + goto yy1268; +yy1309: ++p; yych = *p; - if (yych <= '<') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy1241; - if (yych <= '\r') goto yy1280; - if (yych <= 0x1F) goto yy1241; - goto yy1280; + if (yybm[256+yych] & 128) { + goto yy1300; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy1268; + if (yych <= '-') goto yy1317; + goto yy1268; } else { - if (yych <= '/') { - if (yych <= '.') goto yy1241; - goto yy1277; - } else { - if (yych == ':') goto yy1278; - goto yy1241; - } + if (yych <= 0xDF) goto yy1310; + if (yych <= 0xE0) goto yy1311; + goto yy1312; } } else { - if (yych <= 'Z') { - if (yych <= '=') goto yy1282; - if (yych <= '>') goto yy1243; - if (yych <= '@') goto yy1241; - goto yy1278; + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1316; + if (yych <= 0xEF) goto yy1312; + goto yy1313; } else { - if (yych <= '_') { - if (yych <= '^') goto yy1241; - goto yy1278; - } else { - if (yych <= '`') goto yy1241; - if (yych <= 'z') goto yy1278; - goto yy1241; - } + if (yych <= 0xF3) goto yy1314; + if (yych <= 0xF4) goto yy1315; + goto yy1268; } } -yy1282: +yy1310: ++p; yych = *p; - if (yybm[0+yych] & 32) { - goto yy1284; - } - if (yych <= 0x00) goto yy1241; - if (yych <= '!') goto yy1283; - if (yych <= '"') goto yy1288; - if (yych <= ';') goto yy1286; - goto yy1241; -yy1283: + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1300; + goto yy1268; +yy1311: ++p; yych = *p; - if (yybm[0+yych] & 32) { - goto yy1284; - } - if (yych <= '"') { - if (yych <= 0x00) goto yy1241; - if (yych <= '!') goto yy1297; - goto yy1288; - } else { - if (yych <= ';') goto yy1286; - if (yych == '>') goto yy1243; - goto yy1241; - } -yy1284: + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1310; + goto yy1268; +yy1312: ++p; yych = *p; - if (yybm[0+yych] & 32) { - goto yy1284; - } - if (yych <= 0x00) goto yy1241; - if (yych <= '!') goto yy1291; - if (yych == '>') goto yy1243; - goto yy1241; -yy1286: + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1310; + goto yy1268; +yy1313: ++p; yych = *p; - if (yybm[0+yych] & 64) { - goto yy1286; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1312; + goto yy1268; +yy1314: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1312; + goto yy1268; +yy1315: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1312; + goto yy1268; +yy1316: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1310; + goto yy1268; +yy1317: + yych = *++p; + if (yych == '>') goto yy1285; + goto yy1268; +yy1318: + yych = *++p; + if (yych == '>') goto yy1285; + goto yy1268; +yy1319: + ++p; + yych = *p; + if (yybm[0+yych] & 1) { + goto yy1319; } - if (yych <= 0x00) goto yy1241; - goto yy1290; -yy1288: + if (yych <= 0xE0) { + if (yych <= '>') { + if (yych <= 0x00) goto yy1268; + if (yych >= '>') goto yy1285; + } else { + if (yych <= 0x7F) goto yy1321; + if (yych <= 0xC1) goto yy1268; + if (yych <= 0xDF) goto yy1323; + goto yy1324; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1329; + goto yy1325; + } else { + if (yych <= 0xF0) goto yy1326; + if (yych <= 0xF3) goto yy1327; + if (yych <= 0xF4) goto yy1328; + goto yy1268; + } + } +yy1321: ++p; yych = *p; - if (yybm[0+yych] & 128) { - goto yy1288; + if (yybm[0+yych] & 2) { + goto yy1321; } - if (yych <= 0x00) goto yy1241; -yy1290: + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy1268; + if (yych <= '>') goto yy1285; + goto yy1268; + } else { + if (yych <= 0xDF) goto yy1323; + if (yych <= 0xE0) goto yy1324; + goto yy1325; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1329; + if (yych <= 0xEF) goto yy1325; + goto yy1326; + } else { + if (yych <= 0xF3) goto yy1327; + if (yych <= 0xF4) goto yy1328; + goto yy1268; + } + } +yy1323: ++p; yych = *p; - if (yych <= ' ') { - if (yych <= 0x08) goto yy1241; - if (yych <= '\r') goto yy1275; - if (yych <= 0x1F) goto yy1241; - goto yy1275; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1321; + goto yy1268; +yy1324: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1323; + goto yy1268; +yy1325: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1323; + goto yy1268; +yy1326: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1325; + goto yy1268; +yy1327: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1325; + goto yy1268; +yy1328: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1325; + goto yy1268; +yy1329: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1323; + goto yy1268; +yy1330: + yych = *++p; + if (yych == 'D') goto yy1331; + if (yych != 'd') goto yy1268; +yy1331: + yych = *++p; + if (yych == 'A') goto yy1332; + if (yych != 'a') goto yy1268; +yy1332: + yych = *++p; + if (yych == 'T') goto yy1333; + if (yych != 't') goto yy1268; +yy1333: + yych = *++p; + if (yych == 'A') goto yy1334; + if (yych != 'a') goto yy1268; +yy1334: + yych = *++p; + if (yych != '[') goto yy1268; +yy1335: + ++p; + yych = *p; + if (yybm[0+yych] & 4) { + goto yy1335; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy1268; + if (yych <= ']') goto yy1344; + goto yy1268; + } else { + if (yych <= 0xDF) goto yy1337; + if (yych <= 0xE0) goto yy1338; + goto yy1339; + } } else { - if (yych <= '/') { - if (yych <= '.') goto yy1241; - goto yy1277; + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1343; + if (yych <= 0xEF) goto yy1339; + goto yy1340; } else { - if (yych == '>') goto yy1243; - goto yy1241; + if (yych <= 0xF3) goto yy1341; + if (yych <= 0xF4) goto yy1342; + goto yy1268; } } -yy1291: +yy1337: ++p; yych = *p; - if (yych <= '9') { - if (yych <= ' ') { - if (yych <= 0x08) { - if (yych <= 0x00) goto yy1241; - goto yy1284; - } else { - if (yych <= '\r') goto yy1291; - if (yych <= 0x1F) goto yy1284; - goto yy1291; - } + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1335; + goto yy1268; +yy1338: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1337; + goto yy1268; +yy1339: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1337; + goto yy1268; +yy1340: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1339; + goto yy1268; +yy1341: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1339; + goto yy1268; +yy1342: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1339; + goto yy1268; +yy1343: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1337; + goto yy1268; +yy1344: + ++p; + yych = *p; + if (yybm[0+yych] & 4) { + goto yy1335; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy1268; + if (yych >= '^') goto yy1268; } else { - if (yych <= '"') { - if (yych <= '!') goto yy1284; - goto yy1241; - } else { - if (yych == '\'') goto yy1241; - goto yy1284; - } + if (yych <= 0xDF) goto yy1346; + if (yych <= 0xE0) goto yy1347; + goto yy1348; } } else { - if (yych <= '@') { - if (yych <= ';') { - if (yych >= ';') goto yy1284; - } else { - if (yych <= '=') goto yy1241; - if (yych <= '>') goto yy1243; - goto yy1284; - } + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1352; + if (yych <= 0xEF) goto yy1348; + goto yy1349; } else { - if (yych <= '_') { - if (yych <= 'Z') goto yy1293; - if (yych <= '^') goto yy1284; - } else { - if (yych <= '`') goto yy1241; - if (yych >= '{') goto yy1284; - } + if (yych <= 0xF3) goto yy1350; + if (yych <= 0xF4) goto yy1351; + goto yy1268; } } -yy1293: + ++p; + yych = *p; + if (yych <= 0xE0) { + if (yych <= '>') { + if (yych <= 0x00) goto yy1268; + if (yych <= '=') goto yy1335; + goto yy1285; + } else { + if (yych <= 0x7F) goto yy1335; + if (yych <= 0xC1) goto yy1268; + if (yych <= 0xDF) goto yy1353; + goto yy1354; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1359; + goto yy1355; + } else { + if (yych <= 0xF0) goto yy1356; + if (yych <= 0xF3) goto yy1357; + if (yych <= 0xF4) goto yy1358; + goto yy1268; + } + } +yy1346: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1335; + goto yy1268; +yy1347: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1346; + goto yy1268; +yy1348: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1346; + goto yy1268; +yy1349: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1348; + goto yy1268; +yy1350: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1348; + goto yy1268; +yy1351: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1348; + goto yy1268; +yy1352: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1346; + goto yy1268; +yy1353: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1335; + goto yy1268; +yy1354: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1353; + goto yy1268; +yy1355: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1353; + goto yy1268; +yy1356: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1355; + goto yy1268; +yy1357: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1355; + goto yy1268; +yy1358: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1355; + goto yy1268; +yy1359: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1353; + goto yy1268; +yy1360: + ++p; + yych = *p; + if (yybm[0+yych] & 8) { + goto yy1360; + } + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1268; + if (yych >= 0x0E) goto yy1268; + } else { + if (yych <= ' ') goto yy1362; + if (yych == '>') goto yy1285; + goto yy1268; + } +yy1362: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1268; + if (yych <= '\r') goto yy1362; + goto yy1268; + } else { + if (yych <= ' ') goto yy1362; + if (yych == '>') goto yy1285; + goto yy1268; + } +yy1364: ++p; yych = *p; if (yych <= '/') { - if (yych <= '!') { - if (yych <= '\r') { - if (yych <= 0x00) goto yy1241; - if (yych <= 0x08) goto yy1284; - } else { - if (yych != ' ') goto yy1284; - } + if (yych <= ' ') { + if (yych <= 0x08) goto yy1268; + if (yych <= '\r') goto yy1366; + if (yych <= 0x1F) goto yy1268; } else { - if (yych <= '\'') { - if (yych <= '"') goto yy1241; - if (yych <= '&') goto yy1284; - goto yy1241; - } else { - if (yych <= ',') goto yy1284; - if (yych <= '.') goto yy1293; - goto yy1284; - } + if (yych == '-') goto yy1364; + if (yych <= '.') goto yy1268; + goto yy1368; } } else { if (yych <= '@') { - if (yych <= '<') { - if (yych <= ':') goto yy1293; - if (yych <= ';') goto yy1284; - goto yy1241; - } else { - if (yych <= '=') goto yy1282; - if (yych <= '>') goto yy1243; - goto yy1284; - } + if (yych <= '9') goto yy1364; + if (yych == '>') goto yy1285; + goto yy1268; } else { - if (yych <= '_') { - if (yych <= 'Z') goto yy1293; - if (yych <= '^') goto yy1284; - goto yy1293; - } else { - if (yych <= '`') goto yy1241; - if (yych <= 'z') goto yy1293; - goto yy1284; - } + if (yych <= 'Z') goto yy1364; + if (yych <= '`') goto yy1268; + if (yych <= 'z') goto yy1364; + goto yy1268; } } -yy1295: +yy1366: ++p; yych = *p; if (yych <= ':') { if (yych <= ' ') { - if (yych <= 0x08) { - if (yych <= 0x00) goto yy1241; - goto yy1284; - } else { - if (yych <= '\r') goto yy1295; - if (yych <= 0x1F) goto yy1284; - goto yy1295; - } + if (yych <= 0x08) goto yy1268; + if (yych <= '\r') goto yy1366; + if (yych <= 0x1F) goto yy1268; + goto yy1366; } else { - if (yych <= '&') { - if (yych == '"') goto yy1241; - goto yy1284; - } else { - if (yych <= '\'') goto yy1241; - if (yych <= '9') goto yy1284; - goto yy1293; - } + if (yych == '/') goto yy1368; + if (yych <= '9') goto yy1268; + goto yy1369; } } else { - if (yych <= '@') { - if (yych <= '<') { - if (yych <= ';') goto yy1284; - goto yy1241; - } else { - if (yych <= '=') goto yy1282; - if (yych <= '>') goto yy1243; - goto yy1284; - } + if (yych <= 'Z') { + if (yych == '>') goto yy1285; + if (yych <= '@') goto yy1268; + goto yy1369; } else { if (yych <= '_') { - if (yych <= 'Z') goto yy1293; - if (yych <= '^') goto yy1284; - goto yy1293; + if (yych <= '^') goto yy1268; + goto yy1369; } else { - if (yych <= '`') goto yy1241; - if (yych <= 'z') goto yy1293; - goto yy1284; + if (yych <= '`') goto yy1268; + if (yych <= 'z') goto yy1369; + goto yy1268; } } } -yy1297: +yy1368: + yych = *++p; + if (yych == '>') goto yy1285; + goto yy1268; +yy1369: ++p; yych = *p; - if (yych <= '9') { + if (yybm[0+yych] & 16) { + goto yy1369; + } + if (yych <= ',') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy1268; + } else { + if (yych != ' ') goto yy1268; + } + } else { + if (yych <= '<') { + if (yych <= '/') goto yy1368; + goto yy1268; + } else { + if (yych <= '=') goto yy1373; + if (yych <= '>') goto yy1285; + goto yy1268; + } + } +yy1371: + ++p; + yych = *p; + if (yych <= '<') { if (yych <= ' ') { - if (yych <= 0x08) { - if (yych <= 0x00) goto yy1241; - goto yy1284; - } else { - if (yych <= '\r') goto yy1297; - if (yych <= 0x1F) goto yy1284; - goto yy1297; - } + if (yych <= 0x08) goto yy1268; + if (yych <= '\r') goto yy1371; + if (yych <= 0x1F) goto yy1268; + goto yy1371; } else { - if (yych <= '"') { - if (yych <= '!') goto yy1284; - goto yy1288; + if (yych <= '/') { + if (yych <= '.') goto yy1268; + goto yy1368; } else { - if (yych == '\'') goto yy1286; - goto yy1284; + if (yych == ':') goto yy1369; + goto yy1268; } } } else { - if (yych <= '@') { - if (yych <= ';') { - if (yych <= ':') goto yy1293; - goto yy1284; - } else { - if (yych <= '=') goto yy1241; - if (yych <= '>') goto yy1243; - goto yy1284; - } + if (yych <= 'Z') { + if (yych <= '=') goto yy1373; + if (yych <= '>') goto yy1285; + if (yych <= '@') goto yy1268; + goto yy1369; } else { if (yych <= '_') { - if (yych <= 'Z') goto yy1293; - if (yych <= '^') goto yy1284; - goto yy1293; + if (yych <= '^') goto yy1268; + goto yy1369; } else { - if (yych <= '`') goto yy1241; - if (yych <= 'z') goto yy1293; - goto yy1284; + if (yych <= '`') goto yy1268; + if (yych <= 'z') goto yy1369; + goto yy1268; } } } -} - -} - -// Try to match an HTML block tag including first <, -// returning num of chars matched. -bufsize_t _scan_html_block_tag(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; - -{ - unsigned char yych; +yy1373: + ++p; yych = *p; - if (yych == '\n') goto yy1301; - if (yych == '<') goto yy1302; - goto yy1303; -yy1301: - { return 0; } -yy1302: - yych = *(marker = ++p); - switch (yych) { - case '!': - case '?': goto yy1304; - case '/': goto yy1323; - case 'A': - case 'a': goto yy1308; - case 'B': - case 'b': goto yy1311; - case 'C': - case 'c': goto yy1315; - case 'D': - case 'd': goto yy1316; - case 'E': - case 'e': goto yy1319; - case 'F': - case 'f': goto yy1320; - case 'H': - case 'h': goto yy1309; - case 'I': - case 'i': goto yy1310; - case 'L': - case 'l': goto yy1312; - case 'M': - case 'm': goto yy1313; - case 'O': - case 'o': goto yy1314; - case 'P': - case 'p': goto yy1306; - case 'S': - case 's': goto yy1317; - case 'T': - case 't': goto yy1318; - case 'U': - case 'u': goto yy1321; - case 'V': - case 'v': goto yy1322; - default: goto yy1301; + if (yybm[0+yych] & 32) { + goto yy1375; + } + if (yych <= 0xE0) { + if (yych <= '"') { + if (yych <= 0x00) goto yy1268; + if (yych >= '!') goto yy1386; + } else { + if (yych <= '\'') goto yy1384; + if (yych <= 0xC1) goto yy1268; + if (yych <= 0xDF) goto yy1377; + goto yy1378; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1383; + goto yy1379; + } else { + if (yych <= 0xF0) goto yy1380; + if (yych <= 0xF3) goto yy1381; + if (yych <= 0xF4) goto yy1382; + goto yy1268; + } } -yy1303: - yych = *++p; - goto yy1301; -yy1304: ++p; - { return (bufsize_t)(p - start); } -yy1306: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1307; - if (yych <= '\r') goto yy1467; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1375; + } + if (yych <= 0xDF) { + if (yych <= '\'') { + if (yych <= 0x00) goto yy1268; + if (yych <= ' ') goto yy1409; + if (yych <= '"') goto yy1386; + goto yy1384; } else { - if (yych <= ' ') goto yy1467; - if (yych >= '/') goto yy1467; + if (yych == '>') goto yy1285; + if (yych <= 0xC1) goto yy1268; + goto yy1377; } } else { - if (yych <= 'Q') { - if (yych == '>') goto yy1467; + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1378; + if (yych == 0xED) goto yy1383; + goto yy1379; } else { - if (yych <= 'R') goto yy1580; - if (yych == 'r') goto yy1580; + if (yych <= 0xF0) goto yy1380; + if (yych <= 0xF3) goto yy1381; + if (yych <= 0xF4) goto yy1382; + goto yy1268; } } -yy1307: - p = marker; - goto yy1301; -yy1308: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'Q') goto yy1307; - if (yych <= 'R') goto yy1573; - goto yy1572; +yy1375: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1375; + } + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych <= 0x00) goto yy1268; + if (yych <= ' ') goto yy1403; + goto yy1268; + } else { + if (yych <= '>') goto yy1285; + if (yych <= 0xC1) goto yy1268; + if (yych >= 0xE0) goto yy1378; + } } else { - if (yych <= 'q') goto yy1307; - if (yych <= 'r') goto yy1573; - if (yych <= 's') goto yy1572; - goto yy1307; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1383; + goto yy1379; + } else { + if (yych <= 0xF0) goto yy1380; + if (yych <= 0xF3) goto yy1381; + if (yych <= 0xF4) goto yy1382; + goto yy1268; + } } -yy1309: - yych = *++p; - if (yych <= 'Q') { - if (yych <= 'D') { - if (yych <= '0') goto yy1307; - if (yych <= '6') goto yy1466; - goto yy1307; +yy1377: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1375; + goto yy1268; +yy1378: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1377; + goto yy1268; +yy1379: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1377; + goto yy1268; +yy1380: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1379; + goto yy1268; +yy1381: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1379; + goto yy1268; +yy1382: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1379; + goto yy1268; +yy1383: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1377; + goto yy1268; +yy1384: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1384; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy1268; + if (yych <= '\'') goto yy1395; + goto yy1268; } else { - if (yych <= 'E') goto yy1565; - if (yych == 'G') goto yy1564; - goto yy1307; + if (yych <= 0xDF) goto yy1396; + if (yych <= 0xE0) goto yy1397; + goto yy1398; } } else { - if (yych <= 'f') { - if (yych <= 'R') goto yy1466; - if (yych == 'e') goto yy1565; - goto yy1307; + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1402; + if (yych <= 0xEF) goto yy1398; + goto yy1399; } else { - if (yych <= 'g') goto yy1564; - if (yych == 'r') goto yy1466; - goto yy1307; + if (yych <= 0xF3) goto yy1400; + if (yych <= 0xF4) goto yy1401; + goto yy1268; } } -yy1310: - yych = *++p; - if (yych == 'F') goto yy1560; - if (yych == 'f') goto yy1560; - goto yy1307; -yy1311: - yych = *++p; - if (yych <= 'U') { - if (yych <= 'N') { - if (yych == 'L') goto yy1548; - goto yy1307; +yy1386: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1386; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy1268; + if (yych <= '"') goto yy1395; + goto yy1268; } else { - if (yych <= 'O') goto yy1547; - if (yych <= 'T') goto yy1307; - goto yy1546; + if (yych <= 0xDF) goto yy1388; + if (yych <= 0xE0) goto yy1389; + goto yy1390; } } else { - if (yych <= 'n') { - if (yych == 'l') goto yy1548; - goto yy1307; + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1394; + if (yych <= 0xEF) goto yy1390; + goto yy1391; } else { - if (yych <= 'o') goto yy1547; - if (yych == 'u') goto yy1546; - goto yy1307; + if (yych <= 0xF3) goto yy1392; + if (yych <= 0xF4) goto yy1393; + goto yy1268; } } -yy1312: - yych = *++p; - if (yych == 'I') goto yy1466; - if (yych == 'i') goto yy1466; - goto yy1307; -yy1313: - yych = *++p; - if (yych == 'A') goto yy1545; - if (yych == 'a') goto yy1545; - goto yy1307; -yy1314: - yych = *++p; - if (yych <= 'U') { - if (yych <= 'K') { - if (yych == 'B') goto yy1538; - goto yy1307; +yy1388: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1386; + goto yy1268; +yy1389: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1388; + goto yy1268; +yy1390: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1388; + goto yy1268; +yy1391: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1390; + goto yy1268; +yy1392: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1390; + goto yy1268; +yy1393: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1390; + goto yy1268; +yy1394: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1388; + goto yy1268; +yy1395: + ++p; + yych = *p; + if (yych <= ' ') { + if (yych <= 0x08) goto yy1268; + if (yych <= '\r') goto yy1366; + if (yych <= 0x1F) goto yy1268; + goto yy1366; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy1268; + goto yy1368; } else { - if (yych <= 'L') goto yy1466; - if (yych <= 'T') goto yy1307; - goto yy1537; + if (yych == '>') goto yy1285; + goto yy1268; + } + } +yy1396: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1384; + goto yy1268; +yy1397: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1268; + if (yych <= 0xBF) goto yy1396; + goto yy1268; +yy1398: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1396; + goto yy1268; +yy1399: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1268; + if (yych <= 0xBF) goto yy1398; + goto yy1268; +yy1400: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0xBF) goto yy1398; + goto yy1268; +yy1401: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x8F) goto yy1398; + goto yy1268; +yy1402: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1268; + if (yych <= 0x9F) goto yy1396; + goto yy1268; +yy1403: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '"') { + if (yych <= '\r') { + if (yych <= 0x00) goto yy1268; + if (yych <= 0x08) goto yy1375; + goto yy1403; + } else { + if (yych == ' ') goto yy1403; + if (yych <= '!') goto yy1375; + goto yy1268; + } + } else { + if (yych <= ':') { + if (yych == '\'') goto yy1268; + if (yych <= '9') goto yy1375; + } else { + if (yych <= ';') goto yy1375; + if (yych <= '=') goto yy1268; + if (yych <= '>') goto yy1285; + goto yy1375; + } } } else { - if (yych <= 'k') { - if (yych == 'b') goto yy1538; - goto yy1307; + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') goto yy1405; + if (yych <= '^') goto yy1375; + if (yych >= '`') goto yy1268; + } else { + if (yych <= 'z') goto yy1405; + if (yych <= 0x7F) goto yy1375; + if (yych <= 0xC1) goto yy1268; + goto yy1377; + } } else { - if (yych <= 'l') goto yy1466; - if (yych == 'u') goto yy1537; - goto yy1307; + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1378; + if (yych == 0xED) goto yy1383; + goto yy1379; + } else { + if (yych <= 0xF0) goto yy1380; + if (yych <= 0xF3) goto yy1381; + if (yych <= 0xF4) goto yy1382; + goto yy1268; + } } } -yy1315: - yych = *++p; - if (yych <= 'O') { - if (yych == 'A') goto yy1524; - if (yych <= 'N') goto yy1307; - goto yy1523; +yy1405: + ++p; + yych = *p; + if (yych <= '>') { + if (yych <= '&') { + if (yych <= 0x1F) { + if (yych <= 0x00) goto yy1268; + if (yych <= 0x08) goto yy1375; + if (yych >= 0x0E) goto yy1375; + } else { + if (yych <= ' ') goto yy1407; + if (yych == '"') goto yy1268; + goto yy1375; + } + } else { + if (yych <= '/') { + if (yych <= '\'') goto yy1268; + if (yych <= ',') goto yy1375; + if (yych <= '.') goto yy1405; + goto yy1375; + } else { + if (yych <= ';') { + if (yych <= ':') goto yy1405; + goto yy1375; + } else { + if (yych <= '<') goto yy1268; + if (yych <= '=') goto yy1373; + goto yy1285; + } + } + } } else { - if (yych <= 'a') { - if (yych <= '`') goto yy1307; - goto yy1524; + if (yych <= 0xC1) { + if (yych <= '_') { + if (yych <= '@') goto yy1375; + if (yych <= 'Z') goto yy1405; + if (yych <= '^') goto yy1375; + goto yy1405; + } else { + if (yych <= '`') goto yy1268; + if (yych <= 'z') goto yy1405; + if (yych <= 0x7F) goto yy1375; + goto yy1268; + } } else { - if (yych == 'o') goto yy1523; - goto yy1307; + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1377; + if (yych <= 0xE0) goto yy1378; + if (yych <= 0xEC) goto yy1379; + goto yy1383; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1379; + goto yy1380; + } else { + if (yych <= 0xF3) goto yy1381; + if (yych <= 0xF4) goto yy1382; + goto yy1268; + } + } } } -yy1316: - yych = *++p; - if (yych <= 'T') { - if (yych <= 'I') { - if (yych == 'D') goto yy1466; - if (yych <= 'H') goto yy1307; - goto yy1522; +yy1407: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '&') { + if (yych <= 0x1F) { + if (yych <= 0x00) goto yy1268; + if (yych <= 0x08) goto yy1375; + if (yych <= '\r') goto yy1407; + goto yy1375; + } else { + if (yych <= ' ') goto yy1407; + if (yych == '"') goto yy1268; + goto yy1375; + } + } else { + if (yych <= ';') { + if (yych <= '\'') goto yy1268; + if (yych == ':') goto yy1405; + goto yy1375; + } else { + if (yych <= '<') goto yy1268; + if (yych <= '=') goto yy1373; + if (yych <= '>') goto yy1285; + goto yy1375; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') goto yy1405; + if (yych <= '^') goto yy1375; + if (yych <= '_') goto yy1405; + goto yy1268; + } else { + if (yych <= 'z') goto yy1405; + if (yych <= 0x7F) goto yy1375; + if (yych <= 0xC1) goto yy1268; + goto yy1377; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1378; + if (yych == 0xED) goto yy1383; + goto yy1379; + } else { + if (yych <= 0xF0) goto yy1380; + if (yych <= 0xF3) goto yy1381; + if (yych <= 0xF4) goto yy1382; + goto yy1268; + } + } + } +yy1409: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '"') { + if (yych <= '\r') { + if (yych <= 0x00) goto yy1268; + if (yych <= 0x08) goto yy1375; + goto yy1409; + } else { + if (yych == ' ') goto yy1409; + if (yych <= '!') goto yy1375; + goto yy1386; + } } else { - if (yych == 'L') goto yy1466; - if (yych <= 'S') goto yy1307; - goto yy1466; + if (yych <= ':') { + if (yych == '\'') goto yy1384; + if (yych <= '9') goto yy1375; + goto yy1405; + } else { + if (yych <= ';') goto yy1375; + if (yych <= '=') goto yy1268; + if (yych <= '>') goto yy1285; + goto yy1375; + } } } else { - if (yych <= 'i') { - if (yych == 'd') goto yy1466; - if (yych <= 'h') goto yy1307; - goto yy1522; + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') goto yy1405; + if (yych <= '^') goto yy1375; + if (yych <= '_') goto yy1405; + goto yy1268; + } else { + if (yych <= 'z') goto yy1405; + if (yych <= 0x7F) goto yy1375; + if (yych <= 0xC1) goto yy1268; + goto yy1377; + } } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy1307; - goto yy1466; + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1378; + if (yych == 0xED) goto yy1383; + goto yy1379; } else { - if (yych == 't') goto yy1466; - goto yy1307; + if (yych <= 0xF0) goto yy1380; + if (yych <= 0xF3) goto yy1381; + if (yych <= 0xF4) goto yy1382; + goto yy1268; } } } -yy1317: - yych = *++p; - if (yych <= 'T') { - if (yych <= 'D') { - if (yych == 'C') goto yy1511; - goto yy1307; +} + +} + +// Try to match an HTML block tag start line, returning +// an integer code for the type of block (1-6, matching the spec). +// #7 is handled by a separate function, below. +bufsize_t _scan_html_block_start(const unsigned char *p) +{ + const unsigned char *marker = NULL; + +{ + unsigned char yych; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= ';') { + if (yych != '\n') goto yy1415; } else { - if (yych <= 'E') goto yy1512; - if (yych <= 'S') goto yy1307; - goto yy1510; + if (yych <= '<') goto yy1414; + if (yych <= 0x7F) goto yy1415; + if (yych >= 0xC2) goto yy1416; } } else { - if (yych <= 'd') { - if (yych == 'c') goto yy1511; - goto yy1307; + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1418; + if (yych == 0xED) goto yy1423; + goto yy1419; } else { - if (yych <= 'e') goto yy1512; - if (yych == 't') goto yy1510; - goto yy1307; + if (yych <= 0xF0) goto yy1420; + if (yych <= 0xF3) goto yy1421; + if (yych <= 0xF4) goto yy1422; } } -yy1318: - yych = *++p; +yy1413: + { return 0; } +yy1414: + yych = *(marker = ++p); switch (yych) { + case '!': goto yy1439; + case '/': goto yy1424; + case '?': goto yy1440; case 'A': - case 'a': goto yy1496; + case 'a': goto yy1426; case 'B': - case 'b': goto yy1495; + case 'b': goto yy1427; + case 'C': + case 'c': goto yy1428; case 'D': - case 'R': - case 'd': - case 'r': goto yy1466; - case 'E': - case 'e': goto yy1494; + case 'd': goto yy1429; case 'F': - case 'f': goto yy1493; + case 'f': goto yy1430; case 'H': - case 'h': goto yy1492; - default: goto yy1307; + case 'h': goto yy1431; + case 'L': + case 'l': goto yy1432; + case 'M': + case 'm': goto yy1433; + case 'N': + case 'n': goto yy1434; + case 'O': + case 'o': goto yy1435; + case 'P': + case 'p': goto yy1425; + case 'S': + case 's': goto yy1436; + case 'T': + case 't': goto yy1437; + case 'U': + case 'u': goto yy1438; + default: goto yy1413; } -yy1319: +yy1415: yych = *++p; - if (yych == 'M') goto yy1489; - if (yych == 'm') goto yy1489; - goto yy1307; -yy1320: + goto yy1413; +yy1416: yych = *++p; - if (yych <= 'O') { - if (yych == 'I') goto yy1470; - if (yych <= 'N') goto yy1307; - goto yy1469; - } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy1307; - goto yy1470; - } else { - if (yych == 'o') goto yy1469; - goto yy1307; - } - } -yy1321: + if (yych <= 0x7F) goto yy1417; + if (yych <= 0xBF) goto yy1415; +yy1417: + p = marker; + goto yy1413; +yy1418: yych = *++p; - if (yych == 'L') goto yy1466; - if (yych == 'l') goto yy1466; - goto yy1307; -yy1322: + if (yych <= 0x9F) goto yy1417; + if (yych <= 0xBF) goto yy1416; + goto yy1417; +yy1419: yych = *++p; - if (yych == 'I') goto yy1463; - if (yych == 'i') goto yy1463; - goto yy1307; -yy1323: + if (yych <= 0x7F) goto yy1417; + if (yych <= 0xBF) goto yy1416; + goto yy1417; +yy1420: + yych = *++p; + if (yych <= 0x8F) goto yy1417; + if (yych <= 0xBF) goto yy1419; + goto yy1417; +yy1421: + yych = *++p; + if (yych <= 0x7F) goto yy1417; + if (yych <= 0xBF) goto yy1419; + goto yy1417; +yy1422: + yych = *++p; + if (yych <= 0x7F) goto yy1417; + if (yych <= 0x8F) goto yy1419; + goto yy1417; +yy1423: + yych = *++p; + if (yych <= 0x7F) goto yy1417; + if (yych <= 0x9F) goto yy1416; + goto yy1417; +yy1424: yych = *++p; switch (yych) { case 'A': - case 'a': goto yy1325; + case 'a': goto yy1426; case 'B': - case 'b': goto yy1328; + case 'b': goto yy1427; case 'C': - case 'c': goto yy1332; + case 'c': goto yy1428; case 'D': - case 'd': goto yy1333; - case 'E': - case 'e': goto yy1336; + case 'd': goto yy1429; case 'F': - case 'f': goto yy1337; + case 'f': goto yy1430; case 'H': - case 'h': goto yy1326; - case 'I': - case 'i': goto yy1327; + case 'h': goto yy1431; case 'L': - case 'l': goto yy1329; + case 'l': goto yy1432; case 'M': - case 'm': goto yy1330; + case 'm': goto yy1433; + case 'N': + case 'n': goto yy1434; case 'O': - case 'o': goto yy1331; + case 'o': goto yy1435; case 'P': - case 'p': goto yy1324; + case 'p': goto yy1622; case 'S': - case 's': goto yy1334; + case 's': goto yy1623; case 'T': - case 't': goto yy1335; + case 't': goto yy1437; case 'U': - case 'u': goto yy1338; - case 'V': - case 'v': goto yy1339; - default: goto yy1307; + case 'u': goto yy1438; + default: goto yy1417; } -yy1324: +yy1425: yych = *++p; - if (yych <= '=') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy1307; - goto yy1344; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + if (yych <= 0x1F) goto yy1417; + goto yy1456; } else { - if (yych == ' ') goto yy1344; - goto yy1307; + if (yych == '/') goto yy1458; + if (yych <= '=') goto yy1417; + goto yy1456; } } else { if (yych <= 'R') { - if (yych <= '>') goto yy1344; - if (yych <= 'Q') goto yy1307; - goto yy1457; + if (yych == 'A') goto yy1617; + if (yych <= 'Q') goto yy1417; + goto yy1616; } else { - if (yych == 'r') goto yy1457; - goto yy1307; + if (yych <= 'a') { + if (yych <= '`') goto yy1417; + goto yy1617; + } else { + if (yych == 'r') goto yy1616; + goto yy1417; + } } } -yy1325: +yy1426: yych = *++p; if (yych <= 'S') { - if (yych <= 'Q') goto yy1307; - if (yych <= 'R') goto yy1450; - goto yy1449; + if (yych <= 'D') { + if (yych <= 'C') goto yy1417; + goto yy1605; + } else { + if (yych <= 'Q') goto yy1417; + if (yych <= 'R') goto yy1604; + goto yy1603; + } } else { - if (yych <= 'q') goto yy1307; - if (yych <= 'r') goto yy1450; - if (yych <= 's') goto yy1449; - goto yy1307; + if (yych <= 'q') { + if (yych == 'd') goto yy1605; + goto yy1417; + } else { + if (yych <= 'r') goto yy1604; + if (yych <= 's') goto yy1603; + goto yy1417; + } } -yy1326: +yy1427: yych = *++p; - if (yych <= 'Q') { + if (yych <= 'O') { + if (yych <= 'K') { + if (yych == 'A') goto yy1589; + goto yy1417; + } else { + if (yych <= 'L') goto yy1588; + if (yych <= 'N') goto yy1417; + goto yy1587; + } + } else { + if (yych <= 'k') { + if (yych == 'a') goto yy1589; + goto yy1417; + } else { + if (yych <= 'l') goto yy1588; + if (yych == 'o') goto yy1587; + goto yy1417; + } + } +yy1428: + yych = *++p; + if (yych <= 'O') { if (yych <= 'D') { - if (yych <= '0') goto yy1307; - if (yych <= '6') goto yy1343; - goto yy1307; + if (yych == 'A') goto yy1574; + goto yy1417; } else { - if (yych <= 'E') goto yy1442; - if (yych == 'G') goto yy1441; - goto yy1307; + if (yych <= 'E') goto yy1573; + if (yych <= 'N') goto yy1417; + goto yy1572; } } else { - if (yych <= 'f') { - if (yych <= 'R') goto yy1343; - if (yych == 'e') goto yy1442; - goto yy1307; + if (yych <= 'd') { + if (yych == 'a') goto yy1574; + goto yy1417; } else { - if (yych <= 'g') goto yy1441; - if (yych == 'r') goto yy1343; - goto yy1307; + if (yych <= 'e') goto yy1573; + if (yych == 'o') goto yy1572; + goto yy1417; } } -yy1327: +yy1429: yych = *++p; - if (yych == 'F') goto yy1437; - if (yych == 'f') goto yy1437; - goto yy1307; -yy1328: + switch (yych) { + case 'D': + case 'L': + case 'T': + case 'd': + case 'l': + case 't': goto yy1455; + case 'E': + case 'e': goto yy1564; + case 'I': + case 'i': goto yy1563; + default: goto yy1417; + } +yy1430: yych = *++p; - if (yych <= 'U') { + if (yych <= 'R') { if (yych <= 'N') { - if (yych == 'L') goto yy1425; - goto yy1307; + if (yych == 'I') goto yy1539; + goto yy1417; } else { - if (yych <= 'O') goto yy1424; - if (yych <= 'T') goto yy1307; - goto yy1423; + if (yych <= 'O') goto yy1538; + if (yych <= 'Q') goto yy1417; + goto yy1537; } } else { if (yych <= 'n') { - if (yych == 'l') goto yy1425; - goto yy1307; + if (yych == 'i') goto yy1539; + goto yy1417; } else { - if (yych <= 'o') goto yy1424; - if (yych == 'u') goto yy1423; - goto yy1307; + if (yych <= 'o') goto yy1538; + if (yych == 'r') goto yy1537; + goto yy1417; } } -yy1329: - yych = *++p; - if (yych == 'I') goto yy1343; - if (yych == 'i') goto yy1343; - goto yy1307; -yy1330: - yych = *++p; - if (yych == 'A') goto yy1422; - if (yych == 'a') goto yy1422; - goto yy1307; -yy1331: +yy1431: yych = *++p; - if (yych <= 'U') { - if (yych <= 'K') { - if (yych == 'B') goto yy1415; - goto yy1307; + if (yych <= 'S') { + if (yych <= 'D') { + if (yych == '1') goto yy1455; + goto yy1417; } else { - if (yych <= 'L') goto yy1343; - if (yych <= 'T') goto yy1307; - goto yy1414; + if (yych <= 'E') goto yy1532; + if (yych == 'R') goto yy1455; + goto yy1417; } } else { - if (yych <= 'k') { - if (yych == 'b') goto yy1415; - goto yy1307; + if (yych <= 'q') { + if (yych <= 'T') goto yy1531; + if (yych == 'e') goto yy1532; + goto yy1417; } else { - if (yych <= 'l') goto yy1343; - if (yych == 'u') goto yy1414; - goto yy1307; + if (yych <= 'r') goto yy1455; + if (yych == 't') goto yy1531; + goto yy1417; } } -yy1332: +yy1432: yych = *++p; - if (yych <= 'O') { - if (yych == 'A') goto yy1401; - if (yych <= 'N') goto yy1307; - goto yy1400; + if (yych <= 'I') { + if (yych == 'E') goto yy1526; + if (yych <= 'H') goto yy1417; + goto yy1525; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy1417; + goto yy1526; + } else { + if (yych == 'i') goto yy1525; + goto yy1417; + } + } +yy1433: + yych = *++p; + if (yych <= 'E') { + if (yych == 'A') goto yy1517; + if (yych <= 'D') goto yy1417; + goto yy1516; } else { if (yych <= 'a') { - if (yych <= '`') goto yy1307; - goto yy1401; + if (yych <= '`') goto yy1417; + goto yy1517; } else { - if (yych == 'o') goto yy1400; - goto yy1307; + if (yych == 'e') goto yy1516; + goto yy1417; } } -yy1333: +yy1434: yych = *++p; - if (yych <= 'T') { - if (yych <= 'I') { - if (yych == 'D') goto yy1343; - if (yych <= 'H') goto yy1307; - goto yy1399; + if (yych <= 'O') { + if (yych == 'A') goto yy1510; + if (yych <= 'N') goto yy1417; + goto yy1509; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy1417; + goto yy1510; } else { - if (yych == 'L') goto yy1343; - if (yych <= 'S') goto yy1307; - goto yy1343; + if (yych == 'o') goto yy1509; + goto yy1417; } + } +yy1435: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') goto yy1455; + if (yych <= 'O') goto yy1417; + goto yy1501; } else { - if (yych <= 'i') { - if (yych == 'd') goto yy1343; - if (yych <= 'h') goto yy1307; - goto yy1399; + if (yych <= 'l') { + if (yych <= 'k') goto yy1417; + goto yy1455; } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy1307; - goto yy1343; - } else { - if (yych == 't') goto yy1343; - goto yy1307; - } + if (yych == 'p') goto yy1501; + goto yy1417; } } -yy1334: +yy1436: yych = *++p; - if (yych <= 'T') { - if (yych <= 'D') { - if (yych == 'C') goto yy1388; - goto yy1307; + if (yych <= 'U') { + if (yych <= 'E') { + if (yych == 'C') goto yy1478; + if (yych <= 'D') goto yy1417; + goto yy1481; } else { - if (yych <= 'E') goto yy1389; - if (yych <= 'S') goto yy1307; - goto yy1387; + if (yych <= 'O') { + if (yych <= 'N') goto yy1417; + goto yy1480; + } else { + if (yych <= 'S') goto yy1417; + if (yych <= 'T') goto yy1477; + goto yy1479; + } } } else { - if (yych <= 'd') { - if (yych == 'c') goto yy1388; - goto yy1307; + if (yych <= 'n') { + if (yych <= 'c') { + if (yych <= 'b') goto yy1417; + goto yy1478; + } else { + if (yych == 'e') goto yy1481; + goto yy1417; + } } else { - if (yych <= 'e') goto yy1389; - if (yych == 't') goto yy1387; - goto yy1307; + if (yych <= 's') { + if (yych <= 'o') goto yy1480; + goto yy1417; + } else { + if (yych <= 't') goto yy1477; + if (yych <= 'u') goto yy1479; + goto yy1417; + } } } -yy1335: +yy1437: yych = *++p; switch (yych) { case 'A': - case 'a': goto yy1373; + case 'a': goto yy1464; case 'B': - case 'b': goto yy1372; + case 'b': goto yy1463; case 'D': - case 'R': - case 'd': - case 'r': goto yy1343; - case 'E': - case 'e': goto yy1371; + case 'd': goto yy1455; case 'F': - case 'f': goto yy1370; + case 'f': goto yy1462; case 'H': - case 'h': goto yy1369; - default: goto yy1307; + case 'h': goto yy1461; + case 'I': + case 'i': goto yy1460; + case 'R': + case 'r': goto yy1459; + default: goto yy1417; } -yy1336: +yy1438: yych = *++p; - if (yych == 'M') goto yy1366; - if (yych == 'm') goto yy1366; - goto yy1307; -yy1337: + if (yych == 'L') goto yy1455; + if (yych == 'l') goto yy1455; + goto yy1417; +yy1439: yych = *++p; - if (yych <= 'O') { - if (yych == 'I') goto yy1347; - if (yych <= 'N') goto yy1307; - goto yy1346; + if (yych <= '@') { + if (yych == '-') goto yy1442; + goto yy1417; } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy1307; - goto yy1347; - } else { - if (yych == 'o') goto yy1346; - goto yy1307; - } + if (yych <= 'Z') goto yy1443; + if (yych <= '[') goto yy1445; + goto yy1417; } -yy1338: +yy1440: + ++p; + { return 3; } +yy1442: yych = *++p; - if (yych == 'L') goto yy1343; - if (yych == 'l') goto yy1343; - goto yy1307; -yy1339: + if (yych == '-') goto yy1453; + goto yy1417; +yy1443: + ++p; + { return 4; } +yy1445: yych = *++p; - if (yych == 'I') goto yy1340; - if (yych != 'i') goto yy1307; -yy1340: + if (yych == 'C') goto yy1446; + if (yych != 'c') goto yy1417; +yy1446: yych = *++p; - if (yych == 'D') goto yy1341; - if (yych != 'd') goto yy1307; -yy1341: + if (yych == 'D') goto yy1447; + if (yych != 'd') goto yy1417; +yy1447: yych = *++p; - if (yych == 'E') goto yy1342; - if (yych != 'e') goto yy1307; -yy1342: + if (yych == 'A') goto yy1448; + if (yych != 'a') goto yy1417; +yy1448: yych = *++p; - if (yych == 'O') goto yy1343; - if (yych != 'o') goto yy1307; -yy1343: + if (yych == 'T') goto yy1449; + if (yych != 't') goto yy1417; +yy1449: yych = *++p; - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1307; - if (yych >= 0x0E) goto yy1307; - } else { - if (yych <= ' ') goto yy1344; - if (yych != '>') goto yy1307; - } -yy1344: + if (yych == 'A') goto yy1450; + if (yych != 'a') goto yy1417; +yy1450: + yych = *++p; + if (yych != '[') goto yy1417; ++p; - { return (bufsize_t)(p - start); } -yy1346: + { return 5; } +yy1453: + ++p; + { return 2; } +yy1455: yych = *++p; - if (yych <= 'R') { - if (yych == 'O') goto yy1362; - if (yych <= 'Q') goto yy1307; - goto yy1363; + if (yych <= ' ') { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + if (yych <= 0x1F) goto yy1417; } else { - if (yych <= 'o') { - if (yych <= 'n') goto yy1307; - goto yy1362; + if (yych <= '/') { + if (yych <= '.') goto yy1417; + goto yy1458; } else { - if (yych == 'r') goto yy1363; - goto yy1307; + if (yych != '>') goto yy1417; } } -yy1347: +yy1456: + ++p; + { return 6; } +yy1458: yych = *++p; - if (yych <= 'G') { - if (yych == 'E') goto yy1348; - if (yych <= 'F') goto yy1307; - goto yy1349; + if (yych == '>') goto yy1456; + goto yy1417; +yy1459: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + goto yy1417; + } else { + if (yych <= ' ') goto yy1456; + if (yych <= '.') goto yy1417; + goto yy1458; + } } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy1307; + if (yych <= '@') { + if (yych == '>') goto yy1456; + goto yy1417; } else { - if (yych == 'g') goto yy1349; - goto yy1307; + if (yych <= 'A') goto yy1475; + if (yych == 'a') goto yy1475; + goto yy1417; } } -yy1348: +yy1460: yych = *++p; - if (yych == 'L') goto yy1358; - if (yych == 'l') goto yy1358; - goto yy1307; -yy1349: + if (yych == 'T') goto yy1473; + if (yych == 't') goto yy1473; + goto yy1417; +yy1461: yych = *++p; - if (yych <= 'U') { - if (yych == 'C') goto yy1351; - if (yych <= 'T') goto yy1307; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + goto yy1417; + } else { + if (yych <= ' ') goto yy1456; + if (yych <= '.') goto yy1417; + goto yy1458; + } } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy1307; - goto yy1351; + if (yych <= 'D') { + if (yych == '>') goto yy1456; + goto yy1417; } else { - if (yych != 'u') goto yy1307; + if (yych <= 'E') goto yy1471; + if (yych == 'e') goto yy1471; + goto yy1417; } } +yy1462: yych = *++p; - if (yych == 'R') goto yy1357; - if (yych == 'r') goto yy1357; - goto yy1307; -yy1351: + if (yych == 'O') goto yy1469; + if (yych == 'o') goto yy1469; + goto yy1417; +yy1463: yych = *++p; - if (yych == 'A') goto yy1352; - if (yych != 'a') goto yy1307; -yy1352: + if (yych == 'O') goto yy1467; + if (yych == 'o') goto yy1467; + goto yy1417; +yy1464: yych = *++p; - if (yych == 'P') goto yy1353; - if (yych != 'p') goto yy1307; -yy1353: + if (yych == 'B') goto yy1465; + if (yych != 'b') goto yy1417; +yy1465: yych = *++p; - if (yych == 'T') goto yy1354; - if (yych != 't') goto yy1307; -yy1354: + if (yych == 'L') goto yy1466; + if (yych != 'l') goto yy1417; +yy1466: yych = *++p; - if (yych == 'I') goto yy1355; - if (yych != 'i') goto yy1307; -yy1355: + if (yych == 'E') goto yy1455; + if (yych == 'e') goto yy1455; + goto yy1417; +yy1467: yych = *++p; - if (yych == 'O') goto yy1356; - if (yych != 'o') goto yy1307; -yy1356: + if (yych == 'D') goto yy1468; + if (yych != 'd') goto yy1417; +yy1468: yych = *++p; - if (yych == 'N') goto yy1343; - if (yych == 'n') goto yy1343; - goto yy1307; -yy1357: + if (yych == 'Y') goto yy1455; + if (yych == 'y') goto yy1455; + goto yy1417; +yy1469: yych = *++p; - if (yych == 'E') goto yy1343; - if (yych == 'e') goto yy1343; - goto yy1307; -yy1358: + if (yych == 'O') goto yy1470; + if (yych != 'o') goto yy1417; +yy1470: yych = *++p; - if (yych == 'D') goto yy1359; - if (yych != 'd') goto yy1307; -yy1359: + if (yych == 'T') goto yy1455; + if (yych == 't') goto yy1455; + goto yy1417; +yy1471: yych = *++p; - if (yych == 'S') goto yy1360; - if (yych != 's') goto yy1307; -yy1360: + if (yych == 'A') goto yy1472; + if (yych != 'a') goto yy1417; +yy1472: yych = *++p; - if (yych == 'E') goto yy1361; - if (yych != 'e') goto yy1307; -yy1361: + if (yych == 'D') goto yy1455; + if (yych == 'd') goto yy1455; + goto yy1417; +yy1473: yych = *++p; - if (yych == 'T') goto yy1343; - if (yych == 't') goto yy1343; - goto yy1307; -yy1362: + if (yych == 'L') goto yy1474; + if (yych != 'l') goto yy1417; +yy1474: yych = *++p; - if (yych == 'T') goto yy1364; - if (yych == 't') goto yy1364; - goto yy1307; -yy1363: + if (yych == 'E') goto yy1455; + if (yych == 'e') goto yy1455; + goto yy1417; +yy1475: yych = *++p; - if (yych == 'M') goto yy1343; - if (yych == 'm') goto yy1343; - goto yy1307; -yy1364: + if (yych == 'C') goto yy1476; + if (yych != 'c') goto yy1417; +yy1476: yych = *++p; - if (yych == 'E') goto yy1365; - if (yych != 'e') goto yy1307; -yy1365: + if (yych == 'K') goto yy1455; + if (yych == 'k') goto yy1455; + goto yy1417; +yy1477: yych = *++p; - if (yych == 'R') goto yy1343; - if (yych == 'r') goto yy1343; - goto yy1307; -yy1366: + if (yych == 'Y') goto yy1499; + if (yych == 'y') goto yy1499; + goto yy1417; +yy1478: yych = *++p; - if (yych == 'B') goto yy1367; - if (yych != 'b') goto yy1307; -yy1367: + if (yych == 'R') goto yy1493; + if (yych == 'r') goto yy1493; + goto yy1417; +yy1479: yych = *++p; - if (yych == 'E') goto yy1368; - if (yych != 'e') goto yy1307; -yy1368: + if (yych == 'M') goto yy1489; + if (yych == 'm') goto yy1489; + goto yy1417; +yy1480: yych = *++p; - if (yych == 'D') goto yy1343; - if (yych == 'd') goto yy1343; - goto yy1307; -yy1369: + if (yych == 'U') goto yy1486; + if (yych == 'u') goto yy1486; + goto yy1417; +yy1481: yych = *++p; - if (yych <= '=') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy1307; - goto yy1344; - } else { - if (yych == ' ') goto yy1344; - goto yy1307; - } - } else { - if (yych <= 'E') { - if (yych <= '>') goto yy1344; - if (yych <= 'D') goto yy1307; - goto yy1385; - } else { - if (yych == 'e') goto yy1385; - goto yy1307; - } - } -yy1370: + if (yych == 'C') goto yy1482; + if (yych != 'c') goto yy1417; +yy1482: yych = *++p; - if (yych == 'O') goto yy1383; - if (yych == 'o') goto yy1383; - goto yy1307; -yy1371: + if (yych == 'T') goto yy1483; + if (yych != 't') goto yy1417; +yy1483: yych = *++p; - if (yych == 'X') goto yy1378; - if (yych == 'x') goto yy1378; - goto yy1307; -yy1372: + if (yych == 'I') goto yy1484; + if (yych != 'i') goto yy1417; +yy1484: yych = *++p; - if (yych == 'O') goto yy1376; - if (yych == 'o') goto yy1376; - goto yy1307; -yy1373: + if (yych == 'O') goto yy1485; + if (yych != 'o') goto yy1417; +yy1485: yych = *++p; - if (yych == 'B') goto yy1374; - if (yych != 'b') goto yy1307; -yy1374: + if (yych == 'N') goto yy1455; + if (yych == 'n') goto yy1455; + goto yy1417; +yy1486: yych = *++p; - if (yych == 'L') goto yy1375; - if (yych != 'l') goto yy1307; -yy1375: + if (yych == 'R') goto yy1487; + if (yych != 'r') goto yy1417; +yy1487: yych = *++p; - if (yych == 'E') goto yy1343; - if (yych == 'e') goto yy1343; - goto yy1307; -yy1376: + if (yych == 'C') goto yy1488; + if (yych != 'c') goto yy1417; +yy1488: yych = *++p; - if (yych == 'D') goto yy1377; - if (yych != 'd') goto yy1307; -yy1377: + if (yych == 'E') goto yy1455; + if (yych == 'e') goto yy1455; + goto yy1417; +yy1489: yych = *++p; - if (yych == 'Y') goto yy1343; - if (yych == 'y') goto yy1343; - goto yy1307; -yy1378: + if (yych == 'M') goto yy1490; + if (yych != 'm') goto yy1417; +yy1490: yych = *++p; - if (yych == 'T') goto yy1379; - if (yych != 't') goto yy1307; -yy1379: + if (yych == 'A') goto yy1491; + if (yych != 'a') goto yy1417; +yy1491: yych = *++p; - if (yych == 'A') goto yy1380; - if (yych != 'a') goto yy1307; -yy1380: + if (yych == 'R') goto yy1492; + if (yych != 'r') goto yy1417; +yy1492: yych = *++p; - if (yych == 'R') goto yy1381; - if (yych != 'r') goto yy1307; -yy1381: + if (yych == 'Y') goto yy1455; + if (yych == 'y') goto yy1455; + goto yy1417; +yy1493: yych = *++p; - if (yych == 'E') goto yy1382; - if (yych != 'e') goto yy1307; -yy1382: + if (yych == 'I') goto yy1494; + if (yych != 'i') goto yy1417; +yy1494: yych = *++p; - if (yych == 'A') goto yy1343; - if (yych == 'a') goto yy1343; - goto yy1307; -yy1383: + if (yych == 'P') goto yy1495; + if (yych != 'p') goto yy1417; +yy1495: yych = *++p; - if (yych == 'O') goto yy1384; - if (yych != 'o') goto yy1307; -yy1384: + if (yych == 'T') goto yy1496; + if (yych != 't') goto yy1417; +yy1496: yych = *++p; - if (yych == 'T') goto yy1343; - if (yych == 't') goto yy1343; - goto yy1307; -yy1385: + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1417; + if (yych >= 0x0E) goto yy1417; + } else { + if (yych <= ' ') goto yy1497; + if (yych != '>') goto yy1417; + } +yy1497: + ++p; +yy1498: + { return 1; } +yy1499: yych = *++p; - if (yych == 'A') goto yy1386; - if (yych != 'a') goto yy1307; -yy1386: + if (yych == 'L') goto yy1500; + if (yych != 'l') goto yy1417; +yy1500: yych = *++p; - if (yych == 'D') goto yy1343; - if (yych == 'd') goto yy1343; - goto yy1307; -yy1387: + if (yych == 'E') goto yy1496; + if (yych == 'e') goto yy1496; + goto yy1417; +yy1501: yych = *++p; - if (yych == 'Y') goto yy1397; - if (yych == 'y') goto yy1397; - goto yy1307; -yy1388: + if (yych == 'T') goto yy1502; + if (yych != 't') goto yy1417; +yy1502: yych = *++p; - if (yych == 'R') goto yy1394; - if (yych == 'r') goto yy1394; - goto yy1307; -yy1389: + if (yych <= 'I') { + if (yych == 'G') goto yy1504; + if (yych <= 'H') goto yy1417; + } else { + if (yych <= 'g') { + if (yych <= 'f') goto yy1417; + goto yy1504; + } else { + if (yych != 'i') goto yy1417; + } + } yych = *++p; - if (yych == 'C') goto yy1390; - if (yych != 'c') goto yy1307; -yy1390: + if (yych == 'O') goto yy1508; + if (yych == 'o') goto yy1508; + goto yy1417; +yy1504: yych = *++p; - if (yych == 'T') goto yy1391; - if (yych != 't') goto yy1307; -yy1391: + if (yych == 'R') goto yy1505; + if (yych != 'r') goto yy1417; +yy1505: yych = *++p; - if (yych == 'I') goto yy1392; - if (yych != 'i') goto yy1307; -yy1392: + if (yych == 'O') goto yy1506; + if (yych != 'o') goto yy1417; +yy1506: yych = *++p; - if (yych == 'O') goto yy1393; - if (yych != 'o') goto yy1307; -yy1393: + if (yych == 'U') goto yy1507; + if (yych != 'u') goto yy1417; +yy1507: yych = *++p; - if (yych == 'N') goto yy1343; - if (yych == 'n') goto yy1343; - goto yy1307; -yy1394: + if (yych == 'P') goto yy1455; + if (yych == 'p') goto yy1455; + goto yy1417; +yy1508: yych = *++p; - if (yych == 'I') goto yy1395; - if (yych != 'i') goto yy1307; -yy1395: + if (yych == 'N') goto yy1455; + if (yych == 'n') goto yy1455; + goto yy1417; +yy1509: yych = *++p; - if (yych == 'P') goto yy1396; - if (yych != 'p') goto yy1307; -yy1396: + if (yych == 'F') goto yy1511; + if (yych == 'f') goto yy1511; + goto yy1417; +yy1510: yych = *++p; - if (yych == 'T') goto yy1343; - if (yych == 't') goto yy1343; - goto yy1307; -yy1397: + if (yych == 'V') goto yy1455; + if (yych == 'v') goto yy1455; + goto yy1417; +yy1511: yych = *++p; - if (yych == 'L') goto yy1398; - if (yych != 'l') goto yy1307; -yy1398: + if (yych == 'R') goto yy1512; + if (yych != 'r') goto yy1417; +yy1512: yych = *++p; - if (yych == 'E') goto yy1343; - if (yych == 'e') goto yy1343; - goto yy1307; -yy1399: + if (yych == 'A') goto yy1513; + if (yych != 'a') goto yy1417; +yy1513: yych = *++p; - if (yych == 'V') goto yy1343; - if (yych == 'v') goto yy1343; - goto yy1307; -yy1400: + if (yych == 'M') goto yy1514; + if (yych != 'm') goto yy1417; +yy1514: yych = *++p; - if (yych == 'L') goto yy1409; - if (yych == 'l') goto yy1409; - goto yy1307; -yy1401: + if (yych == 'E') goto yy1515; + if (yych != 'e') goto yy1417; +yy1515: yych = *++p; - if (yych <= 'P') { - if (yych == 'N') goto yy1402; - if (yych <= 'O') goto yy1307; - goto yy1403; + if (yych == 'S') goto yy1455; + if (yych == 's') goto yy1455; + goto yy1417; +yy1516: + yych = *++p; + if (yych <= 'T') { + if (yych == 'N') goto yy1519; + if (yych <= 'S') goto yy1417; + goto yy1520; } else { if (yych <= 'n') { - if (yych <= 'm') goto yy1307; + if (yych <= 'm') goto yy1417; + goto yy1519; } else { - if (yych == 'p') goto yy1403; - goto yy1307; + if (yych == 't') goto yy1520; + goto yy1417; } } -yy1402: +yy1517: yych = *++p; - if (yych == 'V') goto yy1407; - if (yych == 'v') goto yy1407; - goto yy1307; -yy1403: + if (yych == 'I') goto yy1518; + if (yych != 'i') goto yy1417; +yy1518: yych = *++p; - if (yych == 'T') goto yy1404; - if (yych != 't') goto yy1307; -yy1404: + if (yych == 'N') goto yy1455; + if (yych == 'n') goto yy1455; + goto yy1417; +yy1519: yych = *++p; - if (yych == 'I') goto yy1405; - if (yych != 'i') goto yy1307; -yy1405: + if (yych == 'U') goto yy1521; + if (yych == 'u') goto yy1521; + goto yy1417; +yy1520: yych = *++p; - if (yych == 'O') goto yy1406; - if (yych != 'o') goto yy1307; -yy1406: + if (yych == 'A') goto yy1455; + if (yych == 'a') goto yy1455; + goto yy1417; +yy1521: yych = *++p; - if (yych == 'N') goto yy1343; - if (yych == 'n') goto yy1343; - goto yy1307; -yy1407: + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + goto yy1417; + } else { + if (yych <= ' ') goto yy1456; + if (yych <= '.') goto yy1417; + goto yy1458; + } + } else { + if (yych <= 'H') { + if (yych == '>') goto yy1456; + goto yy1417; + } else { + if (yych <= 'I') goto yy1522; + if (yych != 'i') goto yy1417; + } + } +yy1522: + yych = *++p; + if (yych == 'T') goto yy1523; + if (yych != 't') goto yy1417; +yy1523: yych = *++p; - if (yych == 'A') goto yy1408; - if (yych != 'a') goto yy1307; -yy1408: + if (yych == 'E') goto yy1524; + if (yych != 'e') goto yy1417; +yy1524: yych = *++p; - if (yych == 'S') goto yy1343; - if (yych == 's') goto yy1343; - goto yy1307; -yy1409: + if (yych == 'M') goto yy1455; + if (yych == 'm') goto yy1455; + goto yy1417; +yy1525: yych = *++p; - if (yych <= '=') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy1307; - goto yy1344; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + goto yy1417; } else { - if (yych == ' ') goto yy1344; - goto yy1307; + if (yych <= ' ') goto yy1456; + if (yych <= '.') goto yy1417; + goto yy1458; } } else { - if (yych <= 'G') { - if (yych <= '>') goto yy1344; - if (yych <= 'F') goto yy1307; + if (yych <= 'M') { + if (yych == '>') goto yy1456; + goto yy1417; } else { - if (yych != 'g') goto yy1307; + if (yych <= 'N') goto yy1530; + if (yych == 'n') goto yy1530; + goto yy1417; } } +yy1526: yych = *++p; - if (yych == 'R') goto yy1411; - if (yych != 'r') goto yy1307; -yy1411: + if (yych == 'G') goto yy1527; + if (yych != 'g') goto yy1417; +yy1527: yych = *++p; - if (yych == 'O') goto yy1412; - if (yych != 'o') goto yy1307; -yy1412: + if (yych == 'E') goto yy1528; + if (yych != 'e') goto yy1417; +yy1528: yych = *++p; - if (yych == 'U') goto yy1413; - if (yych != 'u') goto yy1307; -yy1413: + if (yych == 'N') goto yy1529; + if (yych != 'n') goto yy1417; +yy1529: yych = *++p; - if (yych == 'P') goto yy1343; - if (yych == 'p') goto yy1343; - goto yy1307; -yy1414: + if (yych == 'D') goto yy1455; + if (yych == 'd') goto yy1455; + goto yy1417; +yy1530: yych = *++p; - if (yych == 'T') goto yy1419; - if (yych == 't') goto yy1419; - goto yy1307; -yy1415: + if (yych == 'K') goto yy1455; + if (yych == 'k') goto yy1455; + goto yy1417; +yy1531: yych = *++p; - if (yych == 'J') goto yy1416; - if (yych != 'j') goto yy1307; -yy1416: + if (yych == 'M') goto yy1536; + if (yych == 'm') goto yy1536; + goto yy1417; +yy1532: yych = *++p; - if (yych == 'E') goto yy1417; - if (yych != 'e') goto yy1307; -yy1417: + if (yych == 'A') goto yy1533; + if (yych != 'a') goto yy1417; +yy1533: yych = *++p; - if (yych == 'C') goto yy1418; - if (yych != 'c') goto yy1307; -yy1418: + if (yych == 'D') goto yy1534; + if (yych != 'd') goto yy1417; +yy1534: yych = *++p; - if (yych == 'T') goto yy1343; - if (yych == 't') goto yy1343; - goto yy1307; -yy1419: + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + goto yy1417; + } else { + if (yych <= ' ') goto yy1456; + if (yych <= '.') goto yy1417; + goto yy1458; + } + } else { + if (yych <= 'D') { + if (yych == '>') goto yy1456; + goto yy1417; + } else { + if (yych <= 'E') goto yy1535; + if (yych != 'e') goto yy1417; + } + } +yy1535: yych = *++p; - if (yych == 'P') goto yy1420; - if (yych != 'p') goto yy1307; -yy1420: + if (yych == 'R') goto yy1455; + if (yych == 'r') goto yy1455; + goto yy1417; +yy1536: yych = *++p; - if (yych == 'U') goto yy1421; - if (yych != 'u') goto yy1307; -yy1421: + if (yych == 'L') goto yy1455; + if (yych == 'l') goto yy1455; + goto yy1417; +yy1537: yych = *++p; - if (yych == 'T') goto yy1343; - if (yych == 't') goto yy1343; - goto yy1307; -yy1422: + if (yych == 'A') goto yy1558; + if (yych == 'a') goto yy1558; + goto yy1417; +yy1538: yych = *++p; - if (yych == 'P') goto yy1343; - if (yych == 'p') goto yy1343; - goto yy1307; -yy1423: + if (yych <= 'R') { + if (yych == 'O') goto yy1554; + if (yych <= 'Q') goto yy1417; + goto yy1555; + } else { + if (yych <= 'o') { + if (yych <= 'n') goto yy1417; + goto yy1554; + } else { + if (yych == 'r') goto yy1555; + goto yy1417; + } + } +yy1539: yych = *++p; - if (yych == 'T') goto yy1434; - if (yych == 't') goto yy1434; - goto yy1307; -yy1424: + if (yych <= 'G') { + if (yych == 'E') goto yy1540; + if (yych <= 'F') goto yy1417; + goto yy1541; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy1417; + } else { + if (yych == 'g') goto yy1541; + goto yy1417; + } + } +yy1540: yych = *++p; - if (yych == 'D') goto yy1433; - if (yych == 'd') goto yy1433; - goto yy1307; -yy1425: + if (yych == 'L') goto yy1550; + if (yych == 'l') goto yy1550; + goto yy1417; +yy1541: yych = *++p; - if (yych == 'O') goto yy1426; - if (yych != 'o') goto yy1307; -yy1426: + if (yych <= 'U') { + if (yych == 'C') goto yy1543; + if (yych <= 'T') goto yy1417; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy1417; + goto yy1543; + } else { + if (yych != 'u') goto yy1417; + } + } yych = *++p; - if (yych == 'C') goto yy1427; - if (yych != 'c') goto yy1307; -yy1427: + if (yych == 'R') goto yy1549; + if (yych == 'r') goto yy1549; + goto yy1417; +yy1543: yych = *++p; - if (yych == 'K') goto yy1428; - if (yych != 'k') goto yy1307; -yy1428: + if (yych == 'A') goto yy1544; + if (yych != 'a') goto yy1417; +yy1544: yych = *++p; - if (yych == 'Q') goto yy1429; - if (yych != 'q') goto yy1307; -yy1429: + if (yych == 'P') goto yy1545; + if (yych != 'p') goto yy1417; +yy1545: yych = *++p; - if (yych == 'U') goto yy1430; - if (yych != 'u') goto yy1307; -yy1430: + if (yych == 'T') goto yy1546; + if (yych != 't') goto yy1417; +yy1546: yych = *++p; - if (yych == 'O') goto yy1431; - if (yych != 'o') goto yy1307; -yy1431: + if (yych == 'I') goto yy1547; + if (yych != 'i') goto yy1417; +yy1547: yych = *++p; - if (yych == 'T') goto yy1432; - if (yych != 't') goto yy1307; -yy1432: + if (yych == 'O') goto yy1548; + if (yych != 'o') goto yy1417; +yy1548: yych = *++p; - if (yych == 'E') goto yy1343; - if (yych == 'e') goto yy1343; - goto yy1307; -yy1433: + if (yych == 'N') goto yy1455; + if (yych == 'n') goto yy1455; + goto yy1417; +yy1549: yych = *++p; - if (yych == 'Y') goto yy1343; - if (yych == 'y') goto yy1343; - goto yy1307; -yy1434: + if (yych == 'E') goto yy1455; + if (yych == 'e') goto yy1455; + goto yy1417; +yy1550: yych = *++p; - if (yych == 'T') goto yy1435; - if (yych != 't') goto yy1307; -yy1435: + if (yych == 'D') goto yy1551; + if (yych != 'd') goto yy1417; +yy1551: yych = *++p; - if (yych == 'O') goto yy1436; - if (yych != 'o') goto yy1307; -yy1436: + if (yych == 'S') goto yy1552; + if (yych != 's') goto yy1417; +yy1552: yych = *++p; - if (yych == 'N') goto yy1343; - if (yych == 'n') goto yy1343; - goto yy1307; -yy1437: + if (yych == 'E') goto yy1553; + if (yych != 'e') goto yy1417; +yy1553: yych = *++p; - if (yych == 'R') goto yy1438; - if (yych != 'r') goto yy1307; -yy1438: + if (yych == 'T') goto yy1455; + if (yych == 't') goto yy1455; + goto yy1417; +yy1554: yych = *++p; - if (yych == 'A') goto yy1439; - if (yych != 'a') goto yy1307; -yy1439: + if (yych == 'T') goto yy1556; + if (yych == 't') goto yy1556; + goto yy1417; +yy1555: yych = *++p; - if (yych == 'M') goto yy1440; - if (yych != 'm') goto yy1307; -yy1440: + if (yych == 'M') goto yy1455; + if (yych == 'm') goto yy1455; + goto yy1417; +yy1556: yych = *++p; - if (yych == 'E') goto yy1343; - if (yych == 'e') goto yy1343; - goto yy1307; -yy1441: + if (yych == 'E') goto yy1557; + if (yych != 'e') goto yy1417; +yy1557: yych = *++p; - if (yych == 'R') goto yy1446; - if (yych == 'r') goto yy1446; - goto yy1307; -yy1442: + if (yych == 'R') goto yy1455; + if (yych == 'r') goto yy1455; + goto yy1417; +yy1558: yych = *++p; - if (yych == 'A') goto yy1443; - if (yych != 'a') goto yy1307; -yy1443: + if (yych == 'M') goto yy1559; + if (yych != 'm') goto yy1417; +yy1559: yych = *++p; - if (yych == 'D') goto yy1444; - if (yych != 'd') goto yy1307; -yy1444: + if (yych == 'E') goto yy1560; + if (yych != 'e') goto yy1417; +yy1560: yych = *++p; - if (yych == 'E') goto yy1445; - if (yych != 'e') goto yy1307; -yy1445: + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + goto yy1417; + } else { + if (yych <= ' ') goto yy1456; + if (yych <= '.') goto yy1417; + goto yy1458; + } + } else { + if (yych <= 'R') { + if (yych == '>') goto yy1456; + goto yy1417; + } else { + if (yych <= 'S') goto yy1561; + if (yych != 's') goto yy1417; + } + } +yy1561: yych = *++p; - if (yych == 'R') goto yy1343; - if (yych == 'r') goto yy1343; - goto yy1307; -yy1446: + if (yych == 'E') goto yy1562; + if (yych != 'e') goto yy1417; +yy1562: yych = *++p; - if (yych == 'O') goto yy1447; - if (yych != 'o') goto yy1307; -yy1447: + if (yych == 'T') goto yy1455; + if (yych == 't') goto yy1455; + goto yy1417; +yy1563: yych = *++p; - if (yych == 'U') goto yy1448; - if (yych != 'u') goto yy1307; -yy1448: + if (yych <= 'V') { + if (yych <= 'Q') { + if (yych == 'A') goto yy1569; + goto yy1417; + } else { + if (yych <= 'R') goto yy1455; + if (yych <= 'U') goto yy1417; + goto yy1455; + } + } else { + if (yych <= 'q') { + if (yych == 'a') goto yy1569; + goto yy1417; + } else { + if (yych <= 'r') goto yy1455; + if (yych == 'v') goto yy1455; + goto yy1417; + } + } +yy1564: yych = *++p; - if (yych == 'P') goto yy1343; - if (yych == 'p') goto yy1343; - goto yy1307; -yy1449: + if (yych == 'T') goto yy1565; + if (yych != 't') goto yy1417; +yy1565: yych = *++p; - if (yych == 'I') goto yy1455; - if (yych == 'i') goto yy1455; - goto yy1307; -yy1450: + if (yych == 'A') goto yy1566; + if (yych != 'a') goto yy1417; +yy1566: yych = *++p; - if (yych == 'T') goto yy1451; - if (yych != 't') goto yy1307; -yy1451: + if (yych == 'I') goto yy1567; + if (yych != 'i') goto yy1417; +yy1567: yych = *++p; - if (yych == 'I') goto yy1452; - if (yych != 'i') goto yy1307; -yy1452: + if (yych == 'L') goto yy1568; + if (yych != 'l') goto yy1417; +yy1568: yych = *++p; - if (yych == 'C') goto yy1453; - if (yych != 'c') goto yy1307; -yy1453: + if (yych == 'S') goto yy1455; + if (yych == 's') goto yy1455; + goto yy1417; +yy1569: yych = *++p; - if (yych == 'L') goto yy1454; - if (yych != 'l') goto yy1307; -yy1454: + if (yych == 'L') goto yy1570; + if (yych != 'l') goto yy1417; +yy1570: yych = *++p; - if (yych == 'E') goto yy1343; - if (yych == 'e') goto yy1343; - goto yy1307; -yy1455: + if (yych == 'O') goto yy1571; + if (yych != 'o') goto yy1417; +yy1571: yych = *++p; - if (yych == 'D') goto yy1456; - if (yych != 'd') goto yy1307; -yy1456: + if (yych == 'G') goto yy1455; + if (yych == 'g') goto yy1455; + goto yy1417; +yy1572: yych = *++p; - if (yych == 'E') goto yy1343; - if (yych == 'e') goto yy1343; - goto yy1307; -yy1457: + if (yych == 'L') goto yy1582; + if (yych == 'l') goto yy1582; + goto yy1417; +yy1573: yych = *++p; - if (yych <= 'O') { - if (yych == 'E') goto yy1343; - if (yych <= 'N') goto yy1307; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy1307; - goto yy1343; - } else { - if (yych != 'o') goto yy1307; - } - } + if (yych == 'N') goto yy1579; + if (yych == 'n') goto yy1579; + goto yy1417; +yy1574: yych = *++p; - if (yych == 'G') goto yy1459; - if (yych != 'g') goto yy1307; -yy1459: + if (yych == 'P') goto yy1575; + if (yych != 'p') goto yy1417; +yy1575: yych = *++p; - if (yych == 'R') goto yy1460; - if (yych != 'r') goto yy1307; -yy1460: + if (yych == 'T') goto yy1576; + if (yych != 't') goto yy1417; +yy1576: yych = *++p; - if (yych == 'E') goto yy1461; - if (yych != 'e') goto yy1307; -yy1461: + if (yych == 'I') goto yy1577; + if (yych != 'i') goto yy1417; +yy1577: yych = *++p; - if (yych == 'S') goto yy1462; - if (yych != 's') goto yy1307; -yy1462: + if (yych == 'O') goto yy1578; + if (yych != 'o') goto yy1417; +yy1578: yych = *++p; - if (yych == 'S') goto yy1343; - if (yych == 's') goto yy1343; - goto yy1307; -yy1463: + if (yych == 'N') goto yy1455; + if (yych == 'n') goto yy1455; + goto yy1417; +yy1579: yych = *++p; - if (yych == 'D') goto yy1464; - if (yych != 'd') goto yy1307; -yy1464: + if (yych == 'T') goto yy1580; + if (yych != 't') goto yy1417; +yy1580: yych = *++p; - if (yych == 'E') goto yy1465; - if (yych != 'e') goto yy1307; -yy1465: + if (yych == 'E') goto yy1581; + if (yych != 'e') goto yy1417; +yy1581: yych = *++p; - if (yych == 'O') goto yy1466; - if (yych != 'o') goto yy1307; -yy1466: + if (yych == 'R') goto yy1455; + if (yych == 'r') goto yy1455; + goto yy1417; +yy1582: yych = *++p; - if (yych <= ' ') { - if (yych <= 0x08) goto yy1307; - if (yych <= '\r') goto yy1467; - if (yych <= 0x1F) goto yy1307; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy1307; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + goto yy1417; } else { - if (yych != '>') goto yy1307; + if (yych <= ' ') goto yy1456; + if (yych <= '.') goto yy1417; + goto yy1458; } - } -yy1467: - ++p; - { return (bufsize_t)(p - start); } -yy1469: - yych = *++p; - if (yych <= 'R') { - if (yych == 'O') goto yy1485; - if (yych <= 'Q') goto yy1307; - goto yy1486; - } else { - if (yych <= 'o') { - if (yych <= 'n') goto yy1307; - goto yy1485; - } else { - if (yych == 'r') goto yy1486; - goto yy1307; - } - } -yy1470: - yych = *++p; - if (yych <= 'G') { - if (yych == 'E') goto yy1471; - if (yych <= 'F') goto yy1307; - goto yy1472; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy1307; - } else { - if (yych == 'g') goto yy1472; - goto yy1307; - } - } -yy1471: - yych = *++p; - if (yych == 'L') goto yy1481; - if (yych == 'l') goto yy1481; - goto yy1307; -yy1472: - yych = *++p; - if (yych <= 'U') { - if (yych == 'C') goto yy1474; - if (yych <= 'T') goto yy1307; } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy1307; - goto yy1474; + if (yych <= 'F') { + if (yych == '>') goto yy1456; + goto yy1417; } else { - if (yych != 'u') goto yy1307; + if (yych <= 'G') goto yy1583; + if (yych != 'g') goto yy1417; } } +yy1583: yych = *++p; - if (yych == 'R') goto yy1480; - if (yych == 'r') goto yy1480; - goto yy1307; -yy1474: - yych = *++p; - if (yych == 'A') goto yy1475; - if (yych != 'a') goto yy1307; -yy1475: - yych = *++p; - if (yych == 'P') goto yy1476; - if (yych != 'p') goto yy1307; -yy1476: - yych = *++p; - if (yych == 'T') goto yy1477; - if (yych != 't') goto yy1307; -yy1477: - yych = *++p; - if (yych == 'I') goto yy1478; - if (yych != 'i') goto yy1307; -yy1478: - yych = *++p; - if (yych == 'O') goto yy1479; - if (yych != 'o') goto yy1307; -yy1479: - yych = *++p; - if (yych == 'N') goto yy1466; - if (yych == 'n') goto yy1466; - goto yy1307; -yy1480: - yych = *++p; - if (yych == 'E') goto yy1466; - if (yych == 'e') goto yy1466; - goto yy1307; -yy1481: - yych = *++p; - if (yych == 'D') goto yy1482; - if (yych != 'd') goto yy1307; -yy1482: - yych = *++p; - if (yych == 'S') goto yy1483; - if (yych != 's') goto yy1307; -yy1483: - yych = *++p; - if (yych == 'E') goto yy1484; - if (yych != 'e') goto yy1307; -yy1484: - yych = *++p; - if (yych == 'T') goto yy1466; - if (yych == 't') goto yy1466; - goto yy1307; -yy1485: + if (yych == 'R') goto yy1584; + if (yych != 'r') goto yy1417; +yy1584: yych = *++p; - if (yych == 'T') goto yy1487; - if (yych == 't') goto yy1487; - goto yy1307; -yy1486: + if (yych == 'O') goto yy1585; + if (yych != 'o') goto yy1417; +yy1585: yych = *++p; - if (yych == 'M') goto yy1466; - if (yych == 'm') goto yy1466; - goto yy1307; -yy1487: + if (yych == 'U') goto yy1586; + if (yych != 'u') goto yy1417; +yy1586: yych = *++p; - if (yych == 'E') goto yy1488; - if (yych != 'e') goto yy1307; -yy1488: + if (yych == 'P') goto yy1455; + if (yych == 'p') goto yy1455; + goto yy1417; +yy1587: yych = *++p; - if (yych == 'R') goto yy1466; - if (yych == 'r') goto yy1466; - goto yy1307; -yy1489: + if (yych == 'D') goto yy1602; + if (yych == 'd') goto yy1602; + goto yy1417; +yy1588: yych = *++p; - if (yych == 'B') goto yy1490; - if (yych != 'b') goto yy1307; -yy1490: + if (yych == 'O') goto yy1595; + if (yych == 'o') goto yy1595; + goto yy1417; +yy1589: yych = *++p; - if (yych == 'E') goto yy1491; - if (yych != 'e') goto yy1307; -yy1491: + if (yych == 'S') goto yy1590; + if (yych != 's') goto yy1417; +yy1590: yych = *++p; - if (yych == 'D') goto yy1466; - if (yych == 'd') goto yy1466; - goto yy1307; -yy1492: + if (yych == 'E') goto yy1591; + if (yych != 'e') goto yy1417; +yy1591: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1307; - if (yych <= '\r') goto yy1467; - goto yy1307; + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + goto yy1417; } else { - if (yych <= ' ') goto yy1467; - if (yych <= '.') goto yy1307; - goto yy1467; + if (yych <= ' ') goto yy1456; + if (yych <= '.') goto yy1417; + goto yy1458; } } else { - if (yych <= 'D') { - if (yych == '>') goto yy1467; - goto yy1307; + if (yych <= 'E') { + if (yych == '>') goto yy1456; + goto yy1417; } else { - if (yych <= 'E') goto yy1508; - if (yych == 'e') goto yy1508; - goto yy1307; + if (yych <= 'F') goto yy1592; + if (yych != 'f') goto yy1417; } } -yy1493: +yy1592: yych = *++p; - if (yych == 'O') goto yy1506; - if (yych == 'o') goto yy1506; - goto yy1307; -yy1494: + if (yych == 'O') goto yy1593; + if (yych != 'o') goto yy1417; +yy1593: yych = *++p; - if (yych == 'X') goto yy1501; - if (yych == 'x') goto yy1501; - goto yy1307; -yy1495: + if (yych == 'N') goto yy1594; + if (yych != 'n') goto yy1417; +yy1594: yych = *++p; - if (yych == 'O') goto yy1499; - if (yych == 'o') goto yy1499; - goto yy1307; -yy1496: + if (yych == 'T') goto yy1455; + if (yych == 't') goto yy1455; + goto yy1417; +yy1595: yych = *++p; - if (yych == 'B') goto yy1497; - if (yych != 'b') goto yy1307; -yy1497: + if (yych == 'C') goto yy1596; + if (yych != 'c') goto yy1417; +yy1596: yych = *++p; - if (yych == 'L') goto yy1498; - if (yych != 'l') goto yy1307; -yy1498: + if (yych == 'K') goto yy1597; + if (yych != 'k') goto yy1417; +yy1597: yych = *++p; - if (yych == 'E') goto yy1466; - if (yych == 'e') goto yy1466; - goto yy1307; -yy1499: + if (yych == 'Q') goto yy1598; + if (yych != 'q') goto yy1417; +yy1598: yych = *++p; - if (yych == 'D') goto yy1500; - if (yych != 'd') goto yy1307; -yy1500: + if (yych == 'U') goto yy1599; + if (yych != 'u') goto yy1417; +yy1599: yych = *++p; - if (yych == 'Y') goto yy1466; - if (yych == 'y') goto yy1466; - goto yy1307; -yy1501: + if (yych == 'O') goto yy1600; + if (yych != 'o') goto yy1417; +yy1600: yych = *++p; - if (yych == 'T') goto yy1502; - if (yych != 't') goto yy1307; -yy1502: + if (yych == 'T') goto yy1601; + if (yych != 't') goto yy1417; +yy1601: yych = *++p; - if (yych == 'A') goto yy1503; - if (yych != 'a') goto yy1307; -yy1503: + if (yych == 'E') goto yy1455; + if (yych == 'e') goto yy1455; + goto yy1417; +yy1602: yych = *++p; - if (yych == 'R') goto yy1504; - if (yych != 'r') goto yy1307; -yy1504: + if (yych == 'Y') goto yy1455; + if (yych == 'y') goto yy1455; + goto yy1417; +yy1603: yych = *++p; - if (yych == 'E') goto yy1505; - if (yych != 'e') goto yy1307; -yy1505: + if (yych == 'I') goto yy1614; + if (yych == 'i') goto yy1614; + goto yy1417; +yy1604: yych = *++p; - if (yych == 'A') goto yy1466; - if (yych == 'a') goto yy1466; - goto yy1307; -yy1506: + if (yych == 'T') goto yy1610; + if (yych == 't') goto yy1610; + goto yy1417; +yy1605: yych = *++p; - if (yych == 'O') goto yy1507; - if (yych != 'o') goto yy1307; -yy1507: + if (yych == 'D') goto yy1606; + if (yych != 'd') goto yy1417; +yy1606: yych = *++p; - if (yych == 'T') goto yy1466; - if (yych == 't') goto yy1466; - goto yy1307; -yy1508: + if (yych == 'R') goto yy1607; + if (yych != 'r') goto yy1417; +yy1607: yych = *++p; - if (yych == 'A') goto yy1509; - if (yych != 'a') goto yy1307; -yy1509: + if (yych == 'E') goto yy1608; + if (yych != 'e') goto yy1417; +yy1608: yych = *++p; - if (yych == 'D') goto yy1466; - if (yych == 'd') goto yy1466; - goto yy1307; -yy1510: + if (yych == 'S') goto yy1609; + if (yych != 's') goto yy1417; +yy1609: yych = *++p; - if (yych == 'Y') goto yy1520; - if (yych == 'y') goto yy1520; - goto yy1307; -yy1511: + if (yych == 'S') goto yy1455; + if (yych == 's') goto yy1455; + goto yy1417; +yy1610: yych = *++p; - if (yych == 'R') goto yy1517; - if (yych == 'r') goto yy1517; - goto yy1307; -yy1512: + if (yych == 'I') goto yy1611; + if (yych != 'i') goto yy1417; +yy1611: yych = *++p; - if (yych == 'C') goto yy1513; - if (yych != 'c') goto yy1307; -yy1513: + if (yych == 'C') goto yy1612; + if (yych != 'c') goto yy1417; +yy1612: yych = *++p; - if (yych == 'T') goto yy1514; - if (yych != 't') goto yy1307; -yy1514: + if (yych == 'L') goto yy1613; + if (yych != 'l') goto yy1417; +yy1613: yych = *++p; - if (yych == 'I') goto yy1515; - if (yych != 'i') goto yy1307; -yy1515: + if (yych == 'E') goto yy1455; + if (yych == 'e') goto yy1455; + goto yy1417; +yy1614: yych = *++p; - if (yych == 'O') goto yy1516; - if (yych != 'o') goto yy1307; -yy1516: + if (yych == 'D') goto yy1615; + if (yych != 'd') goto yy1417; +yy1615: yych = *++p; - if (yych == 'N') goto yy1466; - if (yych == 'n') goto yy1466; - goto yy1307; -yy1517: + if (yych == 'E') goto yy1455; + if (yych == 'e') goto yy1455; + goto yy1417; +yy1616: yych = *++p; - if (yych == 'I') goto yy1518; - if (yych != 'i') goto yy1307; -yy1518: + if (yych == 'E') goto yy1620; + if (yych == 'e') goto yy1620; + goto yy1417; +yy1617: yych = *++p; - if (yych == 'P') goto yy1519; - if (yych != 'p') goto yy1307; -yy1519: + if (yych == 'R') goto yy1618; + if (yych != 'r') goto yy1417; +yy1618: yych = *++p; - if (yych == 'T') goto yy1466; - if (yych == 't') goto yy1466; - goto yy1307; -yy1520: + if (yych == 'A') goto yy1619; + if (yych != 'a') goto yy1417; +yy1619: yych = *++p; - if (yych == 'L') goto yy1521; - if (yych != 'l') goto yy1307; -yy1521: + if (yych == 'M') goto yy1455; + if (yych == 'm') goto yy1455; + goto yy1417; +yy1620: yych = *++p; - if (yych == 'E') goto yy1466; - if (yych == 'e') goto yy1466; - goto yy1307; -yy1522: + if (yych <= ' ') { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1621; + if (yych <= 0x1F) goto yy1417; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy1417; + goto yy1458; + } else { + if (yych != '>') goto yy1417; + } + } +yy1621: yych = *++p; - if (yych == 'V') goto yy1466; - if (yych == 'v') goto yy1466; - goto yy1307; -yy1523: + goto yy1498; +yy1622: yych = *++p; - if (yych == 'L') goto yy1532; - if (yych == 'l') goto yy1532; - goto yy1307; -yy1524: + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy1417; + if (yych <= '\r') goto yy1456; + if (yych <= 0x1F) goto yy1417; + goto yy1456; + } else { + if (yych == '/') goto yy1458; + if (yych <= '=') goto yy1417; + goto yy1456; + } + } else { + if (yych <= 'R') { + if (yych == 'A') goto yy1617; + if (yych <= 'Q') goto yy1417; + goto yy1624; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy1417; + goto yy1617; + } else { + if (yych == 'r') goto yy1624; + goto yy1417; + } + } + } +yy1623: yych = *++p; - if (yych <= 'P') { - if (yych == 'N') goto yy1525; - if (yych <= 'O') goto yy1307; - goto yy1526; + if (yych <= 'U') { + if (yych <= 'N') { + if (yych == 'E') goto yy1481; + goto yy1417; + } else { + if (yych <= 'O') goto yy1480; + if (yych <= 'T') goto yy1417; + goto yy1479; + } } else { if (yych <= 'n') { - if (yych <= 'm') goto yy1307; + if (yych == 'e') goto yy1481; + goto yy1417; } else { - if (yych == 'p') goto yy1526; - goto yy1307; + if (yych <= 'o') goto yy1480; + if (yych == 'u') goto yy1479; + goto yy1417; } } -yy1525: - yych = *++p; - if (yych == 'V') goto yy1530; - if (yych == 'v') goto yy1530; - goto yy1307; -yy1526: - yych = *++p; - if (yych == 'T') goto yy1527; - if (yych != 't') goto yy1307; -yy1527: - yych = *++p; - if (yych == 'I') goto yy1528; - if (yych != 'i') goto yy1307; -yy1528: - yych = *++p; - if (yych == 'O') goto yy1529; - if (yych != 'o') goto yy1307; -yy1529: - yych = *++p; - if (yych == 'N') goto yy1466; - if (yych == 'n') goto yy1466; - goto yy1307; -yy1530: - yych = *++p; - if (yych == 'A') goto yy1531; - if (yych != 'a') goto yy1307; -yy1531: - yych = *++p; - if (yych == 'S') goto yy1466; - if (yych == 's') goto yy1466; - goto yy1307; -yy1532: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1307; - if (yych <= '\r') goto yy1467; - goto yy1307; +yy1624: + ++p; + if ((yych = *p) == 'E') goto yy1455; + if (yych == 'e') goto yy1455; + goto yy1417; +} + +} + +// Try to match an HTML block tag start line of type 7, returning +// 7 if successful, 0 if not. +bufsize_t _scan_html_block_start_7(const unsigned char *p) +{ + const unsigned char *marker = NULL; + +{ + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 224, 224, 224, 224, 224, 224, 224, + 224, 198, 202, 194, 198, 194, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 198, 224, 64, 224, 224, 224, 224, 128, + 224, 224, 224, 224, 224, 241, 240, 224, + 241, 241, 241, 241, 241, 241, 241, 241, + 241, 241, 240, 224, 192, 192, 192, 224, + 224, 241, 241, 241, 241, 241, 241, 241, + 241, 241, 241, 241, 241, 241, 241, 241, + 241, 241, 241, 241, 241, 241, 241, 241, + 241, 241, 241, 224, 224, 224, 224, 240, + 192, 241, 241, 241, 241, 241, 241, 241, + 241, 241, 241, 241, 241, 241, 241, 241, + 241, 241, 241, 241, 241, 241, 241, 241, + 241, 241, 241, 224, 224, 224, 224, 224, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 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 = *(marker = p); + if (yych <= 0xDF) { + if (yych <= ';') { + if (yych != '\n') goto yy1629; } else { - if (yych <= ' ') goto yy1467; - if (yych <= '.') goto yy1307; - goto yy1467; + if (yych <= '<') goto yy1628; + if (yych <= 0x7F) goto yy1629; + if (yych >= 0xC2) goto yy1630; } } else { - if (yych <= 'F') { - if (yych == '>') goto yy1467; - goto yy1307; + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1632; + if (yych == 0xED) goto yy1637; + goto yy1633; } else { - if (yych <= 'G') goto yy1533; - if (yych != 'g') goto yy1307; + if (yych <= 0xF0) goto yy1634; + if (yych <= 0xF3) goto yy1635; + if (yych <= 0xF4) goto yy1636; } } -yy1533: - yych = *++p; - if (yych == 'R') goto yy1534; - if (yych != 'r') goto yy1307; -yy1534: - yych = *++p; - if (yych == 'O') goto yy1535; - if (yych != 'o') goto yy1307; -yy1535: - yych = *++p; - if (yych == 'U') goto yy1536; - if (yych != 'u') goto yy1307; -yy1536: - yych = *++p; - if (yych == 'P') goto yy1466; - if (yych == 'p') goto yy1466; - goto yy1307; -yy1537: - yych = *++p; - if (yych == 'T') goto yy1542; - if (yych == 't') goto yy1542; - goto yy1307; -yy1538: - yych = *++p; - if (yych == 'J') goto yy1539; - if (yych != 'j') goto yy1307; -yy1539: - yych = *++p; - if (yych == 'E') goto yy1540; - if (yych != 'e') goto yy1307; -yy1540: +yy1627: + { return 0; } +yy1628: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '@') { + if (yych == '/') goto yy1640; + goto yy1627; + } else { + if (yych <= 'Z') goto yy1638; + if (yych <= '`') goto yy1627; + if (yych <= 'z') goto yy1638; + goto yy1627; + } +yy1629: yych = *++p; - if (yych == 'C') goto yy1541; - if (yych != 'c') goto yy1307; -yy1541: + goto yy1627; +yy1630: yych = *++p; - if (yych == 'T') goto yy1466; - if (yych == 't') goto yy1466; - goto yy1307; -yy1542: + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1629; +yy1631: + p = marker; + if (yyaccept == 0) { + goto yy1627; + } else { + goto yy1649; + } +yy1632: yych = *++p; - if (yych == 'P') goto yy1543; - if (yych != 'p') goto yy1307; -yy1543: + if (yych <= 0x9F) goto yy1631; + if (yych <= 0xBF) goto yy1630; + goto yy1631; +yy1633: yych = *++p; - if (yych == 'U') goto yy1544; - if (yych != 'u') goto yy1307; -yy1544: + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1630; + goto yy1631; +yy1634: yych = *++p; - if (yych == 'T') goto yy1466; - if (yych == 't') goto yy1466; - goto yy1307; -yy1545: + if (yych <= 0x8F) goto yy1631; + if (yych <= 0xBF) goto yy1633; + goto yy1631; +yy1635: yych = *++p; - if (yych == 'P') goto yy1466; - if (yych == 'p') goto yy1466; - goto yy1307; -yy1546: + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1633; + goto yy1631; +yy1636: yych = *++p; - if (yych == 'T') goto yy1557; - if (yych == 't') goto yy1557; - goto yy1307; -yy1547: + if (yych <= 0x7F) goto yy1631; + if (yych <= 0x8F) goto yy1633; + goto yy1631; +yy1637: yych = *++p; - if (yych == 'D') goto yy1556; - if (yych == 'd') goto yy1556; - goto yy1307; -yy1548: + if (yych <= 0x7F) goto yy1631; + if (yych <= 0x9F) goto yy1630; + goto yy1631; +yy1638: + ++p; + yych = *p; + if (yybm[0+yych] & 1) { + goto yy1638; + } + if (yych <= ' ') { + if (yych <= 0x08) goto yy1631; + if (yych <= '\r') goto yy1651; + if (yych <= 0x1F) goto yy1631; + goto yy1651; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy1631; + goto yy1653; + } else { + if (yych == '>') goto yy1645; + goto yy1631; + } + } +yy1640: yych = *++p; - if (yych == 'O') goto yy1549; - if (yych != 'o') goto yy1307; -yy1549: - yych = *++p; - if (yych == 'C') goto yy1550; - if (yych != 'c') goto yy1307; -yy1550: - yych = *++p; - if (yych == 'K') goto yy1551; - if (yych != 'k') goto yy1307; -yy1551: - yych = *++p; - if (yych == 'Q') goto yy1552; - if (yych != 'q') goto yy1307; -yy1552: - yych = *++p; - if (yych == 'U') goto yy1553; - if (yych != 'u') goto yy1307; -yy1553: - yych = *++p; - if (yych == 'O') goto yy1554; - if (yych != 'o') goto yy1307; -yy1554: - yych = *++p; - if (yych == 'T') goto yy1555; - if (yych != 't') goto yy1307; -yy1555: - yych = *++p; - if (yych == 'E') goto yy1466; - if (yych == 'e') goto yy1466; - goto yy1307; -yy1556: - yych = *++p; - if (yych == 'Y') goto yy1466; - if (yych == 'y') goto yy1466; - goto yy1307; -yy1557: - yych = *++p; - if (yych == 'T') goto yy1558; - if (yych != 't') goto yy1307; -yy1558: - yych = *++p; - if (yych == 'O') goto yy1559; - if (yych != 'o') goto yy1307; -yy1559: - yych = *++p; - if (yych == 'N') goto yy1466; - if (yych == 'n') goto yy1466; - goto yy1307; -yy1560: - yych = *++p; - if (yych == 'R') goto yy1561; - if (yych != 'r') goto yy1307; -yy1561: - yych = *++p; - if (yych == 'A') goto yy1562; - if (yych != 'a') goto yy1307; -yy1562: - yych = *++p; - if (yych == 'M') goto yy1563; - if (yych != 'm') goto yy1307; -yy1563: - yych = *++p; - if (yych == 'E') goto yy1466; - if (yych == 'e') goto yy1466; - goto yy1307; -yy1564: - yych = *++p; - if (yych == 'R') goto yy1569; - if (yych == 'r') goto yy1569; - goto yy1307; -yy1565: - yych = *++p; - if (yych == 'A') goto yy1566; - if (yych != 'a') goto yy1307; -yy1566: - yych = *++p; - if (yych == 'D') goto yy1567; - if (yych != 'd') goto yy1307; -yy1567: - yych = *++p; - if (yych == 'E') goto yy1568; - if (yych != 'e') goto yy1307; -yy1568: - yych = *++p; - if (yych == 'R') goto yy1466; - if (yych == 'r') goto yy1466; - goto yy1307; -yy1569: - yych = *++p; - if (yych == 'O') goto yy1570; - if (yych != 'o') goto yy1307; -yy1570: - yych = *++p; - if (yych == 'U') goto yy1571; - if (yych != 'u') goto yy1307; -yy1571: - yych = *++p; - if (yych == 'P') goto yy1466; - if (yych == 'p') goto yy1466; - goto yy1307; -yy1572: - yych = *++p; - if (yych == 'I') goto yy1578; - if (yych == 'i') goto yy1578; - goto yy1307; -yy1573: - yych = *++p; - if (yych == 'T') goto yy1574; - if (yych != 't') goto yy1307; -yy1574: - yych = *++p; - if (yych == 'I') goto yy1575; - if (yych != 'i') goto yy1307; -yy1575: - yych = *++p; - if (yych == 'C') goto yy1576; - if (yych != 'c') goto yy1307; -yy1576: - yych = *++p; - if (yych == 'L') goto yy1577; - if (yych != 'l') goto yy1307; -yy1577: - yych = *++p; - if (yych == 'E') goto yy1466; - if (yych == 'e') goto yy1466; - goto yy1307; -yy1578: - yych = *++p; - if (yych == 'D') goto yy1579; - if (yych != 'd') goto yy1307; -yy1579: - yych = *++p; - if (yych == 'E') goto yy1466; - if (yych == 'e') goto yy1466; - goto yy1307; -yy1580: - yych = *++p; - if (yych <= 'O') { - if (yych == 'E') goto yy1466; - if (yych <= 'N') goto yy1307; + if (yych <= '@') goto yy1631; + if (yych <= 'Z') goto yy1641; + if (yych <= '`') goto yy1631; + if (yych >= '{') goto yy1631; +yy1641: + ++p; + yych = *p; + if (yybm[0+yych] & 2) { + goto yy1643; + } + if (yych <= '=') { + if (yych <= '-') { + if (yych <= ',') goto yy1631; + goto yy1641; + } else { + if (yych <= '/') goto yy1631; + if (yych <= '9') goto yy1641; + goto yy1631; + } } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy1307; - goto yy1466; + if (yych <= 'Z') { + if (yych <= '>') goto yy1645; + if (yych <= '@') goto yy1631; + goto yy1641; } else { - if (yych != 'o') goto yy1307; + if (yych <= '`') goto yy1631; + if (yych <= 'z') goto yy1641; + goto yy1631; } } +yy1643: + ++p; + yych = *p; + if (yybm[0+yych] & 2) { + goto yy1643; + } + if (yych != '>') goto yy1631; +yy1645: + ++p; + yych = *p; + if (yybm[0+yych] & 4) { + goto yy1645; + } + if (yych <= 0x08) goto yy1631; + if (yych <= '\n') goto yy1647; + if (yych <= '\v') goto yy1631; + if (yych <= '\r') goto yy1650; + goto yy1631; +yy1647: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 4) { + goto yy1645; + } + if (yych <= 0x08) goto yy1649; + if (yych <= '\n') goto yy1647; + if (yych <= '\v') goto yy1649; + if (yych <= '\r') goto yy1650; +yy1649: + { return 7; } +yy1650: yych = *++p; - if (yych == 'G') goto yy1582; - if (yych != 'g') goto yy1307; -yy1582: - yych = *++p; - if (yych == 'R') goto yy1583; - if (yych != 'r') goto yy1307; -yy1583: - yych = *++p; - if (yych == 'E') goto yy1584; - if (yych != 'e') goto yy1307; -yy1584: + goto yy1649; +yy1651: + ++p; + yych = *p; + if (yych <= ':') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy1631; + if (yych <= '\r') goto yy1651; + if (yych <= 0x1F) goto yy1631; + goto yy1651; + } else { + if (yych == '/') goto yy1653; + if (yych <= '9') goto yy1631; + goto yy1654; + } + } else { + if (yych <= 'Z') { + if (yych == '>') goto yy1645; + if (yych <= '@') goto yy1631; + goto yy1654; + } else { + if (yych <= '_') { + if (yych <= '^') goto yy1631; + goto yy1654; + } else { + if (yych <= '`') goto yy1631; + if (yych <= 'z') goto yy1654; + goto yy1631; + } + } + } +yy1653: yych = *++p; - if (yych == 'S') goto yy1585; - if (yych != 's') goto yy1307; -yy1585: + if (yych == '>') goto yy1645; + goto yy1631; +yy1654: ++p; - if ((yych = *p) == 'S') goto yy1466; - if (yych == 's') goto yy1466; - goto yy1307; -} - -} - -// 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. -bufsize_t _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, 8, 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 <= '\f') { - if (yych == '\n') goto yy1589; - goto yy1597; + if (yybm[0+yych] & 16) { + goto yy1654; + } + if (yych <= ',') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy1631; + } else { + if (yych != ' ') goto yy1631; + } + } else { + if (yych <= '<') { + if (yych <= '/') goto yy1653; + goto yy1631; + } else { + if (yych <= '=') goto yy1658; + if (yych <= '>') goto yy1645; + goto yy1631; + } + } +yy1656: + ++p; + yych = *p; + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy1631; + if (yych <= '\r') goto yy1656; + if (yych <= 0x1F) goto yy1631; + goto yy1656; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy1631; + goto yy1653; + } else { + if (yych == ':') goto yy1654; + goto yy1631; + } + } + } else { + if (yych <= 'Z') { + if (yych <= '=') goto yy1658; + if (yych <= '>') goto yy1645; + if (yych <= '@') goto yy1631; + goto yy1654; + } else { + if (yych <= '_') { + if (yych <= '^') goto yy1631; + goto yy1654; + } else { + if (yych <= '`') goto yy1631; + if (yych <= 'z') goto yy1654; + goto yy1631; + } + } + } +yy1658: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1660; + } + if (yych <= 0xE0) { + if (yych <= '"') { + if (yych <= 0x00) goto yy1631; + if (yych >= '!') goto yy1671; + } else { + if (yych <= '\'') goto yy1669; + if (yych <= 0xC1) goto yy1631; + if (yych <= 0xDF) goto yy1662; + goto yy1663; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1668; + goto yy1664; + } else { + if (yych <= 0xF0) goto yy1665; + if (yych <= 0xF3) goto yy1666; + if (yych <= 0xF4) goto yy1667; + goto yy1631; + } + } + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1660; + } + if (yych <= 0xDF) { + if (yych <= '\'') { + if (yych <= 0x00) goto yy1631; + if (yych <= ' ') goto yy1694; + if (yych <= '"') goto yy1671; + goto yy1669; + } else { + if (yych == '>') goto yy1645; + if (yych <= 0xC1) goto yy1631; + goto yy1662; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1663; + if (yych == 0xED) goto yy1668; + goto yy1664; + } else { + if (yych <= 0xF0) goto yy1665; + if (yych <= 0xF3) goto yy1666; + if (yych <= 0xF4) goto yy1667; + goto yy1631; + } + } +yy1660: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1660; + } + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych <= 0x00) goto yy1631; + if (yych <= ' ') goto yy1688; + goto yy1631; + } else { + if (yych <= '>') goto yy1645; + if (yych <= 0xC1) goto yy1631; + if (yych >= 0xE0) goto yy1663; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1668; + goto yy1664; + } else { + if (yych <= 0xF0) goto yy1665; + if (yych <= 0xF3) goto yy1666; + if (yych <= 0xF4) goto yy1667; + goto yy1631; + } + } +yy1662: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1660; + goto yy1631; +yy1663: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1631; + if (yych <= 0xBF) goto yy1662; + goto yy1631; +yy1664: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1662; + goto yy1631; +yy1665: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1631; + if (yych <= 0xBF) goto yy1664; + goto yy1631; +yy1666: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1664; + goto yy1631; +yy1667: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0x8F) goto yy1664; + goto yy1631; +yy1668: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0x9F) goto yy1662; + goto yy1631; +yy1669: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1669; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy1631; + if (yych <= '\'') goto yy1680; + goto yy1631; + } else { + if (yych <= 0xDF) goto yy1681; + if (yych <= 0xE0) goto yy1682; + goto yy1683; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1687; + if (yych <= 0xEF) goto yy1683; + goto yy1684; + } else { + if (yych <= 0xF3) goto yy1685; + if (yych <= 0xF4) goto yy1686; + goto yy1631; + } + } +yy1671: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1671; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy1631; + if (yych <= '"') goto yy1680; + goto yy1631; + } else { + if (yych <= 0xDF) goto yy1673; + if (yych <= 0xE0) goto yy1674; + goto yy1675; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1679; + if (yych <= 0xEF) goto yy1675; + goto yy1676; + } else { + if (yych <= 0xF3) goto yy1677; + if (yych <= 0xF4) goto yy1678; + goto yy1631; + } + } +yy1673: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1671; + goto yy1631; +yy1674: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1631; + if (yych <= 0xBF) goto yy1673; + goto yy1631; +yy1675: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1673; + goto yy1631; +yy1676: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1631; + if (yych <= 0xBF) goto yy1675; + goto yy1631; +yy1677: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1675; + goto yy1631; +yy1678: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0x8F) goto yy1675; + goto yy1631; +yy1679: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0x9F) goto yy1673; + goto yy1631; +yy1680: + ++p; + yych = *p; + if (yych <= ' ') { + if (yych <= 0x08) goto yy1631; + if (yych <= '\r') goto yy1651; + if (yych <= 0x1F) goto yy1631; + goto yy1651; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy1631; + goto yy1653; + } else { + if (yych == '>') goto yy1645; + goto yy1631; + } + } +yy1681: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1669; + goto yy1631; +yy1682: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1631; + if (yych <= 0xBF) goto yy1681; + goto yy1631; +yy1683: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1681; + goto yy1631; +yy1684: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1631; + if (yych <= 0xBF) goto yy1683; + goto yy1631; +yy1685: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0xBF) goto yy1683; + goto yy1631; +yy1686: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0x8F) goto yy1683; + goto yy1631; +yy1687: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1631; + if (yych <= 0x9F) goto yy1681; + goto yy1631; +yy1688: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '"') { + if (yych <= '\r') { + if (yych <= 0x00) goto yy1631; + if (yych <= 0x08) goto yy1660; + goto yy1688; + } else { + if (yych == ' ') goto yy1688; + if (yych <= '!') goto yy1660; + goto yy1631; + } + } else { + if (yych <= ':') { + if (yych == '\'') goto yy1631; + if (yych <= '9') goto yy1660; + } else { + if (yych <= ';') goto yy1660; + if (yych <= '=') goto yy1631; + if (yych <= '>') goto yy1645; + goto yy1660; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') goto yy1690; + if (yych <= '^') goto yy1660; + if (yych >= '`') goto yy1631; + } else { + if (yych <= 'z') goto yy1690; + if (yych <= 0x7F) goto yy1660; + if (yych <= 0xC1) goto yy1631; + goto yy1662; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1663; + if (yych == 0xED) goto yy1668; + goto yy1664; + } else { + if (yych <= 0xF0) goto yy1665; + if (yych <= 0xF3) goto yy1666; + if (yych <= 0xF4) goto yy1667; + goto yy1631; + } + } + } +yy1690: + ++p; + yych = *p; + if (yych <= '>') { + if (yych <= '&') { + if (yych <= 0x1F) { + if (yych <= 0x00) goto yy1631; + if (yych <= 0x08) goto yy1660; + if (yych >= 0x0E) goto yy1660; + } else { + if (yych <= ' ') goto yy1692; + if (yych == '"') goto yy1631; + goto yy1660; + } + } else { + if (yych <= '/') { + if (yych <= '\'') goto yy1631; + if (yych <= ',') goto yy1660; + if (yych <= '.') goto yy1690; + goto yy1660; + } else { + if (yych <= ';') { + if (yych <= ':') goto yy1690; + goto yy1660; + } else { + if (yych <= '<') goto yy1631; + if (yych <= '=') goto yy1658; + goto yy1645; + } + } + } + } else { + if (yych <= 0xC1) { + if (yych <= '_') { + if (yych <= '@') goto yy1660; + if (yych <= 'Z') goto yy1690; + if (yych <= '^') goto yy1660; + goto yy1690; + } else { + if (yych <= '`') goto yy1631; + if (yych <= 'z') goto yy1690; + if (yych <= 0x7F) goto yy1660; + goto yy1631; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1662; + if (yych <= 0xE0) goto yy1663; + if (yych <= 0xEC) goto yy1664; + goto yy1668; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1664; + goto yy1665; + } else { + if (yych <= 0xF3) goto yy1666; + if (yych <= 0xF4) goto yy1667; + goto yy1631; + } + } + } + } +yy1692: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '&') { + if (yych <= 0x1F) { + if (yych <= 0x00) goto yy1631; + if (yych <= 0x08) goto yy1660; + if (yych <= '\r') goto yy1692; + goto yy1660; + } else { + if (yych <= ' ') goto yy1692; + if (yych == '"') goto yy1631; + goto yy1660; + } + } else { + if (yych <= ';') { + if (yych <= '\'') goto yy1631; + if (yych == ':') goto yy1690; + goto yy1660; + } else { + if (yych <= '<') goto yy1631; + if (yych <= '=') goto yy1658; + if (yych <= '>') goto yy1645; + goto yy1660; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') goto yy1690; + if (yych <= '^') goto yy1660; + if (yych <= '_') goto yy1690; + goto yy1631; + } else { + if (yych <= 'z') goto yy1690; + if (yych <= 0x7F) goto yy1660; + if (yych <= 0xC1) goto yy1631; + goto yy1662; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1663; + if (yych == 0xED) goto yy1668; + goto yy1664; + } else { + if (yych <= 0xF0) goto yy1665; + if (yych <= 0xF3) goto yy1666; + if (yych <= 0xF4) goto yy1667; + goto yy1631; + } + } + } +yy1694: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '"') { + if (yych <= '\r') { + if (yych <= 0x00) goto yy1631; + if (yych <= 0x08) goto yy1660; + goto yy1694; + } else { + if (yych == ' ') goto yy1694; + if (yych <= '!') goto yy1660; + goto yy1671; + } + } else { + if (yych <= ':') { + if (yych == '\'') goto yy1669; + if (yych <= '9') goto yy1660; + goto yy1690; + } else { + if (yych <= ';') goto yy1660; + if (yych <= '=') goto yy1631; + if (yych <= '>') goto yy1645; + goto yy1660; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') goto yy1690; + if (yych <= '^') goto yy1660; + if (yych <= '_') goto yy1690; + goto yy1631; + } else { + if (yych <= 'z') goto yy1690; + if (yych <= 0x7F) goto yy1660; + if (yych <= 0xC1) goto yy1631; + goto yy1662; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1663; + if (yych == 0xED) goto yy1668; + goto yy1664; + } else { + if (yych <= 0xF0) goto yy1665; + if (yych <= 0xF3) goto yy1666; + if (yych <= 0xF4) goto yy1667; + goto yy1631; + } + } + } +} + +} + +// Try to match an HTML block end line of type 1 +bufsize_t _scan_html_block_end_1(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[] = { + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 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, 64, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 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, + }; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= ';') { + if (yych != '\n') goto yy1699; + } else { + if (yych <= '<') goto yy1700; + if (yych <= 0x7F) goto yy1699; + if (yych >= 0xC2) goto yy1701; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1703; + if (yych == 0xED) goto yy1708; + goto yy1704; + } else { + if (yych <= 0xF0) goto yy1705; + if (yych <= 0xF3) goto yy1706; + if (yych <= 0xF4) goto yy1707; + } + } +yy1698: + { return 0; } +yy1699: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych == '\n') goto yy1698; + goto yy1713; + } else { + if (yych <= 0xC1) goto yy1698; + if (yych <= 0xF4) goto yy1713; + goto yy1698; + } +yy1700: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '/') { + if (yych == '\n') goto yy1698; + if (yych <= '.') goto yy1713; + goto yy1709; + } else { + if (yych <= 0x7F) goto yy1713; + if (yych <= 0xC1) goto yy1698; + if (yych <= 0xF4) goto yy1713; + goto yy1698; + } +yy1701: + yych = *++p; + if (yych <= 0x7F) goto yy1702; + if (yych <= 0xBF) goto yy1699; +yy1702: + p = marker; + if (yyaccept == 0) { + goto yy1698; + } else { + goto yy1730; + } +yy1703: + yych = *++p; + if (yych <= 0x9F) goto yy1702; + if (yych <= 0xBF) goto yy1701; + goto yy1702; +yy1704: + yych = *++p; + if (yych <= 0x7F) goto yy1702; + if (yych <= 0xBF) goto yy1701; + goto yy1702; +yy1705: + yych = *++p; + if (yych <= 0x8F) goto yy1702; + if (yych <= 0xBF) goto yy1704; + goto yy1702; +yy1706: + yych = *++p; + if (yych <= 0x7F) goto yy1702; + if (yych <= 0xBF) goto yy1704; + goto yy1702; +yy1707: + yych = *++p; + if (yych <= 0x7F) goto yy1702; + if (yych <= 0x8F) goto yy1704; + goto yy1702; +yy1708: + yych = *++p; + if (yych <= 0x7F) goto yy1702; + if (yych <= 0x9F) goto yy1701; + goto yy1702; +yy1709: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 's') { + if (yych <= 'R') { + if (yych <= '\n') { + if (yych <= '\t') goto yy1712; + goto yy1702; + } else { + if (yych == 'P') goto yy1721; + goto yy1712; + } + } else { + if (yych <= 'o') { + if (yych <= 'S') goto yy1722; + goto yy1712; + } else { + if (yych <= 'p') goto yy1721; + if (yych <= 'r') goto yy1712; + goto yy1722; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } else { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + goto yy1716; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1720; + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } +yy1710: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xDF) { + if (yych <= '.') { + if (yych == '\n') goto yy1702; + } else { + if (yych <= '/') goto yy1709; + if (yych <= 0x7F) goto yy1712; + if (yych <= 0xC1) goto yy1702; + goto yy1714; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1715; + if (yych == 0xED) goto yy1720; + goto yy1716; + } else { + if (yych <= 0xF0) goto yy1717; + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } +yy1712: + ++p; + yych = *p; +yy1713: + if (yybm[0+yych] & 128) { + goto yy1712; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1702; + if (yych <= '<') goto yy1710; + goto yy1702; + } else { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + goto yy1716; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1720; + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } +yy1714: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1702; + if (yych <= 0xBF) goto yy1712; + goto yy1702; +yy1715: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1702; + if (yych <= 0xBF) goto yy1714; + goto yy1702; +yy1716: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1702; + if (yych <= 0xBF) goto yy1714; + goto yy1702; +yy1717: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1702; + if (yych <= 0xBF) goto yy1716; + goto yy1702; +yy1718: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1702; + if (yych <= 0xBF) goto yy1716; + goto yy1702; +yy1719: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1702; + if (yych <= 0x8F) goto yy1716; + goto yy1702; +yy1720: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1702; + if (yych <= 0x9F) goto yy1714; + goto yy1702; +yy1721: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xC1) { + if (yych <= 'R') { + if (yych == '\n') goto yy1702; + if (yych <= 'Q') goto yy1712; + goto yy1733; + } else { + if (yych == 'r') goto yy1733; + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + if (yych <= 0xEC) goto yy1716; + goto yy1720; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } +yy1722: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 't') { + if (yych <= 'S') { + if (yych <= '\n') { + if (yych <= '\t') goto yy1712; + goto yy1702; + } else { + if (yych == 'C') goto yy1724; + goto yy1712; + } + } else { + if (yych <= 'b') { + if (yych >= 'U') goto yy1712; + } else { + if (yych <= 'c') goto yy1724; + if (yych <= 's') goto yy1712; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } else { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + goto yy1716; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1720; + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xC1) { + if (yych <= 'Y') { + if (yych == '\n') goto yy1702; + if (yych <= 'X') goto yy1712; + goto yy1731; + } else { + if (yych == 'y') goto yy1731; + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + if (yych <= 0xEC) goto yy1716; + goto yy1720; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } +yy1724: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xC1) { + if (yych <= 'R') { + if (yych == '\n') goto yy1702; + if (yych <= 'Q') goto yy1712; + } else { + if (yych == 'r') goto yy1725; + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + if (yych <= 0xEC) goto yy1716; + goto yy1720; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } +yy1725: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xC1) { + if (yych <= 'I') { + if (yych == '\n') goto yy1702; + if (yych <= 'H') goto yy1712; + } else { + if (yych == 'i') goto yy1726; + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + if (yych <= 0xEC) goto yy1716; + goto yy1720; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } +yy1726: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xC1) { + if (yych <= 'P') { + if (yych == '\n') goto yy1702; + if (yych <= 'O') goto yy1712; + } else { + if (yych == 'p') goto yy1727; + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + if (yych <= 0xEC) goto yy1716; + goto yy1720; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } +yy1727: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xC1) { + if (yych <= 'T') { + if (yych == '\n') goto yy1702; + if (yych <= 'S') goto yy1712; + } else { + if (yych == 't') goto yy1728; + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + if (yych <= 0xEC) goto yy1716; + goto yy1720; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } +yy1728: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych == '\n') goto yy1702; + goto yy1712; + } else { + if (yych <= '>') goto yy1729; + if (yych <= 0x7F) goto yy1712; + if (yych <= 0xC1) goto yy1702; + goto yy1714; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1715; + if (yych == 0xED) goto yy1720; + goto yy1716; + } else { + if (yych <= 0xF0) goto yy1717; + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } +yy1729: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1712; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1730; + if (yych <= '<') goto yy1710; + } else { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + goto yy1716; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1720; + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + } + } +yy1730: + { return (bufsize_t)(p - start); } +yy1731: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xC1) { + if (yych <= 'L') { + if (yych == '\n') goto yy1702; + if (yych <= 'K') goto yy1712; + } else { + if (yych == 'l') goto yy1732; + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + if (yych <= 0xEC) goto yy1716; + goto yy1720; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } +yy1732: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xC1) { + if (yych <= 'E') { + if (yych == '\n') goto yy1702; + if (yych <= 'D') goto yy1712; + goto yy1728; + } else { + if (yych == 'e') goto yy1728; + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + if (yych <= 0xEC) goto yy1716; + goto yy1720; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } +yy1733: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1710; + } + if (yych <= 0xC1) { + if (yych <= 'E') { + if (yych == '\n') goto yy1702; + if (yych <= 'D') goto yy1712; + goto yy1728; + } else { + if (yych == 'e') goto yy1728; + if (yych <= 0x7F) goto yy1712; + goto yy1702; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1714; + if (yych <= 0xE0) goto yy1715; + if (yych <= 0xEC) goto yy1716; + goto yy1720; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1716; + goto yy1717; + } else { + if (yych <= 0xF3) goto yy1718; + if (yych <= 0xF4) goto yy1719; + goto yy1702; + } + } + } +} + +} + +// Try to match an HTML block end line of type 2 +bufsize_t _scan_html_block_end_2(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[] = { + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 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, 64, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 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, + }; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= ',') { + if (yych != '\n') goto yy1737; + } else { + if (yych <= '-') goto yy1738; + if (yych <= 0x7F) goto yy1737; + if (yych >= 0xC2) goto yy1739; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1741; + if (yych == 0xED) goto yy1746; + goto yy1742; + } else { + if (yych <= 0xF0) goto yy1743; + if (yych <= 0xF3) goto yy1744; + if (yych <= 0xF4) goto yy1745; + } + } +yy1736: + { return 0; } +yy1737: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych == '\n') goto yy1736; + goto yy1750; + } else { + if (yych <= 0xC1) goto yy1736; + if (yych <= 0xF4) goto yy1750; + goto yy1736; + } +yy1738: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0+yych] & 64) { + goto yy1747; + } + if (yych <= 0x7F) { + if (yych == '\n') goto yy1736; + goto yy1750; + } else { + if (yych <= 0xC1) goto yy1736; + if (yych <= 0xF4) goto yy1750; + goto yy1736; + } +yy1739: + yych = *++p; + if (yych <= 0x7F) goto yy1740; + if (yych <= 0xBF) goto yy1737; +yy1740: + p = marker; + if (yyaccept == 0) { + goto yy1736; + } else { + goto yy1760; + } +yy1741: + yych = *++p; + if (yych <= 0x9F) goto yy1740; + if (yych <= 0xBF) goto yy1739; + goto yy1740; +yy1742: + yych = *++p; + if (yych <= 0x7F) goto yy1740; + if (yych <= 0xBF) goto yy1739; + goto yy1740; +yy1743: + yych = *++p; + if (yych <= 0x8F) goto yy1740; + if (yych <= 0xBF) goto yy1742; + goto yy1740; +yy1744: + yych = *++p; + if (yych <= 0x7F) goto yy1740; + if (yych <= 0xBF) goto yy1742; + goto yy1740; +yy1745: + yych = *++p; + if (yych <= 0x7F) goto yy1740; + if (yych <= 0x8F) goto yy1742; + goto yy1740; +yy1746: + yych = *++p; + if (yych <= 0x7F) goto yy1740; + if (yych <= 0x9F) goto yy1739; + goto yy1740; +yy1747: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1747; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych == '\n') goto yy1740; + } else { + if (yych <= '>') goto yy1759; + if (yych <= 0x7F) goto yy1749; + if (yych <= 0xC1) goto yy1740; + goto yy1751; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1752; + if (yych == 0xED) goto yy1757; + goto yy1753; + } else { + if (yych <= 0xF0) goto yy1754; + if (yych <= 0xF3) goto yy1755; + if (yych <= 0xF4) goto yy1756; + goto yy1740; + } + } +yy1749: + ++p; + yych = *p; +yy1750: + if (yybm[0+yych] & 128) { + goto yy1749; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1740; + if (yych <= '-') goto yy1758; + goto yy1740; + } else { + if (yych <= 0xDF) goto yy1751; + if (yych <= 0xE0) goto yy1752; + goto yy1753; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1757; + if (yych <= 0xEF) goto yy1753; + goto yy1754; + } else { + if (yych <= 0xF3) goto yy1755; + if (yych <= 0xF4) goto yy1756; + goto yy1740; + } + } +yy1751: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1740; + if (yych <= 0xBF) goto yy1749; + goto yy1740; +yy1752: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1740; + if (yych <= 0xBF) goto yy1751; + goto yy1740; +yy1753: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1740; + if (yych <= 0xBF) goto yy1751; + goto yy1740; +yy1754: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1740; + if (yych <= 0xBF) goto yy1753; + goto yy1740; +yy1755: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1740; + if (yych <= 0xBF) goto yy1753; + goto yy1740; +yy1756: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1740; + if (yych <= 0x8F) goto yy1753; + goto yy1740; +yy1757: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1740; + if (yych <= 0x9F) goto yy1751; + goto yy1740; +yy1758: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1749; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1740; + if (yych <= '-') goto yy1747; + goto yy1740; + } else { + if (yych <= 0xDF) goto yy1751; + if (yych <= 0xE0) goto yy1752; + goto yy1753; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1757; + if (yych <= 0xEF) goto yy1753; + goto yy1754; + } else { + if (yych <= 0xF3) goto yy1755; + if (yych <= 0xF4) goto yy1756; + goto yy1740; + } + } +yy1759: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1749; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1760; + if (yych <= '-') goto yy1758; + } else { + if (yych <= 0xDF) goto yy1751; + if (yych <= 0xE0) goto yy1752; + goto yy1753; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1757; + if (yych <= 0xEF) goto yy1753; + goto yy1754; + } else { + if (yych <= 0xF3) goto yy1755; + if (yych <= 0xF4) goto yy1756; + } + } +yy1760: + { return (bufsize_t)(p - start); } +} + +} + +// Try to match an HTML block end line of type 3 +bufsize_t _scan_html_block_end_3(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[] = { + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 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, 64, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 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, + }; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= '>') { + if (yych != '\n') goto yy1764; + } else { + if (yych <= '?') goto yy1765; + if (yych <= 0x7F) goto yy1764; + if (yych >= 0xC2) goto yy1766; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1768; + if (yych == 0xED) goto yy1773; + goto yy1769; + } else { + if (yych <= 0xF0) goto yy1770; + if (yych <= 0xF3) goto yy1771; + if (yych <= 0xF4) goto yy1772; + } + } +yy1763: + { return 0; } +yy1764: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych == '\n') goto yy1763; + goto yy1779; + } else { + if (yych <= 0xC1) goto yy1763; + if (yych <= 0xF4) goto yy1779; + goto yy1763; + } +yy1765: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '>') { + if (yych == '\n') goto yy1763; + if (yych <= '=') goto yy1779; + goto yy1774; + } else { + if (yych <= 0x7F) goto yy1779; + if (yych <= 0xC1) goto yy1763; + if (yych <= 0xF4) goto yy1779; + goto yy1763; + } +yy1766: + yych = *++p; + if (yych <= 0x7F) goto yy1767; + if (yych <= 0xBF) goto yy1764; +yy1767: + p = marker; + if (yyaccept == 0) { + goto yy1763; + } else { + goto yy1775; + } +yy1768: + yych = *++p; + if (yych <= 0x9F) goto yy1767; + if (yych <= 0xBF) goto yy1766; + goto yy1767; +yy1769: + yych = *++p; + if (yych <= 0x7F) goto yy1767; + if (yych <= 0xBF) goto yy1766; + goto yy1767; +yy1770: + yych = *++p; + if (yych <= 0x8F) goto yy1767; + if (yych <= 0xBF) goto yy1769; + goto yy1767; +yy1771: + yych = *++p; + if (yych <= 0x7F) goto yy1767; + if (yych <= 0xBF) goto yy1769; + goto yy1767; +yy1772: + yych = *++p; + if (yych <= 0x7F) goto yy1767; + if (yych <= 0x8F) goto yy1769; + goto yy1767; +yy1773: + yych = *++p; + if (yych <= 0x7F) goto yy1767; + if (yych <= 0x9F) goto yy1766; + goto yy1767; +yy1774: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1778; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1775; + if (yych <= '?') goto yy1776; + } else { + if (yych <= 0xDF) goto yy1780; + if (yych <= 0xE0) goto yy1781; + goto yy1782; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1786; + if (yych <= 0xEF) goto yy1782; + goto yy1783; + } else { + if (yych <= 0xF3) goto yy1784; + if (yych <= 0xF4) goto yy1785; + } + } +yy1775: + { return (bufsize_t)(p - start); } +yy1776: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1776; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych == '\n') goto yy1767; + } else { + if (yych <= '>') goto yy1774; + if (yych <= 0x7F) goto yy1778; + if (yych <= 0xC1) goto yy1767; + goto yy1780; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1781; + if (yych == 0xED) goto yy1786; + goto yy1782; + } else { + if (yych <= 0xF0) goto yy1783; + if (yych <= 0xF3) goto yy1784; + if (yych <= 0xF4) goto yy1785; + goto yy1767; + } + } +yy1778: + ++p; + yych = *p; +yy1779: + if (yybm[0+yych] & 128) { + goto yy1778; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1767; + if (yych <= '?') goto yy1776; + goto yy1767; + } else { + if (yych <= 0xDF) goto yy1780; + if (yych <= 0xE0) goto yy1781; + goto yy1782; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1786; + if (yych <= 0xEF) goto yy1782; + goto yy1783; + } else { + if (yych <= 0xF3) goto yy1784; + if (yych <= 0xF4) goto yy1785; + goto yy1767; + } + } +yy1780: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1767; + if (yych <= 0xBF) goto yy1778; + goto yy1767; +yy1781: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1767; + if (yych <= 0xBF) goto yy1780; + goto yy1767; +yy1782: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1767; + if (yych <= 0xBF) goto yy1780; + goto yy1767; +yy1783: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1767; + if (yych <= 0xBF) goto yy1782; + goto yy1767; +yy1784: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1767; + if (yych <= 0xBF) goto yy1782; + goto yy1767; +yy1785: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1767; + if (yych <= 0x8F) goto yy1782; + goto yy1767; +yy1786: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1767; + if (yych <= 0x9F) goto yy1780; + goto yy1767; +} + +} + +// Try to match an HTML block end line of type 4 +bufsize_t _scan_html_block_end_4(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[] = { + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 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, 64, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 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, + }; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych != '\n') goto yy1790; + } else { + if (yych <= '>') goto yy1791; + if (yych <= 0x7F) goto yy1790; + if (yych >= 0xC2) goto yy1793; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1795; + if (yych == 0xED) goto yy1800; + goto yy1796; + } else { + if (yych <= 0xF0) goto yy1797; + if (yych <= 0xF3) goto yy1798; + if (yych <= 0xF4) goto yy1799; + } + } +yy1789: + { return 0; } +yy1790: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych == '\n') goto yy1789; + goto yy1804; + } else { + if (yych <= 0xC1) goto yy1789; + if (yych <= 0xF4) goto yy1804; + goto yy1789; + } +yy1791: + yyaccept = 1; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych != '\n') goto yy1804; + } else { + if (yych <= 0xC1) goto yy1792; + if (yych <= 0xF4) goto yy1804; + } +yy1792: + { return (bufsize_t)(p - start); } +yy1793: + yych = *++p; + if (yych <= 0x7F) goto yy1794; + if (yych <= 0xBF) goto yy1790; +yy1794: + p = marker; + if (yyaccept == 0) { + goto yy1789; + } else { + goto yy1792; + } +yy1795: + yych = *++p; + if (yych <= 0x9F) goto yy1794; + if (yych <= 0xBF) goto yy1793; + goto yy1794; +yy1796: + yych = *++p; + if (yych <= 0x7F) goto yy1794; + if (yych <= 0xBF) goto yy1793; + goto yy1794; +yy1797: + yych = *++p; + if (yych <= 0x8F) goto yy1794; + if (yych <= 0xBF) goto yy1796; + goto yy1794; +yy1798: + yych = *++p; + if (yych <= 0x7F) goto yy1794; + if (yych <= 0xBF) goto yy1796; + goto yy1794; +yy1799: + yych = *++p; + if (yych <= 0x7F) goto yy1794; + if (yych <= 0x8F) goto yy1796; + goto yy1794; +yy1800: + yych = *++p; + if (yych <= 0x7F) goto yy1794; + if (yych <= 0x9F) goto yy1793; + goto yy1794; +yy1801: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1803; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1792; + if (yych <= '>') goto yy1801; + goto yy1792; + } else { + if (yych <= 0xDF) goto yy1805; + if (yych <= 0xE0) goto yy1806; + goto yy1807; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1811; + if (yych <= 0xEF) goto yy1807; + goto yy1808; + } else { + if (yych <= 0xF3) goto yy1809; + if (yych <= 0xF4) goto yy1810; + goto yy1792; + } + } +yy1803: + ++p; + yych = *p; +yy1804: + if (yybm[0+yych] & 128) { + goto yy1803; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1794; + if (yych <= '>') goto yy1801; + goto yy1794; + } else { + if (yych <= 0xDF) goto yy1805; + if (yych <= 0xE0) goto yy1806; + goto yy1807; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1811; + if (yych <= 0xEF) goto yy1807; + goto yy1808; + } else { + if (yych <= 0xF3) goto yy1809; + if (yych <= 0xF4) goto yy1810; + goto yy1794; + } + } +yy1805: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1794; + if (yych <= 0xBF) goto yy1803; + goto yy1794; +yy1806: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1794; + if (yych <= 0xBF) goto yy1805; + goto yy1794; +yy1807: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1794; + if (yych <= 0xBF) goto yy1805; + goto yy1794; +yy1808: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1794; + if (yych <= 0xBF) goto yy1807; + goto yy1794; +yy1809: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1794; + if (yych <= 0xBF) goto yy1807; + goto yy1794; +yy1810: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1794; + if (yych <= 0x8F) goto yy1807; + goto yy1794; +yy1811: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1794; + if (yych <= 0x9F) goto yy1805; + goto yy1794; +} + +} + +// Try to match an HTML block end line of type 5 +bufsize_t _scan_html_block_end_5(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[] = { + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 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, 64, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 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, + }; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= '\\') { + if (yych != '\n') goto yy1815; + } else { + if (yych <= ']') goto yy1816; + if (yych <= 0x7F) goto yy1815; + if (yych >= 0xC2) goto yy1817; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1819; + if (yych == 0xED) goto yy1824; + goto yy1820; + } else { + if (yych <= 0xF0) goto yy1821; + if (yych <= 0xF3) goto yy1822; + if (yych <= 0xF4) goto yy1823; + } + } +yy1814: + { return 0; } +yy1815: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych == '\n') goto yy1814; + goto yy1828; + } else { + if (yych <= 0xC1) goto yy1814; + if (yych <= 0xF4) goto yy1828; + goto yy1814; + } +yy1816: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0+yych] & 64) { + goto yy1825; + } + if (yych <= 0x7F) { + if (yych == '\n') goto yy1814; + goto yy1828; + } else { + if (yych <= 0xC1) goto yy1814; + if (yych <= 0xF4) goto yy1828; + goto yy1814; + } +yy1817: + yych = *++p; + if (yych <= 0x7F) goto yy1818; + if (yych <= 0xBF) goto yy1815; +yy1818: + p = marker; + if (yyaccept == 0) { + goto yy1814; + } else { + goto yy1838; + } +yy1819: + yych = *++p; + if (yych <= 0x9F) goto yy1818; + if (yych <= 0xBF) goto yy1817; + goto yy1818; +yy1820: + yych = *++p; + if (yych <= 0x7F) goto yy1818; + if (yych <= 0xBF) goto yy1817; + goto yy1818; +yy1821: + yych = *++p; + if (yych <= 0x8F) goto yy1818; + if (yych <= 0xBF) goto yy1820; + goto yy1818; +yy1822: + yych = *++p; + if (yych <= 0x7F) goto yy1818; + if (yych <= 0xBF) goto yy1820; + goto yy1818; +yy1823: + yych = *++p; + if (yych <= 0x7F) goto yy1818; + if (yych <= 0x8F) goto yy1820; + goto yy1818; +yy1824: + yych = *++p; + if (yych <= 0x7F) goto yy1818; + if (yych <= 0x9F) goto yy1817; + goto yy1818; +yy1825: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1825; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych == '\n') goto yy1818; + } else { + if (yych <= '>') goto yy1837; + if (yych <= 0x7F) goto yy1827; + if (yych <= 0xC1) goto yy1818; + goto yy1829; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1830; + if (yych == 0xED) goto yy1835; + goto yy1831; + } else { + if (yych <= 0xF0) goto yy1832; + if (yych <= 0xF3) goto yy1833; + if (yych <= 0xF4) goto yy1834; + goto yy1818; + } + } +yy1827: + ++p; + yych = *p; +yy1828: + if (yybm[0+yych] & 128) { + goto yy1827; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1818; + if (yych <= ']') goto yy1836; + goto yy1818; + } else { + if (yych <= 0xDF) goto yy1829; + if (yych <= 0xE0) goto yy1830; + goto yy1831; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1835; + if (yych <= 0xEF) goto yy1831; + goto yy1832; + } else { + if (yych <= 0xF3) goto yy1833; + if (yych <= 0xF4) goto yy1834; + goto yy1818; + } + } +yy1829: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1818; + if (yych <= 0xBF) goto yy1827; + goto yy1818; +yy1830: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1818; + if (yych <= 0xBF) goto yy1829; + goto yy1818; +yy1831: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1818; + if (yych <= 0xBF) goto yy1829; + goto yy1818; +yy1832: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1818; + if (yych <= 0xBF) goto yy1831; + goto yy1818; +yy1833: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1818; + if (yych <= 0xBF) goto yy1831; + goto yy1818; +yy1834: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1818; + if (yych <= 0x8F) goto yy1831; + goto yy1818; +yy1835: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1818; + if (yych <= 0x9F) goto yy1829; + goto yy1818; +yy1836: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1827; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1818; + if (yych <= ']') goto yy1825; + goto yy1818; + } else { + if (yych <= 0xDF) goto yy1829; + if (yych <= 0xE0) goto yy1830; + goto yy1831; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1835; + if (yych <= 0xEF) goto yy1831; + goto yy1832; + } else { + if (yych <= 0xF3) goto yy1833; + if (yych <= 0xF4) goto yy1834; + goto yy1818; + } + } +yy1837: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1827; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') goto yy1838; + if (yych <= ']') goto yy1836; + } else { + if (yych <= 0xDF) goto yy1829; + if (yych <= 0xE0) goto yy1830; + goto yy1831; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1835; + if (yych <= 0xEF) goto yy1831; + goto yy1832; + } else { + if (yych <= 0xF3) goto yy1833; + if (yych <= 0xF4) goto yy1834; + } + } +yy1838: + { return (bufsize_t)(p - start); } +} + +} + +// 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. +bufsize_t _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, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 8, 128, 128, 8, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 136, 224, 224, 224, 224, 224, 224, 224, + 128, 128, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 32, 224, 32, 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, 224, 224, 224, 16, 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, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 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 = *(marker = p); + if (yych <= '[') { + if (yych <= ' ') { + if (yych <= '\f') { + if (yych == '\n') goto yy1842; + goto yy1858; + } else { + if (yych <= '\r') goto yy1844; + if (yych <= 0x1F) goto yy1858; + goto yy1844; + } + } else { + if (yych <= ')') { + if (yych <= '\'') goto yy1846; + if (yych <= '(') goto yy1857; + goto yy1858; + } else { + if (yych == '<') goto yy1845; + goto yy1846; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') goto yy1855; + if (yych <= 0x7F) goto yy1846; + } else { + if (yych <= 0xDF) goto yy1847; + if (yych <= 0xE0) goto yy1849; + goto yy1850; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1854; + if (yych <= 0xEF) goto yy1850; + goto yy1851; + } else { + if (yych <= 0xF3) goto yy1852; + if (yych <= 0xF4) goto yy1853; + } + } + } +yy1841: + { return (bufsize_t)(p - start); } +yy1842: + yyaccept = 0; + marker = ++p; + yych = *p; +yy1843: + if (yybm[0+yych] & 8) { + goto yy1842; + } + if (yych <= 0x7F) { + if (yych <= ')') { + if (yych <= 0x1F) goto yy1841; + if (yych <= '\'') goto yy1870; + if (yych <= '(') goto yy1861; + goto yy1841; + } else { + if (yych <= '<') { + if (yych <= ';') goto yy1870; + goto yy1905; + } else { + if (yych == '\\') goto yy1879; + goto yy1870; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) { + if (yych <= 0xC1) goto yy1841; + goto yy1872; + } else { + if (yych <= 0xE0) goto yy1873; + if (yych <= 0xEC) goto yy1874; + goto yy1878; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1874; + goto yy1875; + } else { + if (yych <= 0xF3) goto yy1876; + if (yych <= 0xF4) goto yy1877; + goto yy1841; + } + } + } +yy1844: + yyaccept = 0; + yych = *(marker = ++p); + goto yy1843; +yy1845: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0+yych] & 64) { + goto yy1905; + } + if (yych <= '>') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1841; + goto yy1919; + } else { + if (yych <= '\n') goto yy1841; + if (yych <= '\f') goto yy1919; + goto yy1841; + } + } else { + if (yych <= '(') { + if (yych <= ' ') goto yy1919; + goto yy1917; + } else { + if (yych <= ')') goto yy1919; + if (yych <= '<') goto yy1870; + goto yy1907; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') goto yy1916; + goto yy1841; + } else { + if (yych <= 0xDF) goto yy1909; + if (yych <= 0xE0) goto yy1910; + goto yy1911; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1915; + if (yych <= 0xEF) goto yy1911; + goto yy1912; + } else { + if (yych <= 0xF3) goto yy1913; + if (yych <= 0xF4) goto yy1914; + goto yy1841; + } + } + } +yy1846: + yyaccept = 0; + yych = *(marker = ++p); + goto yy1871; +yy1847: + yych = *++p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1846; +yy1848: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy1841; + } else { + goto yy1856; + } + } else { + goto yy1908; + } +yy1849: + yych = *++p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1847; + goto yy1848; +yy1850: + yych = *++p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1847; + goto yy1848; +yy1851: + yych = *++p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1850; + goto yy1848; +yy1852: + yych = *++p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1850; + goto yy1848; +yy1853: + yych = *++p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1850; + goto yy1848; +yy1854: + yych = *++p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1847; + goto yy1848; +yy1855: + yyaccept = 1; + yych = *(marker = ++p); + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) goto yy1870; + } else { + if (yych <= 0xDF) goto yy1880; + if (yych <= 0xE0) goto yy1881; + goto yy1882; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1886; + if (yych <= 0xEF) goto yy1882; + goto yy1883; + } else { + if (yych <= 0xF3) goto yy1884; + if (yych <= 0xF4) goto yy1885; + } + } +yy1856: + { return 0; } +yy1857: + yyaccept = 1; + yych = *(marker = ++p); + if (yych <= '(') { + if (yych <= ' ') goto yy1856; + if (yych <= '\'') goto yy1862; + goto yy1856; + } else { + if (yych <= 0x7F) goto yy1862; + if (yych <= 0xC1) goto yy1856; + if (yych <= 0xF4) goto yy1862; + goto yy1856; + } +yy1858: + yych = *++p; + goto yy1856; +yy1859: + ++p; + yych = *p; + if (yybm[0+yych] & 16) { + goto yy1859; + } + if (yych <= 0xE0) { + if (yych <= ')') { + if (yych <= ' ') goto yy1848; + if (yych >= ')') goto yy1887; + } else { + if (yych <= 0x7F) goto yy1861; + if (yych <= 0xC1) goto yy1848; + if (yych <= 0xDF) goto yy1863; + goto yy1864; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1869; + goto yy1865; + } else { + if (yych <= 0xF0) goto yy1866; + if (yych <= 0xF3) goto yy1867; + if (yych <= 0xF4) goto yy1868; + goto yy1848; + } + } +yy1861: + ++p; + yych = *p; +yy1862: + if (yybm[0+yych] & 32) { + goto yy1861; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= '(') goto yy1848; + if (yych <= ')') goto yy1870; + goto yy1859; + } else { + if (yych <= 0xC1) goto yy1848; + if (yych >= 0xE0) goto yy1864; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1869; + goto yy1865; + } else { + if (yych <= 0xF0) goto yy1866; + if (yych <= 0xF3) goto yy1867; + if (yych <= 0xF4) goto yy1868; + goto yy1848; + } + } +yy1863: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1861; + goto yy1848; +yy1864: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1863; + goto yy1848; +yy1865: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1863; + goto yy1848; +yy1866: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1865; + goto yy1848; +yy1867: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1865; + goto yy1848; +yy1868: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1865; + goto yy1848; +yy1869: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1863; + goto yy1848; +yy1870: + yyaccept = 0; + marker = ++p; + yych = *p; +yy1871: + if (yych <= 0xC1) { + if (yych <= ')') { + if (yych <= ' ') goto yy1841; + if (yych <= '\'') goto yy1870; + if (yych <= '(') goto yy1861; + goto yy1841; + } else { + if (yych == '\\') goto yy1879; + if (yych <= 0x7F) goto yy1870; + goto yy1841; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1872; + if (yych <= 0xE0) goto yy1873; + if (yych <= 0xEC) goto yy1874; + goto yy1878; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1874; + goto yy1875; + } else { + if (yych <= 0xF3) goto yy1876; + if (yych <= 0xF4) goto yy1877; + goto yy1841; + } + } + } +yy1872: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1870; + goto yy1848; +yy1873: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1872; + goto yy1848; +yy1874: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1872; + goto yy1848; +yy1875: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1874; + goto yy1848; +yy1876: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1874; + goto yy1848; +yy1877: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1874; + goto yy1848; +yy1878: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1872; + goto yy1848; +yy1879: + ++p; + yych = *p; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) goto yy1870; + goto yy1848; + } else { + if (yych <= 0xDF) goto yy1880; + if (yych <= 0xE0) goto yy1881; + goto yy1882; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1886; + if (yych <= 0xEF) goto yy1882; + goto yy1883; + } else { + if (yych <= 0xF3) goto yy1884; + if (yych <= 0xF4) goto yy1885; + goto yy1848; + } + } +yy1880: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1870; + goto yy1848; +yy1881: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1880; + goto yy1848; +yy1882: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1880; + goto yy1848; +yy1883: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1882; + goto yy1848; +yy1884: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1882; + goto yy1848; +yy1885: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1882; + goto yy1848; +yy1886: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1880; + goto yy1848; +yy1887: + yyaccept = 0; + marker = ++p; + yych = *p; +yy1888: + if (yych <= 0xC1) { + if (yych <= ')') { + if (yych <= ' ') goto yy1841; + if (yych <= '\'') goto yy1887; + if (yych <= '(') goto yy1861; + goto yy1870; + } else { + if (yych == '\\') goto yy1896; + if (yych <= 0x7F) goto yy1887; + goto yy1841; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1889; + if (yych <= 0xE0) goto yy1890; + if (yych <= 0xEC) goto yy1891; + goto yy1895; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1891; + goto yy1892; + } else { + if (yych <= 0xF3) goto yy1893; + if (yych <= 0xF4) goto yy1894; + goto yy1841; + } + } + } +yy1889: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1887; + goto yy1848; +yy1890: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1889; + goto yy1848; +yy1891: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1889; + goto yy1848; +yy1892: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1891; + goto yy1848; +yy1893: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1891; + goto yy1848; +yy1894: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1891; + goto yy1848; +yy1895: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1889; + goto yy1848; +yy1896: + ++p; + yych = *p; + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= ' ') goto yy1870; + if (yych <= '[') goto yy1887; + } else { + if (yych <= 0x7F) goto yy1887; + if (yych <= 0xC1) goto yy1848; + if (yych <= 0xDF) goto yy1898; + goto yy1899; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1904; + goto yy1900; + } else { + if (yych <= 0xF0) goto yy1901; + if (yych <= 0xF3) goto yy1902; + if (yych <= 0xF4) goto yy1903; + goto yy1848; + } + } + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= 0xDF) { + if (yych <= '[') { + if (yych <= ' ') goto yy1841; + if (yych == '(') goto yy1861; + goto yy1887; + } else { + if (yych <= '\\') goto yy1896; + if (yych <= 0x7F) goto yy1887; + if (yych <= 0xC1) goto yy1841; + goto yy1889; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy1890; + if (yych == 0xED) goto yy1895; + goto yy1891; + } else { + if (yych <= 0xF0) goto yy1892; + if (yych <= 0xF3) goto yy1893; + if (yych <= 0xF4) goto yy1894; + goto yy1841; + } + } +yy1898: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1887; + goto yy1848; +yy1899: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1898; + goto yy1848; +yy1900: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1898; + goto yy1848; +yy1901: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1900; + goto yy1848; +yy1902: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1900; + goto yy1848; +yy1903: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1900; + goto yy1848; +yy1904: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1898; + goto yy1848; +yy1905: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1905; + } + if (yych <= '>') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1841; + goto yy1919; + } else { + if (yych <= '\n') goto yy1841; + if (yych <= '\f') goto yy1919; + goto yy1841; + } + } else { + if (yych <= '(') { + if (yych <= ' ') goto yy1919; + goto yy1917; + } else { + if (yych <= ')') goto yy1919; + if (yych <= '<') goto yy1870; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') goto yy1916; + goto yy1841; + } else { + if (yych <= 0xDF) goto yy1909; + if (yych <= 0xE0) goto yy1910; + goto yy1911; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1915; + if (yych <= 0xEF) goto yy1911; + goto yy1912; + } else { + if (yych <= 0xF3) goto yy1913; + if (yych <= 0xF4) goto yy1914; + goto yy1841; + } + } + } +yy1907: + yyaccept = 2; + yych = *(marker = ++p); + if (yych <= ')') { + if (yych <= ' ') goto yy1908; + if (yych <= '(') goto yy1871; + } else { + if (yych <= 0x7F) goto yy1871; + if (yych <= 0xC1) goto yy1908; + if (yych <= 0xF4) goto yy1871; + } +yy1908: + { return (bufsize_t)(p - start); } +yy1909: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1905; + goto yy1848; +yy1910: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1909; + goto yy1848; +yy1911: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1909; + goto yy1848; +yy1912: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1911; + goto yy1848; +yy1913: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1911; + goto yy1848; +yy1914: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1911; + goto yy1848; +yy1915: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1909; + goto yy1848; +yy1916: + ++p; + yych = *p; + if (yych <= 0x7F) { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1870; + goto yy1905; + } else { + if (yych <= '\n') goto yy1870; + if (yych <= '\f') goto yy1905; + goto yy1870; + } + } else { + if (yych <= '>') { + if (yych <= '=') goto yy1905; + goto yy1963; + } else { + if (yych == '\\') goto yy1964; + goto yy1905; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) { + if (yych <= 0xC1) goto yy1848; + goto yy1965; + } else { + if (yych <= 0xE0) goto yy1966; + if (yych <= 0xEC) goto yy1967; + goto yy1971; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1967; + goto yy1968; + } else { + if (yych <= 0xF3) goto yy1969; + if (yych <= 0xF4) goto yy1970; + goto yy1848; + } + } + } +yy1917: + ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1848; + if (yych >= '\n') goto yy1848; + } else { + if (yych == '\r') goto yy1848; + } + } else { + if (yych <= ')') { + if (yych <= '\'') goto yy1917; + if (yych >= ')') goto yy1905; + } else { + if (yych == '<') goto yy1861; + if (yych <= '=') goto yy1917; + goto yy1932; + } + } + } else { + if (yych <= 0xE0) { + if (yych <= 0x7F) { + if (yych == '\\') goto yy1933; + goto yy1917; + } else { + if (yych <= 0xC1) goto yy1848; + if (yych <= 0xDF) goto yy1935; + goto yy1936; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1941; + goto yy1937; + } else { + if (yych <= 0xF0) goto yy1938; + if (yych <= 0xF3) goto yy1939; + if (yych <= 0xF4) goto yy1940; + goto yy1848; + } + } + } +yy1919: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1919; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= '<') goto yy1848; + if (yych >= '?') goto yy1922; + } else { + if (yych <= 0xC1) goto yy1848; + if (yych <= 0xDF) goto yy1924; + goto yy1925; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1930; + goto yy1926; + } else { + if (yych <= 0xF0) goto yy1927; + if (yych <= 0xF3) goto yy1928; + if (yych <= 0xF4) goto yy1929; + goto yy1848; + } + } +yy1921: + yych = *++p; + goto yy1908; +yy1922: + ++p; + yych = *p; + if (yych <= 0x7F) { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1848; + goto yy1919; + } else { + if (yych <= '\n') goto yy1848; + if (yych <= '\f') goto yy1919; + goto yy1848; + } + } else { + if (yych <= '>') { + if (yych <= '=') goto yy1919; + goto yy1931; + } else { + if (yych == '\\') goto yy1922; + goto yy1919; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) { + if (yych <= 0xC1) goto yy1848; + } else { + if (yych <= 0xE0) goto yy1925; + if (yych <= 0xEC) goto yy1926; + goto yy1930; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1926; + goto yy1927; + } else { + if (yych <= 0xF3) goto yy1928; + if (yych <= 0xF4) goto yy1929; + goto yy1848; + } + } + } +yy1924: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1919; + goto yy1848; +yy1925: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1924; + goto yy1848; +yy1926: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1924; + goto yy1848; +yy1927: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1926; + goto yy1848; +yy1928: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1926; + goto yy1848; +yy1929: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1926; + goto yy1848; +yy1930: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1924; + goto yy1848; +yy1931: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1919; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= '<') goto yy1908; + if (yych <= '>') goto yy1921; + goto yy1922; + } else { + if (yych <= 0xC1) goto yy1908; + if (yych <= 0xDF) goto yy1924; + goto yy1925; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1930; + goto yy1926; + } else { + if (yych <= 0xF0) goto yy1927; + if (yych <= 0xF3) goto yy1928; + if (yych <= 0xF4) goto yy1929; + goto yy1908; + } + } +yy1932: + yyaccept = 2; + yych = *(marker = ++p); + if (yych <= '(') { + if (yych <= ' ') goto yy1908; + if (yych <= '\'') goto yy1862; + goto yy1908; + } else { + if (yych <= 0x7F) goto yy1862; + if (yych <= 0xC1) goto yy1908; + if (yych <= 0xF4) goto yy1862; + goto yy1908; + } +yy1933: + ++p; + yych = *p; + if (yych <= '[') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1848; + goto yy1919; + } else { + if (yych <= '\n') goto yy1848; + if (yych <= '\f') goto yy1919; + goto yy1848; + } + } else { + if (yych <= ')') { + if (yych <= ' ') goto yy1919; + if (yych <= '(') goto yy1917; + goto yy1942; + } else { + if (yych == '>') goto yy1944; + goto yy1917; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') goto yy1933; + if (yych <= 0x7F) goto yy1917; + goto yy1848; + } else { + if (yych <= 0xDF) goto yy1935; + if (yych <= 0xE0) goto yy1936; + goto yy1937; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1941; + if (yych <= 0xEF) goto yy1937; + goto yy1938; + } else { + if (yych <= 0xF3) goto yy1939; + if (yych <= 0xF4) goto yy1940; + goto yy1848; + } + } + } +yy1935: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1917; + goto yy1848; +yy1936: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1935; + goto yy1848; +yy1937: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1935; + goto yy1848; +yy1938: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1937; + goto yy1848; +yy1939: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1937; + goto yy1848; +yy1940: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1937; + goto yy1848; +yy1941: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1935; + goto yy1848; +yy1942: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1841; + if (yych <= '\t') goto yy1919; + goto yy1841; + } else { + if (yych == '\r') goto yy1841; + goto yy1919; + } + } else { + if (yych <= ')') { + if (yych <= '\'') goto yy1942; + if (yych <= '(') goto yy1917; + goto yy1905; + } else { + if (yych == '<') goto yy1887; + if (yych <= '=') goto yy1942; + goto yy1945; + } + } + } else { + if (yych <= 0xE0) { + if (yych <= 0x7F) { + if (yych == '\\') goto yy1946; + goto yy1942; + } else { + if (yych <= 0xC1) goto yy1841; + if (yych <= 0xDF) goto yy1947; + goto yy1948; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1953; + goto yy1949; + } else { + if (yych <= 0xF0) goto yy1950; + if (yych <= 0xF3) goto yy1951; + if (yych <= 0xF4) goto yy1952; + goto yy1841; + } + } + } +yy1944: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1908; + if (yych <= '\t') goto yy1919; + goto yy1908; + } else { + if (yych == '\r') goto yy1908; + goto yy1919; + } + } else { + if (yych <= ')') { + if (yych <= '\'') goto yy1917; + if (yych <= '(') goto yy1919; + goto yy1905; + } else { + if (yych == '<') goto yy1861; + if (yych <= '=') goto yy1917; + goto yy1932; + } + } + } else { + if (yych <= 0xE0) { + if (yych <= 0x7F) { + if (yych == '\\') goto yy1933; + goto yy1917; + } else { + if (yych <= 0xC1) goto yy1908; + if (yych <= 0xDF) goto yy1935; + goto yy1936; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1941; + goto yy1937; + } else { + if (yych <= 0xF0) goto yy1938; + if (yych <= 0xF3) goto yy1939; + if (yych <= 0xF4) goto yy1940; + goto yy1908; + } + } + } +yy1945: + yyaccept = 2; + yych = *(marker = ++p); + if (yych <= ' ') goto yy1908; + if (yych <= 0x7F) goto yy1888; + if (yych <= 0xC1) goto yy1908; + if (yych <= 0xF4) goto yy1888; + goto yy1908; +yy1946: + ++p; + yych = *p; + if (yych <= '\\') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1870; + goto yy1905; + } else { + if (yych <= '\n') goto yy1870; + if (yych <= '\f') goto yy1905; + goto yy1870; + } + } else { + if (yych <= '=') { + if (yych <= ' ') goto yy1905; + goto yy1942; + } else { + if (yych <= '>') goto yy1954; + if (yych <= '[') goto yy1942; + goto yy1955; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) goto yy1942; + goto yy1848; + } else { + if (yych <= 0xDF) goto yy1956; + if (yych <= 0xE0) goto yy1957; + goto yy1958; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1962; + if (yych <= 0xEF) goto yy1958; + goto yy1959; + } else { + if (yych <= 0xF3) goto yy1960; + if (yych <= 0xF4) goto yy1961; + goto yy1848; + } + } + } +yy1947: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1942; + goto yy1848; +yy1948: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1947; + goto yy1848; +yy1949: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1947; + goto yy1848; +yy1950: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1949; + goto yy1848; +yy1951: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1949; + goto yy1848; +yy1952: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1949; + goto yy1848; +yy1953: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1947; + goto yy1848; +yy1954: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1908; + if (yych <= '\t') goto yy1919; + goto yy1908; + } else { + if (yych == '\r') goto yy1908; + goto yy1919; + } } else { - if (yych <= '\r') goto yy1591; - if (yych <= 0x1F) goto yy1597; - if (yych <= ' ') goto yy1591; - goto yy1593; + if (yych <= ')') { + if (yych <= '\'') goto yy1942; + if (yych <= '(') goto yy1917; + goto yy1905; + } else { + if (yych == '<') goto yy1887; + if (yych <= '=') goto yy1942; + goto yy1945; + } } } else { - if (yych <= ';') { - if (yych <= '(') goto yy1596; - if (yych <= ')') goto yy1597; - goto yy1593; + if (yych <= 0xE0) { + if (yych <= 0x7F) { + if (yych == '\\') goto yy1946; + goto yy1942; + } else { + if (yych <= 0xC1) goto yy1908; + if (yych <= 0xDF) goto yy1947; + goto yy1948; + } } else { - if (yych <= '<') goto yy1592; - if (yych == '\\') goto yy1594; - goto yy1593; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1953; + goto yy1949; + } else { + if (yych <= 0xF0) goto yy1950; + if (yych <= 0xF3) goto yy1951; + if (yych <= 0xF4) goto yy1952; + goto yy1908; + } } } -yy1588: - { return (bufsize_t)(p - start); } -yy1589: +yy1955: yyaccept = 0; marker = ++p; yych = *p; -yy1590: - if (yybm[0+yych] & 8) { - goto yy1589; - } - if (yych <= ')') { - if (yych <= ' ') goto yy1588; - if (yych <= '\'') goto yy1602; - if (yych <= '(') goto yy1598; - goto yy1588; - } else { - if (yych <= '<') { - if (yych <= ';') goto yy1602; - goto yy1605; - } else { - if (yych == '\\') goto yy1604; - goto yy1602; - } - } -yy1591: - yyaccept = 0; - yych = *(marker = ++p); - goto yy1590; -yy1592: - yyaccept = 0; - yych = *(marker = ++p); - if (yybm[0+yych] & 32) { - goto yy1605; - } - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1588; - goto yy1612; + if (yych <= '[') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1841; + goto yy1919; + } else { + if (yych <= '\n') goto yy1841; + if (yych <= '\f') goto yy1919; + goto yy1841; + } } else { - if (yych <= '\n') goto yy1588; - if (yych <= '\f') goto yy1612; - goto yy1588; + if (yych <= '(') { + if (yych <= ' ') goto yy1919; + if (yych <= '\'') goto yy1942; + goto yy1917; + } else { + if (yych == '>') goto yy1954; + goto yy1942; + } } } else { - if (yych <= ')') { - if (yych == '(') goto yy1610; - goto yy1612; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') goto yy1946; + if (yych <= 0x7F) goto yy1942; + goto yy1841; + } else { + if (yych <= 0xDF) goto yy1947; + if (yych <= 0xE0) goto yy1948; + goto yy1949; + } } else { - if (yych <= '=') goto yy1602; - if (yych <= '>') goto yy1607; - goto yy1609; + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1953; + if (yych <= 0xEF) goto yy1949; + goto yy1950; + } else { + if (yych <= 0xF3) goto yy1951; + if (yych <= 0xF4) goto yy1952; + goto yy1841; + } } } -yy1593: - yyaccept = 0; - yych = *(marker = ++p); - goto yy1603; -yy1594: +yy1956: ++p; - if ((yych = *p) <= '@') { - if (yych <= ' ') goto yy1595; - if (yych <= '/') goto yy1602; - if (yych >= ':') goto yy1602; - } else { - if (yych <= '`') { - if (yych >= '[') goto yy1602; - } else { - if (yych <= 'z') goto yy1595; - if (yych <= '~') goto yy1602; - } - } -yy1595: - { return 0; } -yy1596: - yyaccept = 1; - yych = *(marker = ++p); - if (yych <= ' ') goto yy1595; - if (yych == '(') goto yy1595; - goto yy1599; -yy1597: - yych = *++p; - goto yy1595; -yy1598: + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1942; + goto yy1848; +yy1957: ++p; yych = *p; -yy1599: - if (yybm[0+yych] & 16) { - goto yy1598; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1956; + goto yy1848; +yy1958: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1956; + goto yy1848; +yy1959: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1958; + goto yy1848; +yy1960: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1958; + goto yy1848; +yy1961: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1958; + goto yy1848; +yy1962: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1956; + goto yy1848; +yy1963: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1905; } - if (yych <= '(') goto yy1600; - if (yych <= ')') goto yy1602; - goto yy1601; -yy1600: - p = marker; - if (yyaccept <= 1) { - if (yyaccept <= 0) { - goto yy1588; + if (yych <= '>') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) goto yy1908; + goto yy1919; + } else { + if (yych <= '\n') goto yy1908; + if (yych <= '\f') goto yy1919; + goto yy1908; + } } else { - goto yy1595; + if (yych <= '(') { + if (yych <= ' ') goto yy1919; + goto yy1917; + } else { + if (yych <= ')') goto yy1919; + if (yych <= '<') goto yy1870; + goto yy1907; + } } } else { - goto yy1608; - } -yy1601: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= ' ') goto yy1600; - if (yych <= '/') goto yy1598; - if (yych <= '9') goto yy1600; - goto yy1598; - } else { - if (yych <= '`') { - if (yych <= 'Z') goto yy1600; - goto yy1598; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') goto yy1916; + goto yy1908; + } else { + if (yych <= 0xDF) goto yy1909; + if (yych <= 0xE0) goto yy1910; + goto yy1911; + } } else { - if (yych <= 'z') goto yy1600; - if (yych <= '~') goto yy1598; - goto yy1600; + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1915; + if (yych <= 0xEF) goto yy1911; + goto yy1912; + } else { + if (yych <= 0xF3) goto yy1913; + if (yych <= 0xF4) goto yy1914; + goto yy1908; + } } } -yy1602: +yy1964: yyaccept = 0; marker = ++p; yych = *p; -yy1603: - if (yych <= '(') { - if (yych <= ' ') goto yy1588; - if (yych <= '\'') goto yy1602; - goto yy1598; + if (yych <= '[') { + if (yych <= ' ') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1841; + if (yych <= '\t') goto yy1919; + goto yy1841; + } else { + if (yych == '\r') goto yy1841; + goto yy1919; + } + } else { + if (yych <= ')') { + if (yych <= '\'') goto yy1905; + if (yych <= '(') goto yy1917; + goto yy1919; + } else { + if (yych == '>') goto yy1963; + goto yy1905; + } + } } else { - if (yych <= ')') goto yy1588; - if (yych != '\\') goto yy1602; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') goto yy1916; + if (yych <= 0x7F) goto yy1905; + goto yy1841; + } else { + if (yych <= 0xDF) goto yy1909; + if (yych <= 0xE0) goto yy1910; + goto yy1911; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy1915; + if (yych <= 0xEF) goto yy1911; + goto yy1912; + } else { + if (yych <= 0xF3) goto yy1913; + if (yych <= 0xF4) goto yy1914; + goto yy1841; + } + } } -yy1604: +yy1965: ++p; yych = *p; - if (yych <= '@') { - if (yych <= ' ') goto yy1600; - if (yych <= '/') goto yy1602; - if (yych <= '9') goto yy1600; - goto yy1602; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1905; + goto yy1848; +yy1966: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1848; + if (yych <= 0xBF) goto yy1965; + goto yy1848; +yy1967: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1965; + goto yy1848; +yy1968: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1848; + if (yych <= 0xBF) goto yy1967; + goto yy1848; +yy1969: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0xBF) goto yy1967; + goto yy1848; +yy1970: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x8F) goto yy1967; + goto yy1848; +yy1971: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1848; + if (yych <= 0x9F) goto yy1965; + goto yy1848; +} + +} + +// 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). +bufsize_t _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, 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, 224, 224, 224, 224, 224, + 224, 224, 96, 224, 224, 224, 224, 160, + 224, 192, 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, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 16, 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, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 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 = *(marker = p); + if (yych <= 0xC1) { + if (yych <= '"') { + if (yych == '\n') goto yy1974; + if (yych <= '!') goto yy1978; + goto yy1975; + } else { + if (yych <= '\'') { + if (yych <= '&') goto yy1978; + goto yy1976; + } else { + if (yych <= '(') goto yy1977; + if (yych <= 0x7F) goto yy1978; + } + } } else { - if (yych <= '`') { - if (yych <= 'Z') goto yy1600; - goto yy1602; + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy1979; + if (yych <= 0xE0) goto yy1981; + if (yych <= 0xEC) goto yy1982; + goto yy1986; } else { - if (yych <= 'z') goto yy1600; - if (yych <= '~') goto yy1602; - goto yy1600; + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy1982; + goto yy1983; + } else { + if (yych <= 0xF3) goto yy1984; + if (yych <= 0xF4) goto yy1985; + } } } -yy1605: +yy1974: + { return 0; } +yy1975: yyaccept = 0; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1605; - } - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1588; - goto yy1612; + yych = *(marker = ++p); + if (yych <= 0x00) goto yy1974; + if (yych <= 0x7F) goto yy2018; + if (yych <= 0xC1) goto yy1974; + if (yych <= 0xF4) goto yy2018; + goto yy1974; +yy1976: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) goto yy1974; + if (yych <= 0x7F) goto yy2004; + if (yych <= 0xC1) goto yy1974; + if (yych <= 0xF4) goto yy2004; + goto yy1974; +yy1977: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) goto yy1974; + if (yych <= 0x7F) goto yy1990; + if (yych <= 0xC1) goto yy1974; + if (yych <= 0xF4) goto yy1990; + goto yy1974; +yy1978: + yych = *++p; + goto yy1974; +yy1979: + yych = *++p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy1978; +yy1980: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy1974; } else { - if (yych <= '\n') goto yy1588; - if (yych <= '\f') goto yy1612; - goto yy1588; + goto yy1999; } } else { - if (yych <= ')') { - if (yych == '(') goto yy1610; - goto yy1612; + if (yyaccept == 2) { + goto yy2013; } else { - if (yych <= '=') goto yy1602; - if (yych >= '?') goto yy1609; + goto yy2027; } } -yy1607: - yyaccept = 2; - yych = *(marker = ++p); - if (yych <= ' ') goto yy1608; - if (yych != ')') goto yy1603; -yy1608: - { return (bufsize_t)(p - start); } -yy1609: +yy1981: + yych = *++p; + if (yych <= 0x9F) goto yy1980; + if (yych <= 0xBF) goto yy1979; + goto yy1980; +yy1982: + yych = *++p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy1979; + goto yy1980; +yy1983: + yych = *++p; + if (yych <= 0x8F) goto yy1980; + if (yych <= 0xBF) goto yy1982; + goto yy1980; +yy1984: + yych = *++p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy1982; + goto yy1980; +yy1985: + yych = *++p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0x8F) goto yy1982; + goto yy1980; +yy1986: + yych = *++p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0x9F) goto yy1979; + goto yy1980; +yy1987: ++p; yych = *p; - if (yych <= '=') { - if (yych <= '\f') { - if (yych <= 0x00) goto yy1600; - if (yych == '\n') goto yy1600; - goto yy1612; + if (yybm[0+yych] & 32) { + goto yy1989; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) goto yy1980; + if (yych <= ')') goto yy2000; + goto yy1987; } else { - if (yych <= ' ') { - if (yych <= '\r') goto yy1600; - goto yy1612; - } else { - if (yych <= '/') goto yy1605; - if (yych <= '9') goto yy1612; - goto yy1605; - } + if (yych <= 0xC1) goto yy1980; + if (yych <= 0xDF) goto yy1991; + goto yy1992; } } else { - if (yych <= '[') { - if (yych <= '>') goto yy1622; - if (yych <= '@') goto yy1605; - if (yych <= 'Z') goto yy1612; - goto yy1605; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1997; + goto yy1993; } else { - if (yych <= '`') { - if (yych <= '\\') goto yy1623; - goto yy1605; - } else { - if (yych <= 'z') goto yy1612; - if (yych <= '~') goto yy1605; - goto yy1612; - } + if (yych <= 0xF0) goto yy1994; + if (yych <= 0xF3) goto yy1995; + if (yych <= 0xF4) goto yy1996; + goto yy1980; } } -yy1610: +yy1989: ++p; yych = *p; - if (yych <= '(') { - if (yych <= '\f') { - if (yych <= 0x00) goto yy1600; - if (yych == '\n') goto yy1600; +yy1990: + if (yybm[0+yych] & 32) { + goto yy1989; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) goto yy1980; + if (yych <= ')') goto yy1998; + goto yy1987; } else { - if (yych <= '\r') goto yy1600; - if (yych <= ' ') goto yy1612; - if (yych <= '\'') goto yy1610; + if (yych <= 0xC1) goto yy1980; + if (yych >= 0xE0) goto yy1992; } } else { - if (yych <= '=') { - if (yych <= ')') goto yy1605; - if (yych == '<') goto yy1598; - goto yy1610; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1997; + goto yy1993; } else { - if (yych <= '>') goto yy1618; - if (yych == '\\') goto yy1619; - goto yy1610; + if (yych <= 0xF0) goto yy1994; + if (yych <= 0xF3) goto yy1995; + if (yych <= 0xF4) goto yy1996; + goto yy1980; } } -yy1612: +yy1991: ++p; yych = *p; - if (yybm[0+yych] & 64) { - goto yy1612; - } - if (yych <= '=') goto yy1600; - if (yych >= '?') goto yy1615; -yy1614: - yych = *++p; - goto yy1608; -yy1615: + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy1989; + goto yy1980; +yy1992: ++p; yych = *p; - if (yybm[0+yych] & 128) { - goto yy1615; - } - if (yych <= '\f') { - if (yych <= 0x00) goto yy1600; - if (yych == '\n') goto yy1600; - goto yy1612; - } else { - if (yych <= '\r') goto yy1600; - if (yych != '>') goto yy1612; - } - yyaccept = 2; - marker = ++p; + if (yych <= 0x9F) goto yy1980; + if (yych <= 0xBF) goto yy1991; + goto yy1980; +yy1993: + ++p; yych = *p; - if (yybm[0+yych] & 64) { - goto yy1612; - } - if (yych <= '=') goto yy1608; - if (yych <= '>') goto yy1614; - goto yy1615; -yy1618: - yyaccept = 2; - yych = *(marker = ++p); - if (yych <= ' ') goto yy1608; - if (yych == '(') goto yy1608; - goto yy1599; -yy1619: + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy1991; + goto yy1980; +yy1994: ++p; yych = *p; - if (yych <= '=') { - if (yych <= '\f') { - if (yych <= 0x00) goto yy1600; - if (yych == '\n') goto yy1600; - goto yy1612; + if (yych <= 0x8F) goto yy1980; + if (yych <= 0xBF) goto yy1993; + goto yy1980; +yy1995: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy1993; + goto yy1980; +yy1996: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0x8F) goto yy1993; + goto yy1980; +yy1997: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0x9F) goto yy1991; + goto yy1980; +yy1998: + ++p; +yy1999: + { return (bufsize_t)(p - start); } +yy2000: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1989; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) goto yy1999; + if (yych <= ')') goto yy1998; + goto yy1987; } else { - if (yych <= ' ') { - if (yych <= '\r') goto yy1600; - goto yy1612; - } else { - if (yych <= '/') goto yy1610; - if (yych <= '9') goto yy1612; - goto yy1610; - } + if (yych <= 0xC1) goto yy1999; + if (yych <= 0xDF) goto yy1991; + goto yy1992; } } else { - if (yych <= '[') { - if (yych <= '>') goto yy1620; - if (yych <= '@') goto yy1610; - if (yych <= 'Z') goto yy1612; - goto yy1610; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy1997; + goto yy1993; } else { - if (yych <= '`') { - if (yych <= '\\') goto yy1621; - goto yy1610; - } else { - if (yych <= 'z') goto yy1612; - if (yych <= '~') goto yy1610; - goto yy1612; - } + if (yych <= 0xF0) goto yy1994; + if (yych <= 0xF3) goto yy1995; + if (yych <= 0xF4) goto yy1996; + goto yy1999; } } -yy1620: - yyaccept = 2; - marker = ++p; +yy2001: + ++p; yych = *p; - if (yych <= '(') { - if (yych <= '\f') { - if (yych <= 0x00) goto yy1608; - if (yych == '\n') goto yy1608; - goto yy1612; + if (yybm[0+yych] & 64) { + goto yy2003; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) goto yy1980; + if (yych <= '\'') goto yy2014; + goto yy2001; } else { - if (yych <= '\r') goto yy1608; - if (yych <= ' ') goto yy1612; - if (yych <= '\'') goto yy1610; - goto yy1612; + if (yych <= 0xC1) goto yy1980; + if (yych <= 0xDF) goto yy2005; + goto yy2006; } } else { - if (yych <= '=') { - if (yych <= ')') goto yy1605; - if (yych == '<') goto yy1598; - goto yy1610; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy2011; + goto yy2007; } else { - if (yych <= '>') goto yy1618; - if (yych == '\\') goto yy1619; - goto yy1610; + if (yych <= 0xF0) goto yy2008; + if (yych <= 0xF3) goto yy2009; + if (yych <= 0xF4) goto yy2010; + goto yy1980; } } -yy1621: +yy2003: ++p; yych = *p; - if (yych <= '\'') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1600; - if (yych <= '\t') goto yy1612; - goto yy1600; +yy2004: + if (yybm[0+yych] & 64) { + goto yy2003; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) goto yy1980; + if (yych <= '\'') goto yy2012; + goto yy2001; } else { - if (yych == '\r') goto yy1600; - if (yych <= ' ') goto yy1612; - goto yy1610; + if (yych <= 0xC1) goto yy1980; + if (yych >= 0xE0) goto yy2006; } } else { - if (yych <= '=') { - if (yych <= '(') goto yy1612; - if (yych <= ')') goto yy1605; - goto yy1610; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy2011; + goto yy2007; } else { - if (yych <= '>') goto yy1620; - if (yych == '\\') goto yy1619; - goto yy1610; + if (yych <= 0xF0) goto yy2008; + if (yych <= 0xF3) goto yy2009; + if (yych <= 0xF4) goto yy2010; + goto yy1980; } } -yy1622: +yy2005: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy2003; + goto yy1980; +yy2006: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy1980; + if (yych <= 0xBF) goto yy2005; + goto yy1980; +yy2007: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy2005; + goto yy1980; +yy2008: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy1980; + if (yych <= 0xBF) goto yy2007; + goto yy1980; +yy2009: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy2007; + goto yy1980; +yy2010: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0x8F) goto yy2007; + goto yy1980; +yy2011: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy1980; + if (yych <= 0x9F) goto yy2005; + goto yy1980; +yy2012: + ++p; +yy2013: + { return (bufsize_t)(p - start); } +yy2014: yyaccept = 2; marker = ++p; yych = *p; - if (yybm[0+yych] & 32) { - goto yy1605; + if (yybm[0+yych] & 64) { + goto yy2003; } - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1608; - goto yy1612; + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) goto yy2013; + if (yych <= '\'') goto yy2012; + goto yy2001; } else { - if (yych <= '\n') goto yy1608; - if (yych <= '\f') goto yy1612; - goto yy1608; + if (yych <= 0xC1) goto yy2013; + if (yych <= 0xDF) goto yy2005; + goto yy2006; } } else { - if (yych <= ')') { - if (yych == '(') goto yy1610; - goto yy1612; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy2011; + goto yy2007; } else { - if (yych <= '=') goto yy1602; - if (yych <= '>') goto yy1607; - goto yy1609; + if (yych <= 0xF0) goto yy2008; + if (yych <= 0xF3) goto yy2009; + if (yych <= 0xF4) goto yy2010; + goto yy2013; } } -yy1623: - yyaccept = 0; - marker = ++p; +yy2015: + ++p; yych = *p; - if (yych <= '\'') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1588; - if (yych <= '\t') goto yy1612; - goto yy1588; + if (yybm[0+yych] & 128) { + goto yy2017; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) goto yy1980; + if (yych <= '"') goto yy2028; + goto yy2015; } else { - if (yych == '\r') goto yy1588; - if (yych <= ' ') goto yy1612; - goto yy1605; + if (yych <= 0xC1) goto yy1980; + if (yych <= 0xDF) goto yy2019; + goto yy2020; } } else { - if (yych <= '=') { - if (yych <= '(') goto yy1610; - if (yych <= ')') goto yy1612; - goto yy1605; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy2025; + goto yy2021; } else { - if (yych <= '>') goto yy1622; - if (yych == '\\') goto yy1609; - goto yy1605; + if (yych <= 0xF0) goto yy2022; + if (yych <= 0xF3) goto yy2023; + if (yych <= 0xF4) goto yy2024; + goto yy1980; } } -} - -} - -// 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). -bufsize_t _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 yy1626; - if (yych <= '!') goto yy1630; - goto yy1627; - } else { - if (yych <= '&') goto yy1630; - if (yych <= '\'') goto yy1628; - if (yych <= '(') goto yy1629; - goto yy1630; - } -yy1626: - { return 0; } -yy1627: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x00) goto yy1626; - goto yy1647; -yy1628: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x00) goto yy1626; - goto yy1640; -yy1629: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x00) goto yy1626; - goto yy1632; -yy1630: - yych = *++p; - goto yy1626; -yy1631: +yy2017: ++p; yych = *p; -yy1632: - if (yybm[0+yych] & 16) { - goto yy1631; +yy2018: + if (yybm[0+yych] & 128) { + goto yy2017; } - if (yych <= 0x00) goto yy1633; - if (yych <= '[') goto yy1636; - goto yy1634; -yy1633: - p = marker; - if (yyaccept <= 1) { - if (yyaccept <= 0) { - goto yy1626; + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) goto yy1980; + if (yych <= '"') goto yy2026; + goto yy2015; } else { - goto yy1637; + if (yych <= 0xC1) goto yy1980; + if (yych >= 0xE0) goto yy2020; } } else { - if (yyaccept <= 2) { - goto yy1644; + if (yych <= 0xEF) { + if (yych == 0xED) goto yy2025; + goto yy2021; } else { - goto yy1651; + if (yych <= 0xF0) goto yy2022; + if (yych <= 0xF3) goto yy2023; + if (yych <= 0xF4) goto yy2024; + goto yy1980; } } -yy1634: +yy2019: ++p; yych = *p; - if (yybm[0+yych] & 16) { - goto yy1631; - } - if (yych <= 0x00) goto yy1633; - if (yych <= '[') goto yy1638; - goto yy1634; -yy1636: + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy2017; + goto yy1980; +yy2020: ++p; -yy1637: - { return (bufsize_t)(p - start); } -yy1638: - yyaccept = 1; - marker = ++p; yych = *p; - if (yybm[0+yych] & 16) { - goto yy1631; - } - if (yych <= 0x00) goto yy1637; - if (yych <= '[') goto yy1636; - goto yy1634; -yy1639: + if (yych <= 0x9F) goto yy1980; + if (yych <= 0xBF) goto yy2019; + goto yy1980; +yy2021: ++p; yych = *p; -yy1640: - if (yybm[0+yych] & 64) { - goto yy1639; - } - if (yych <= 0x00) goto yy1633; - if (yych <= '[') goto yy1643; -yy1641: + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy2019; + goto yy1980; +yy2022: ++p; yych = *p; - if (yybm[0+yych] & 64) { - goto yy1639; - } - if (yych <= 0x00) goto yy1633; - if (yych <= '[') goto yy1645; - goto yy1641; -yy1643: + if (yych <= 0x8F) goto yy1980; + if (yych <= 0xBF) goto yy2021; + goto yy1980; +yy2023: ++p; -yy1644: - { return (bufsize_t)(p - start); } -yy1645: - yyaccept = 2; - marker = ++p; yych = *p; - if (yybm[0+yych] & 64) { - goto yy1639; - } - if (yych <= 0x00) goto yy1644; - if (yych <= '[') goto yy1643; - goto yy1641; -yy1646: + if (yych <= 0x7F) goto yy1980; + if (yych <= 0xBF) goto yy2021; + goto yy1980; +yy2024: ++p; yych = *p; -yy1647: - if (yybm[0+yych] & 128) { - goto yy1646; - } - if (yych <= 0x00) goto yy1633; - if (yych <= '[') goto yy1650; -yy1648: + if (yych <= 0x7F) goto yy1980; + if (yych <= 0x8F) goto yy2021; + goto yy1980; +yy2025: ++p; yych = *p; - if (yybm[0+yych] & 128) { - goto yy1646; - } - if (yych <= 0x00) goto yy1633; - if (yych <= '[') goto yy1652; - goto yy1648; -yy1650: + if (yych <= 0x7F) goto yy1980; + if (yych <= 0x9F) goto yy2019; + goto yy1980; +yy2026: ++p; -yy1651: +yy2027: { return (bufsize_t)(p - start); } -yy1652: +yy2028: yyaccept = 3; marker = ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1646; + goto yy2017; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) goto yy2027; + if (yych <= '"') goto yy2026; + goto yy2015; + } else { + if (yych <= 0xC1) goto yy2027; + if (yych <= 0xDF) goto yy2019; + goto yy2020; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy2025; + goto yy2021; + } else { + if (yych <= 0xF0) goto yy2022; + if (yych <= 0xF3) goto yy2023; + if (yych <= 0xF4) goto yy2024; + goto yy2027; + } } - if (yych <= 0x00) goto yy1651; - if (yych <= '[') goto yy1650; - goto yy1648; } } @@ -13924,6 +18722,7 @@ bufsize_t _scan_link_title(const unsigned char *p) // Match space characters, including newlines. bufsize_t _scan_spacechars(const unsigned char *p) { + const unsigned char *marker = NULL; const unsigned char *start = p; \ { @@ -13962,32 +18761,85 @@ bufsize_t _scan_spacechars(const unsigned char *p) 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 yy1659; - if (yych <= '\t') goto yy1656; - goto yy1657; + yych = *(marker = p); + if (yych <= 0xC1) { + if (yych <= '\r') { + if (yych <= 0x08) goto yy2035; + if (yych == '\n') goto yy2033; + goto yy2032; + } else { + if (yych == ' ') goto yy2032; + if (yych <= 0x7F) goto yy2035; + } } else { - if (yych <= '\r') goto yy1656; - if (yych == ' ') goto yy1656; - goto yy1659; + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy2037; + if (yych <= 0xE0) goto yy2039; + if (yych <= 0xEC) goto yy2040; + goto yy2044; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy2040; + goto yy2041; + } else { + if (yych <= 0xF3) goto yy2042; + if (yych <= 0xF4) goto yy2043; + } + } } -yy1655: +yy2031: { return (bufsize_t)(p - start); } -yy1656: +yy2032: yych = *++p; - goto yy1658; -yy1657: + goto yy2034; +yy2033: ++p; yych = *p; -yy1658: +yy2034: if (yybm[0+yych] & 128) { - goto yy1657; + goto yy2033; } - goto yy1655; -yy1659: + goto yy2031; +yy2035: ++p; { return 0; } +yy2037: + yych = *++p; + if (yych <= 0x7F) goto yy2038; + if (yych <= 0xBF) goto yy2035; +yy2038: + p = marker; + goto yy2031; +yy2039: + yych = *++p; + if (yych <= 0x9F) goto yy2038; + if (yych <= 0xBF) goto yy2037; + goto yy2038; +yy2040: + yych = *++p; + if (yych <= 0x7F) goto yy2038; + if (yych <= 0xBF) goto yy2037; + goto yy2038; +yy2041: + yych = *++p; + if (yych <= 0x8F) goto yy2038; + if (yych <= 0xBF) goto yy2040; + goto yy2038; +yy2042: + yych = *++p; + if (yych <= 0x7F) goto yy2038; + if (yych <= 0xBF) goto yy2040; + goto yy2038; +yy2043: + yych = *++p; + if (yych <= 0x7F) goto yy2038; + if (yych <= 0x8F) goto yy2040; + goto yy2038; +yy2044: + ++p; + if ((yych = *p) <= 0x7F) goto yy2038; + if (yych <= 0x9F) goto yy2037; + goto yy2038; } } @@ -14034,94 +18886,144 @@ bufsize_t _scan_atx_header_start(const unsigned char *p) 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - yych = *p; - if (yych == '\n') goto yy1663; - if (yych == '#') goto yy1664; - goto yy1665; -yy1663: + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= '"') { + if (yych != '\n') goto yy2049; + } else { + if (yych <= '#') goto yy2048; + if (yych <= 0x7F) goto yy2049; + if (yych >= 0xC2) goto yy2050; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy2052; + if (yych == 0xED) goto yy2057; + goto yy2053; + } else { + if (yych <= 0xF0) goto yy2054; + if (yych <= 0xF3) goto yy2055; + if (yych <= 0xF4) goto yy2056; + } + } +yy2047: { return 0; } -yy1664: +yy2048: yych = *(marker = ++p); if (yybm[0+yych] & 128) { - goto yy1668; + goto yy2060; } if (yych <= '\f') { - if (yych == '\n') goto yy1666; - goto yy1663; + if (yych == '\n') goto yy2058; + goto yy2047; } else { - if (yych <= '\r') goto yy1666; - if (yych == '#') goto yy1670; - goto yy1663; + if (yych <= '\r') goto yy2058; + if (yych == '#') goto yy2062; + goto yy2047; } -yy1665: +yy2049: yych = *++p; - goto yy1663; -yy1666: + goto yy2047; +yy2050: + yych = *++p; + if (yych <= 0x7F) goto yy2051; + if (yych <= 0xBF) goto yy2049; +yy2051: + p = marker; + goto yy2047; +yy2052: + yych = *++p; + if (yych <= 0x9F) goto yy2051; + if (yych <= 0xBF) goto yy2050; + goto yy2051; +yy2053: + yych = *++p; + if (yych <= 0x7F) goto yy2051; + if (yych <= 0xBF) goto yy2050; + goto yy2051; +yy2054: + yych = *++p; + if (yych <= 0x8F) goto yy2051; + if (yych <= 0xBF) goto yy2053; + goto yy2051; +yy2055: + yych = *++p; + if (yych <= 0x7F) goto yy2051; + if (yych <= 0xBF) goto yy2053; + goto yy2051; +yy2056: + yych = *++p; + if (yych <= 0x7F) goto yy2051; + if (yych <= 0x8F) goto yy2053; + goto yy2051; +yy2057: + yych = *++p; + if (yych <= 0x7F) goto yy2051; + if (yych <= 0x9F) goto yy2050; + goto yy2051; +yy2058: ++p; -yy1667: +yy2059: { return (bufsize_t)(p - start); } -yy1668: +yy2060: ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1668; + goto yy2060; } - goto yy1667; -yy1670: + goto yy2059; +yy2062: yych = *++p; if (yybm[0+yych] & 128) { - goto yy1668; + goto yy2060; } if (yych <= '\f') { - if (yych == '\n') goto yy1666; + if (yych == '\n') goto yy2058; + goto yy2051; } else { - if (yych <= '\r') goto yy1666; - if (yych == '#') goto yy1672; + if (yych <= '\r') goto yy2058; + if (yych != '#') goto yy2051; } -yy1671: - p = marker; - goto yy1663; -yy1672: yych = *++p; if (yybm[0+yych] & 128) { - goto yy1668; + goto yy2060; } if (yych <= '\f') { - if (yych == '\n') goto yy1666; - goto yy1671; + if (yych == '\n') goto yy2058; + goto yy2051; } else { - if (yych <= '\r') goto yy1666; - if (yych != '#') goto yy1671; + if (yych <= '\r') goto yy2058; + if (yych != '#') goto yy2051; } yych = *++p; if (yybm[0+yych] & 128) { - goto yy1668; + goto yy2060; } if (yych <= '\f') { - if (yych == '\n') goto yy1666; - goto yy1671; + if (yych == '\n') goto yy2058; + goto yy2051; } else { - if (yych <= '\r') goto yy1666; - if (yych != '#') goto yy1671; + if (yych <= '\r') goto yy2058; + if (yych != '#') goto yy2051; } yych = *++p; if (yybm[0+yych] & 128) { - goto yy1668; + goto yy2060; } if (yych <= '\f') { - if (yych == '\n') goto yy1666; - goto yy1671; + if (yych == '\n') goto yy2058; + goto yy2051; } else { - if (yych <= '\r') goto yy1666; - if (yych != '#') goto yy1671; + if (yych <= '\r') goto yy2058; + if (yych != '#') goto yy2051; } ++p; if (yybm[0+(yych = *p)] & 128) { - goto yy1668; + goto yy2060; } - if (yych == '\n') goto yy1666; - if (yych == '\r') goto yy1666; - goto yy1671; + if (yych == '\n') goto yy2058; + if (yych == '\r') goto yy2058; + goto yy2051; } } @@ -14168,99 +19070,151 @@ bufsize_t _scan_setext_header_line(const unsigned char *p) 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - yych = *p; - if (yych <= ',') { - if (yych != '\n') goto yy1681; + yych = *(marker = p); + if (yych <= 0xC1) { + if (yych <= '-') { + if (yych == '\n') goto yy2069; + if (yych <= ',') goto yy2072; + goto yy2071; + } else { + if (yych == '=') goto yy2070; + if (yych <= 0x7F) goto yy2072; + } } else { - if (yych <= '-') goto yy1680; - if (yych == '=') goto yy1679; - goto yy1681; + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy2073; + if (yych <= 0xE0) goto yy2075; + if (yych <= 0xEC) goto yy2076; + goto yy2080; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy2076; + goto yy2077; + } else { + if (yych <= 0xF3) goto yy2078; + if (yych <= 0xF4) goto yy2079; + } + } } -yy1678: +yy2069: { return 0; } -yy1679: +yy2070: yych = *(marker = ++p); if (yybm[0+yych] & 128) { - goto yy1693; + goto yy2091; } if (yych <= '\f') { - if (yych == '\n') goto yy1691; - goto yy1678; + if (yych == '\n') goto yy2089; + goto yy2069; } else { - if (yych <= '\r') goto yy1691; - if (yych == ' ') goto yy1689; - goto yy1678; + if (yych <= '\r') goto yy2089; + if (yych == ' ') goto yy2087; + goto yy2069; } -yy1680: +yy2071: yych = *(marker = ++p); if (yybm[0+yych] & 32) { - goto yy1682; + goto yy2081; } if (yych <= '\f') { - if (yych == '\n') goto yy1685; - goto yy1678; + if (yych == '\n') goto yy2083; + goto yy2069; } else { - if (yych <= '\r') goto yy1685; - if (yych == '-') goto yy1687; - goto yy1678; + if (yych <= '\r') goto yy2083; + if (yych == '-') goto yy2085; + goto yy2069; } -yy1681: +yy2072: yych = *++p; - goto yy1678; -yy1682: + goto yy2069; +yy2073: + yych = *++p; + if (yych <= 0x7F) goto yy2074; + if (yych <= 0xBF) goto yy2072; +yy2074: + p = marker; + goto yy2069; +yy2075: + yych = *++p; + if (yych <= 0x9F) goto yy2074; + if (yych <= 0xBF) goto yy2073; + goto yy2074; +yy2076: + yych = *++p; + if (yych <= 0x7F) goto yy2074; + if (yych <= 0xBF) goto yy2073; + goto yy2074; +yy2077: + yych = *++p; + if (yych <= 0x8F) goto yy2074; + if (yych <= 0xBF) goto yy2076; + goto yy2074; +yy2078: + yych = *++p; + if (yych <= 0x7F) goto yy2074; + if (yych <= 0xBF) goto yy2076; + goto yy2074; +yy2079: + yych = *++p; + if (yych <= 0x7F) goto yy2074; + if (yych <= 0x8F) goto yy2076; + goto yy2074; +yy2080: + yych = *++p; + if (yych <= 0x7F) goto yy2074; + if (yych <= 0x9F) goto yy2073; + goto yy2074; +yy2081: ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1682; + goto yy2081; } - if (yych == '\n') goto yy1685; - if (yych == '\r') goto yy1685; -yy1684: - p = marker; - goto yy1678; -yy1685: + if (yych == '\n') goto yy2083; + if (yych != '\r') goto yy2074; +yy2083: ++p; { return 2; } -yy1687: +yy2085: ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1682; + goto yy2081; } if (yych <= '\f') { - if (yych == '\n') goto yy1685; - goto yy1684; + if (yych == '\n') goto yy2083; + goto yy2074; } else { - if (yych <= '\r') goto yy1685; - if (yych == '-') goto yy1687; - goto yy1684; + if (yych <= '\r') goto yy2083; + if (yych == '-') goto yy2085; + goto yy2074; } -yy1689: +yy2087: ++p; yych = *p; if (yych <= '\f') { - if (yych != '\n') goto yy1684; + if (yych != '\n') goto yy2074; } else { - if (yych <= '\r') goto yy1691; - if (yych == ' ') goto yy1689; - goto yy1684; + if (yych <= '\r') goto yy2089; + if (yych == ' ') goto yy2087; + goto yy2074; } -yy1691: +yy2089: ++p; { return 1; } -yy1693: +yy2091: ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1693; + goto yy2091; } if (yych <= '\f') { - if (yych == '\n') goto yy1691; - goto yy1684; + if (yych == '\n') goto yy2089; + goto yy2074; } else { - if (yych <= '\r') goto yy1691; - if (yych == ' ') goto yy1689; - goto yy1684; + if (yych <= '\r') goto yy2089; + if (yych == ' ') goto yy2087; + goto yy2074; } } @@ -14310,155 +19264,210 @@ bufsize_t _scan_hrule(const unsigned char *p) 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - yych = *p; - if (yych <= '*') { - if (yych == '\n') goto yy1697; - if (yych <= ')') goto yy1701; - goto yy1698; + yych = *(marker = p); + if (yych <= 0x7F) { + if (yych <= '*') { + if (yych == '\n') goto yy2095; + if (yych <= ')') goto yy2099; + goto yy2096; + } else { + if (yych <= '-') { + if (yych <= ',') goto yy2099; + goto yy2098; + } else { + if (yych == '_') goto yy2097; + goto yy2099; + } + } } else { - if (yych <= '-') { - if (yych <= ',') goto yy1701; - goto yy1700; + if (yych <= 0xED) { + if (yych <= 0xDF) { + if (yych >= 0xC2) goto yy2100; + } else { + if (yych <= 0xE0) goto yy2102; + if (yych <= 0xEC) goto yy2103; + goto yy2107; + } } else { - if (yych == '_') goto yy1699; - goto yy1701; + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy2103; + goto yy2104; + } else { + if (yych <= 0xF3) goto yy2105; + if (yych <= 0xF4) goto yy2106; + } } } -yy1697: +yy2095: { return 0; } -yy1698: +yy2096: yych = *(marker = ++p); - if (yych == ' ') goto yy1723; - if (yych == '*') goto yy1725; - goto yy1697; -yy1699: + if (yych == ' ') goto yy2128; + if (yych == '*') goto yy2130; + goto yy2095; +yy2097: yych = *(marker = ++p); - if (yych == ' ') goto yy1713; - if (yych == '_') goto yy1715; - goto yy1697; -yy1700: + if (yych == ' ') goto yy2118; + if (yych == '_') goto yy2120; + goto yy2095; +yy2098: yych = *(marker = ++p); if (yybm[0+yych] & 8) { - goto yy1702; + goto yy2108; } - if (yych == '-') goto yy1705; - goto yy1697; -yy1701: + if (yych == '-') goto yy2110; + goto yy2095; +yy2099: yych = *++p; - goto yy1697; -yy1702: + goto yy2095; +yy2100: + yych = *++p; + if (yych <= 0x7F) goto yy2101; + if (yych <= 0xBF) goto yy2099; +yy2101: + p = marker; + goto yy2095; +yy2102: + yych = *++p; + if (yych <= 0x9F) goto yy2101; + if (yych <= 0xBF) goto yy2100; + goto yy2101; +yy2103: + yych = *++p; + if (yych <= 0x7F) goto yy2101; + if (yych <= 0xBF) goto yy2100; + goto yy2101; +yy2104: + yych = *++p; + if (yych <= 0x8F) goto yy2101; + if (yych <= 0xBF) goto yy2103; + goto yy2101; +yy2105: + yych = *++p; + if (yych <= 0x7F) goto yy2101; + if (yych <= 0xBF) goto yy2103; + goto yy2101; +yy2106: + yych = *++p; + if (yych <= 0x7F) goto yy2101; + if (yych <= 0x8F) goto yy2103; + goto yy2101; +yy2107: + yych = *++p; + if (yych <= 0x7F) goto yy2101; + if (yych <= 0x9F) goto yy2100; + goto yy2101; +yy2108: ++p; yych = *p; if (yybm[0+yych] & 8) { - goto yy1702; + goto yy2108; } - if (yych == '-') goto yy1705; -yy1704: - p = marker; - goto yy1697; -yy1705: + if (yych != '-') goto yy2101; +yy2110: ++p; yych = *p; - if (yych == ' ') goto yy1705; - if (yych != '-') goto yy1704; -yy1707: + if (yych == ' ') goto yy2110; + if (yych != '-') goto yy2101; +yy2112: ++p; yych = *p; if (yybm[0+yych] & 16) { - goto yy1707; + goto yy2112; } if (yych <= '\n') { - if (yych <= 0x08) goto yy1704; - if (yych >= '\n') goto yy1711; + if (yych <= 0x08) goto yy2101; + if (yych >= '\n') goto yy2116; } else { - if (yych == '\r') goto yy1711; - goto yy1704; + if (yych == '\r') goto yy2116; + goto yy2101; } -yy1709: +yy2114: ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1709; + goto yy2114; } - if (yych == '\n') goto yy1711; - if (yych != '\r') goto yy1704; -yy1711: + if (yych <= 0x08) goto yy2101; + if (yych <= '\n') goto yy2116; + if (yych != '\r') goto yy2101; +yy2116: ++p; { return (bufsize_t)(p - start); } -yy1713: +yy2118: ++p; yych = *p; - if (yych == ' ') goto yy1713; - if (yych != '_') goto yy1704; -yy1715: + if (yych == ' ') goto yy2118; + if (yych != '_') goto yy2101; +yy2120: ++p; yych = *p; - if (yych == ' ') goto yy1715; - if (yych != '_') goto yy1704; -yy1717: + if (yych == ' ') goto yy2120; + if (yych != '_') goto yy2101; +yy2122: ++p; yych = *p; if (yybm[0+yych] & 64) { - goto yy1717; + goto yy2122; } if (yych <= '\n') { - if (yych <= 0x08) goto yy1704; - if (yych >= '\n') goto yy1721; + if (yych <= 0x08) goto yy2101; + if (yych >= '\n') goto yy2126; } else { - if (yych == '\r') goto yy1721; - goto yy1704; + if (yych == '\r') goto yy2126; + goto yy2101; } -yy1719: +yy2124: ++p; yych = *p; if (yych <= '\f') { - if (yych <= 0x08) goto yy1704; - if (yych <= '\t') goto yy1719; - if (yych >= '\v') goto yy1704; + if (yych <= 0x08) goto yy2101; + if (yych <= '\t') goto yy2124; + if (yych >= '\v') goto yy2101; } else { - if (yych <= '\r') goto yy1721; - if (yych == ' ') goto yy1719; - goto yy1704; + if (yych <= '\r') goto yy2126; + if (yych == ' ') goto yy2124; + goto yy2101; } -yy1721: +yy2126: ++p; { return (bufsize_t)(p - start); } -yy1723: +yy2128: ++p; yych = *p; - if (yych == ' ') goto yy1723; - if (yych != '*') goto yy1704; -yy1725: + if (yych == ' ') goto yy2128; + if (yych != '*') goto yy2101; +yy2130: ++p; yych = *p; - if (yych == ' ') goto yy1725; - if (yych != '*') goto yy1704; -yy1727: + if (yych == ' ') goto yy2130; + if (yych != '*') goto yy2101; +yy2132: ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1727; + goto yy2132; } if (yych <= '\n') { - if (yych <= 0x08) goto yy1704; - if (yych >= '\n') goto yy1731; + if (yych <= 0x08) goto yy2101; + if (yych >= '\n') goto yy2136; } else { - if (yych == '\r') goto yy1731; - goto yy1704; + if (yych == '\r') goto yy2136; + goto yy2101; } -yy1729: +yy2134: ++p; yych = *p; if (yych <= '\f') { - if (yych <= 0x08) goto yy1704; - if (yych <= '\t') goto yy1729; - if (yych >= '\v') goto yy1704; + if (yych <= 0x08) goto yy2101; + if (yych <= '\t') goto yy2134; + if (yych >= '\v') goto yy2101; } else { - if (yych <= '\r') goto yy1731; - if (yych == ' ') goto yy1729; - goto yy1704; + if (yych <= '\r') goto yy2136; + if (yych == ' ') goto yy2134; + goto yy2101; } -yy1731: +yy2136: ++p; { return (bufsize_t)(p - start); } } @@ -14490,99 +19499,310 @@ bufsize_t _scan_open_code_fence(const unsigned char *p) 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, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 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 yy1738; + yych = *(marker = p); + if (yych <= 0xC1) { + if (yych <= '`') { + if (yych == '\n') goto yy2140; + if (yych <= '_') goto yy2143; + goto yy2141; + } else { + if (yych == '~') goto yy2142; + if (yych <= 0x7F) goto yy2143; + } } else { - if (yych <= '`') goto yy1736; - if (yych == '~') goto yy1737; - goto yy1738; + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy2144; + if (yych <= 0xE0) goto yy2146; + if (yych <= 0xEC) goto yy2147; + goto yy2151; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy2147; + goto yy2148; + } else { + if (yych <= 0xF3) goto yy2149; + if (yych <= 0xF4) goto yy2150; + } + } } -yy1735: +yy2140: { return 0; } -yy1736: +yy2141: yych = *(marker = ++p); - if (yych == '`') goto yy1747; - goto yy1735; -yy1737: + if (yych == '`') goto yy2166; + goto yy2140; +yy2142: yych = *(marker = ++p); - if (yych == '~') goto yy1739; - goto yy1735; -yy1738: + if (yych == '~') goto yy2152; + goto yy2140; +yy2143: yych = *++p; - goto yy1735; -yy1739: + goto yy2140; +yy2144: + yych = *++p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0xBF) goto yy2143; +yy2145: + p = marker; + goto yy2140; +yy2146: + yych = *++p; + if (yych <= 0x9F) goto yy2145; + if (yych <= 0xBF) goto yy2144; + goto yy2145; +yy2147: + yych = *++p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0xBF) goto yy2144; + goto yy2145; +yy2148: + yych = *++p; + if (yych <= 0x8F) goto yy2145; + if (yych <= 0xBF) goto yy2147; + goto yy2145; +yy2149: + yych = *++p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0xBF) goto yy2147; + goto yy2145; +yy2150: + yych = *++p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0x8F) goto yy2147; + goto yy2145; +yy2151: + yych = *++p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0x9F) goto yy2144; + goto yy2145; +yy2152: yych = *++p; if (yybm[0+yych] & 16) { - goto yy1741; + goto yy2153; } -yy1740: - p = marker; - goto yy1735; -yy1741: + goto yy2145; +yy2153: marker = p + 1; ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1743; + goto yy2155; } - if (yych <= 0x00) goto yy1740; - if (yych <= '}') goto yy1745; - goto yy1741; -yy1743: + if (yych <= 0xE0) { + if (yych <= '~') { + if (yych <= 0x00) goto yy2145; + if (yych <= '\r') goto yy2164; + goto yy2153; + } else { + if (yych <= 0xC1) goto yy2145; + if (yych <= 0xDF) goto yy2157; + goto yy2158; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy2163; + goto yy2159; + } else { + if (yych <= 0xF0) goto yy2160; + if (yych <= 0xF3) goto yy2161; + if (yych <= 0xF4) goto yy2162; + goto yy2145; + } + } +yy2155: ++p; yych = *p; if (yybm[0+yych] & 32) { - goto yy1743; + goto yy2155; } - if (yych <= 0x00) goto yy1740; - if (yych >= '~') goto yy1740; -yy1745: + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy2145; + if (yych <= '\r') goto yy2164; + goto yy2145; + } else { + if (yych <= 0xDF) goto yy2157; + if (yych <= 0xE0) goto yy2158; + goto yy2159; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy2163; + if (yych <= 0xEF) goto yy2159; + goto yy2160; + } else { + if (yych <= 0xF3) goto yy2161; + if (yych <= 0xF4) goto yy2162; + goto yy2145; + } + } +yy2157: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0xBF) goto yy2155; + goto yy2145; +yy2158: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy2145; + if (yych <= 0xBF) goto yy2157; + goto yy2145; +yy2159: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0xBF) goto yy2157; + goto yy2145; +yy2160: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy2145; + if (yych <= 0xBF) goto yy2159; + goto yy2145; +yy2161: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0xBF) goto yy2159; + goto yy2145; +yy2162: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0x8F) goto yy2159; + goto yy2145; +yy2163: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0x9F) goto yy2157; + goto yy2145; +yy2164: ++p; p = marker; { return (bufsize_t)(p - start); } -yy1747: +yy2166: yych = *++p; if (yybm[0+yych] & 64) { - goto yy1748; + goto yy2167; } - goto yy1740; -yy1748: + goto yy2145; +yy2167: marker = p + 1; ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1750; + goto yy2169; } - if (yych <= 0x00) goto yy1740; - if (yych <= '_') goto yy1752; - goto yy1748; -yy1750: + if (yych <= 0xE0) { + if (yych <= '`') { + if (yych <= 0x00) goto yy2145; + if (yych <= '\r') goto yy2178; + goto yy2167; + } else { + if (yych <= 0xC1) goto yy2145; + if (yych <= 0xDF) goto yy2171; + goto yy2172; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) goto yy2177; + goto yy2173; + } else { + if (yych <= 0xF0) goto yy2174; + if (yych <= 0xF3) goto yy2175; + if (yych <= 0xF4) goto yy2176; + goto yy2145; + } + } +yy2169: ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1750; + goto yy2169; } - if (yych <= 0x00) goto yy1740; - if (yych >= '`') goto yy1740; -yy1752: + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) goto yy2145; + if (yych <= '\r') goto yy2178; + goto yy2145; + } else { + if (yych <= 0xDF) goto yy2171; + if (yych <= 0xE0) goto yy2172; + goto yy2173; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) goto yy2177; + if (yych <= 0xEF) goto yy2173; + goto yy2174; + } else { + if (yych <= 0xF3) goto yy2175; + if (yych <= 0xF4) goto yy2176; + goto yy2145; + } + } +yy2171: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0xBF) goto yy2169; + goto yy2145; +yy2172: + ++p; + yych = *p; + if (yych <= 0x9F) goto yy2145; + if (yych <= 0xBF) goto yy2171; + goto yy2145; +yy2173: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0xBF) goto yy2171; + goto yy2145; +yy2174: + ++p; + yych = *p; + if (yych <= 0x8F) goto yy2145; + if (yych <= 0xBF) goto yy2173; + goto yy2145; +yy2175: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0xBF) goto yy2173; + goto yy2145; +yy2176: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0x8F) goto yy2173; + goto yy2145; +yy2177: + ++p; + yych = *p; + if (yych <= 0x7F) goto yy2145; + if (yych <= 0x9F) goto yy2171; + goto yy2145; +yy2178: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -14632,97 +19852,152 @@ bufsize_t _scan_close_code_fence(const unsigned char *p) 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - yych = *p; - if (yych <= '_') { - if (yych != '\n') goto yy1759; + yych = *(marker = p); + if (yych <= 0xC1) { + if (yych <= '`') { + if (yych == '\n') goto yy2182; + if (yych <= '_') goto yy2185; + goto yy2183; + } else { + if (yych == '~') goto yy2184; + if (yych <= 0x7F) goto yy2185; + } } else { - if (yych <= '`') goto yy1757; - if (yych == '~') goto yy1758; - goto yy1759; + if (yych <= 0xED) { + if (yych <= 0xDF) goto yy2186; + if (yych <= 0xE0) goto yy2188; + if (yych <= 0xEC) goto yy2189; + goto yy2193; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) goto yy2189; + goto yy2190; + } else { + if (yych <= 0xF3) goto yy2191; + if (yych <= 0xF4) goto yy2192; + } + } } -yy1756: +yy2182: { return 0; } -yy1757: +yy2183: yych = *(marker = ++p); - if (yych == '`') goto yy1768; - goto yy1756; -yy1758: + if (yych == '`') goto yy2201; + goto yy2182; +yy2184: yych = *(marker = ++p); - if (yych == '~') goto yy1760; - goto yy1756; -yy1759: + if (yych == '~') goto yy2194; + goto yy2182; +yy2185: yych = *++p; - goto yy1756; -yy1760: + goto yy2182; +yy2186: + yych = *++p; + if (yych <= 0x7F) goto yy2187; + if (yych <= 0xBF) goto yy2185; +yy2187: + p = marker; + goto yy2182; +yy2188: + yych = *++p; + if (yych <= 0x9F) goto yy2187; + if (yych <= 0xBF) goto yy2186; + goto yy2187; +yy2189: + yych = *++p; + if (yych <= 0x7F) goto yy2187; + if (yych <= 0xBF) goto yy2186; + goto yy2187; +yy2190: + yych = *++p; + if (yych <= 0x8F) goto yy2187; + if (yych <= 0xBF) goto yy2189; + goto yy2187; +yy2191: + yych = *++p; + if (yych <= 0x7F) goto yy2187; + if (yych <= 0xBF) goto yy2189; + goto yy2187; +yy2192: + yych = *++p; + if (yych <= 0x7F) goto yy2187; + if (yych <= 0x8F) goto yy2189; + goto yy2187; +yy2193: + yych = *++p; + if (yych <= 0x7F) goto yy2187; + if (yych <= 0x9F) goto yy2186; + goto yy2187; +yy2194: yych = *++p; if (yybm[0+yych] & 32) { - goto yy1762; + goto yy2195; } -yy1761: - p = marker; - goto yy1756; -yy1762: + goto yy2187; +yy2195: marker = p + 1; ++p; yych = *p; if (yybm[0+yych] & 64) { - goto yy1764; + goto yy2197; } if (yych <= '\f') { - if (yych == '\n') goto yy1766; - goto yy1761; + if (yych <= 0x08) goto yy2187; + if (yych <= '\n') goto yy2199; + goto yy2187; } else { - if (yych <= '\r') goto yy1766; - if (yych == '~') goto yy1762; - goto yy1761; + if (yych <= '\r') goto yy2199; + if (yych == '~') goto yy2195; + goto yy2187; } -yy1764: +yy2197: ++p; yych = *p; if (yybm[0+yych] & 64) { - goto yy1764; + goto yy2197; } - if (yych == '\n') goto yy1766; - if (yych != '\r') goto yy1761; -yy1766: + if (yych <= 0x08) goto yy2187; + if (yych <= '\n') goto yy2199; + if (yych != '\r') goto yy2187; +yy2199: ++p; p = marker; { return (bufsize_t)(p - start); } -yy1768: +yy2201: yych = *++p; if (yybm[0+yych] & 128) { - goto yy1769; + goto yy2202; } - goto yy1761; -yy1769: + goto yy2187; +yy2202: marker = p + 1; ++p; yych = *p; if (yybm[0+yych] & 128) { - goto yy1769; + goto yy2202; } if (yych <= '\f') { - if (yych <= 0x08) goto yy1761; - if (yych <= '\t') goto yy1771; - if (yych <= '\n') goto yy1773; - goto yy1761; + if (yych <= 0x08) goto yy2187; + if (yych <= '\t') goto yy2204; + if (yych <= '\n') goto yy2206; + goto yy2187; } else { - if (yych <= '\r') goto yy1773; - if (yych != ' ') goto yy1761; + if (yych <= '\r') goto yy2206; + if (yych != ' ') goto yy2187; } -yy1771: +yy2204: ++p; yych = *p; if (yych <= '\f') { - if (yych <= 0x08) goto yy1761; - if (yych <= '\t') goto yy1771; - if (yych >= '\v') goto yy1761; + if (yych <= 0x08) goto yy2187; + if (yych <= '\t') goto yy2204; + if (yych >= '\v') goto yy2187; } else { - if (yych <= '\r') goto yy1773; - if (yych == ' ') goto yy1771; - goto yy1761; + if (yych <= '\r') goto yy2206; + if (yych == ' ') goto yy2204; + goto yy2187; } -yy1773: +yy2206: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -14739,667 +20014,1034 @@ bufsize_t _scan_entity(const unsigned char *p) { unsigned char yych; - yych = *p; - if (yych == '\n') goto yy1777; - if (yych == '&') goto yy1778; - goto yy1779; -yy1777: + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= '%') { + if (yych != '\n') goto yy2212; + } else { + if (yych <= '&') goto yy2211; + if (yych <= 0x7F) goto yy2212; + if (yych >= 0xC2) goto yy2213; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy2215; + if (yych == 0xED) goto yy2220; + goto yy2216; + } else { + if (yych <= 0xF0) goto yy2217; + if (yych <= 0xF3) goto yy2218; + if (yych <= 0xF4) goto yy2219; + } + } +yy2210: { return 0; } -yy1778: +yy2211: yych = *(marker = ++p); if (yych <= '@') { - if (yych == '#') goto yy1780; - goto yy1777; + if (yych == '#') goto yy2221; + goto yy2210; } else { - if (yych <= 'Z') goto yy1782; - if (yych <= '`') goto yy1777; - if (yych <= 'z') goto yy1782; - goto yy1777; + if (yych <= 'Z') goto yy2222; + if (yych <= '`') goto yy2210; + if (yych <= 'z') goto yy2222; + goto yy2210; } -yy1779: +yy2212: yych = *++p; - goto yy1777; -yy1780: + goto yy2210; +yy2213: + yych = *++p; + if (yych <= 0x7F) goto yy2214; + if (yych <= 0xBF) goto yy2212; +yy2214: + p = marker; + goto yy2210; +yy2215: + yych = *++p; + if (yych <= 0x9F) goto yy2214; + if (yych <= 0xBF) goto yy2213; + goto yy2214; +yy2216: + yych = *++p; + if (yych <= 0x7F) goto yy2214; + if (yych <= 0xBF) goto yy2213; + goto yy2214; +yy2217: + yych = *++p; + if (yych <= 0x8F) goto yy2214; + if (yych <= 0xBF) goto yy2216; + goto yy2214; +yy2218: + yych = *++p; + if (yych <= 0x7F) goto yy2214; + if (yych <= 0xBF) goto yy2216; + goto yy2214; +yy2219: + yych = *++p; + if (yych <= 0x7F) goto yy2214; + if (yych <= 0x8F) goto yy2216; + goto yy2214; +yy2220: + yych = *++p; + if (yych <= 0x7F) goto yy2214; + if (yych <= 0x9F) goto yy2213; + goto yy2214; +yy2221: yych = *++p; if (yych <= 'W') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1817; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2257; + goto yy2214; } else { - if (yych <= 'X') goto yy1816; - if (yych == 'x') goto yy1816; + if (yych <= 'X') goto yy2256; + if (yych == 'x') goto yy2256; + goto yy2214; } -yy1781: - p = marker; - goto yy1777; -yy1782: +yy2222: yych = *++p; if (yych <= '@') { - if (yych <= '/') goto yy1781; - if (yych >= ':') goto yy1781; + if (yych <= '/') goto yy2214; + if (yych >= ':') goto yy2214; } else { - if (yych <= 'Z') goto yy1783; - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= 'Z') goto yy2223; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } -yy1783: +yy2223: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1786; - if (yych <= ':') goto yy1781; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2226; + if (yych <= ':') goto yy2214; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; - goto yy1786; + if (yych <= '@') goto yy2214; + goto yy2226; } else { - if (yych <= '`') goto yy1781; - if (yych <= 'z') goto yy1786; - goto yy1781; + if (yych <= '`') goto yy2214; + if (yych <= 'z') goto yy2226; + goto yy2214; } } -yy1784: +yy2224: ++p; { return (bufsize_t)(p - start); } -yy1786: +yy2226: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1787; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2227; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1787: +yy2227: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1788; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2228; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1788: +yy2228: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1789; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2229; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1789: +yy2229: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1790; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2230; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1790: +yy2230: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1791; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2231; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1791: +yy2231: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1792; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2232; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1792: +yy2232: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1793; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2233; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1793: +yy2233: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1794; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2234; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1794: +yy2234: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1795; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2235; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1795: +yy2235: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1796; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2236; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1796: +yy2236: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1797; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2237; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1797: +yy2237: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1798; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2238; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1798: +yy2238: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1799; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2239; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1799: +yy2239: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1800; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2240; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1800: +yy2240: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1801; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2241; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1801: +yy2241: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1802; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2242; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1802: +yy2242: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1803; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2243; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1803: +yy2243: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1804; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2244; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1804: +yy2244: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1805; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2245; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1805: +yy2245: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1806; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2246; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1806: +yy2246: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1807; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2247; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1807: +yy2247: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1808; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2248; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1808: +yy2248: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1809; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2249; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1809: +yy2249: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1810; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2250; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1810: +yy2250: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1811; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2251; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1811: +yy2251: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1812; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2252; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1812: +yy2252: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1813; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2253; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1813: +yy2253: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1814; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2254; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1814: +yy2254: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1815; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2255; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'Z') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= '{') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= '{') goto yy2214; } } -yy1815: +yy2255: yych = *++p; - if (yych == ';') goto yy1784; - goto yy1781; -yy1816: + if (yych == ';') goto yy2224; + goto yy2214; +yy2256: yych = *++p; if (yych <= '@') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1824; - goto yy1781; - } else { - if (yych <= 'F') goto yy1824; - if (yych <= '`') goto yy1781; - if (yych <= 'f') goto yy1824; - goto yy1781; - } -yy1817: - yych = *++p; - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1818; - if (yych == ';') goto yy1784; - goto yy1781; -yy1818: - yych = *++p; - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1819; - if (yych == ';') goto yy1784; - goto yy1781; -yy1819: - yych = *++p; - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1820; - if (yych == ';') goto yy1784; - goto yy1781; -yy1820: - yych = *++p; - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1821; - if (yych == ';') goto yy1784; - goto yy1781; -yy1821: - yych = *++p; - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1822; - if (yych == ';') goto yy1784; - goto yy1781; -yy1822: - yych = *++p; - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1823; - if (yych == ';') goto yy1784; - goto yy1781; -yy1823: - yych = *++p; - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1815; - if (yych == ';') goto yy1784; - goto yy1781; -yy1824: + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2264; + goto yy2214; + } else { + if (yych <= 'F') goto yy2264; + if (yych <= '`') goto yy2214; + if (yych <= 'f') goto yy2264; + goto yy2214; + } +yy2257: + yych = *++p; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2258; + if (yych == ';') goto yy2224; + goto yy2214; +yy2258: + yych = *++p; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2259; + if (yych == ';') goto yy2224; + goto yy2214; +yy2259: + yych = *++p; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2260; + if (yych == ';') goto yy2224; + goto yy2214; +yy2260: + yych = *++p; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2261; + if (yych == ';') goto yy2224; + goto yy2214; +yy2261: + yych = *++p; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2262; + if (yych == ';') goto yy2224; + goto yy2214; +yy2262: + yych = *++p; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2263; + if (yych == ';') goto yy2224; + goto yy2214; +yy2263: + yych = *++p; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2255; + if (yych == ';') goto yy2224; + goto yy2214; +yy2264: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1825; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2265; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= 'g') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= 'g') goto yy2214; } } -yy1825: +yy2265: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1826; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2266; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= 'g') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= 'g') goto yy2214; } } -yy1826: +yy2266: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1827; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2267; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= 'g') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= 'g') goto yy2214; } } -yy1827: +yy2267: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1828; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2268; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= 'g') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= 'g') goto yy2214; } } -yy1828: +yy2268: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1829; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2269; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= 'g') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= 'g') goto yy2214; } } -yy1829: +yy2269: yych = *++p; if (yych <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1830; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2270; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1781; + if (yych <= '@') goto yy2214; } else { - if (yych <= '`') goto yy1781; - if (yych >= 'g') goto yy1781; + if (yych <= '`') goto yy2214; + if (yych >= 'g') goto yy2214; } } -yy1830: +yy2270: ++p; if ((yych = *p) <= ';') { - if (yych <= '/') goto yy1781; - if (yych <= '9') goto yy1815; - if (yych <= ':') goto yy1781; - goto yy1784; + if (yych <= '/') goto yy2214; + if (yych <= '9') goto yy2255; + if (yych <= ':') goto yy2214; + goto yy2224; } else { if (yych <= 'F') { - if (yych <= '@') goto yy1781; - goto yy1815; + if (yych <= '@') goto yy2214; + goto yy2255; + } else { + if (yych <= '`') goto yy2214; + if (yych <= 'f') goto yy2255; + goto yy2214; + } + } +} + +} + +// Returns positive value if a URL begins in a way that is potentially +// dangerous, with javascript:, vbscript:, file:, or data:, otherwise 0. +bufsize_t _scan_dangerous_url(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + unsigned int yyaccept = 0; + yych = *(marker = p); + if (yych <= 'f') { + if (yych <= 'I') { + if (yych <= 'C') { + if (yych != '\n') goto yy2278; + } else { + if (yych <= 'D') goto yy2274; + if (yych == 'F') goto yy2277; + goto yy2278; + } + } else { + if (yych <= 'V') { + if (yych <= 'J') goto yy2275; + if (yych <= 'U') goto yy2278; + goto yy2276; + } else { + if (yych == 'd') goto yy2274; + if (yych <= 'e') goto yy2278; + goto yy2277; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= 'u') { + if (yych == 'j') goto yy2275; + goto yy2278; + } else { + if (yych <= 'v') goto yy2276; + if (yych <= 0x7F) goto yy2278; + if (yych >= 0xC2) goto yy2279; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) goto yy2281; + if (yych == 0xED) goto yy2286; + goto yy2282; + } else { + if (yych <= 0xF0) goto yy2283; + if (yych <= 0xF3) goto yy2284; + if (yych <= 0xF4) goto yy2285; + } + } + } +yy2273: + { return 0; } +yy2274: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'A') goto yy2308; + if (yych == 'a') goto yy2308; + goto yy2273; +yy2275: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'A') goto yy2299; + if (yych == 'a') goto yy2299; + goto yy2273; +yy2276: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'B') goto yy2292; + if (yych == 'b') goto yy2292; + goto yy2273; +yy2277: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'I') goto yy2287; + if (yych == 'i') goto yy2287; + goto yy2273; +yy2278: + yych = *++p; + goto yy2273; +yy2279: + yych = *++p; + if (yych <= 0x7F) goto yy2280; + if (yych <= 0xBF) goto yy2278; +yy2280: + p = marker; + if (yyaccept == 0) { + goto yy2273; + } else { + goto yy2291; + } +yy2281: + yych = *++p; + if (yych <= 0x9F) goto yy2280; + if (yych <= 0xBF) goto yy2279; + goto yy2280; +yy2282: + yych = *++p; + if (yych <= 0x7F) goto yy2280; + if (yych <= 0xBF) goto yy2279; + goto yy2280; +yy2283: + yych = *++p; + if (yych <= 0x8F) goto yy2280; + if (yych <= 0xBF) goto yy2282; + goto yy2280; +yy2284: + yych = *++p; + if (yych <= 0x7F) goto yy2280; + if (yych <= 0xBF) goto yy2282; + goto yy2280; +yy2285: + yych = *++p; + if (yych <= 0x7F) goto yy2280; + if (yych <= 0x8F) goto yy2282; + goto yy2280; +yy2286: + yych = *++p; + if (yych <= 0x7F) goto yy2280; + if (yych <= 0x9F) goto yy2279; + goto yy2280; +yy2287: + yych = *++p; + if (yych == 'L') goto yy2288; + if (yych != 'l') goto yy2280; +yy2288: + yych = *++p; + if (yych == 'E') goto yy2289; + if (yych != 'e') goto yy2280; +yy2289: + yych = *++p; + if (yych != ':') goto yy2280; +yy2290: + ++p; +yy2291: + { return (bufsize_t)(p - start); } +yy2292: + yych = *++p; + if (yych == 'S') goto yy2293; + if (yych != 's') goto yy2280; +yy2293: + yych = *++p; + if (yych == 'C') goto yy2294; + if (yych != 'c') goto yy2280; +yy2294: + yych = *++p; + if (yych == 'R') goto yy2295; + if (yych != 'r') goto yy2280; +yy2295: + yych = *++p; + if (yych == 'I') goto yy2296; + if (yych != 'i') goto yy2280; +yy2296: + yych = *++p; + if (yych == 'P') goto yy2297; + if (yych != 'p') goto yy2280; +yy2297: + yych = *++p; + if (yych == 'T') goto yy2298; + if (yych != 't') goto yy2280; +yy2298: + yych = *++p; + if (yych == ':') goto yy2290; + goto yy2280; +yy2299: + yych = *++p; + if (yych == 'V') goto yy2300; + if (yych != 'v') goto yy2280; +yy2300: + yych = *++p; + if (yych == 'A') goto yy2301; + if (yych != 'a') goto yy2280; +yy2301: + yych = *++p; + if (yych == 'S') goto yy2302; + if (yych != 's') goto yy2280; +yy2302: + yych = *++p; + if (yych == 'C') goto yy2303; + if (yych != 'c') goto yy2280; +yy2303: + yych = *++p; + if (yych == 'R') goto yy2304; + if (yych != 'r') goto yy2280; +yy2304: + yych = *++p; + if (yych == 'I') goto yy2305; + if (yych != 'i') goto yy2280; +yy2305: + yych = *++p; + if (yych == 'P') goto yy2306; + if (yych != 'p') goto yy2280; +yy2306: + yych = *++p; + if (yych == 'T') goto yy2307; + if (yych != 't') goto yy2280; +yy2307: + yych = *++p; + if (yych == ':') goto yy2290; + goto yy2280; +yy2308: + yych = *++p; + if (yych == 'T') goto yy2309; + if (yych != 't') goto yy2280; +yy2309: + yych = *++p; + if (yych == 'A') goto yy2310; + if (yych != 'a') goto yy2280; +yy2310: + yych = *++p; + if (yych != ':') goto yy2280; + yyaccept = 1; + yych = *(marker = ++p); + if (yych == 'I') goto yy2312; + if (yych != 'i') goto yy2291; +yy2312: + yych = *++p; + if (yych == 'M') goto yy2313; + if (yych != 'm') goto yy2280; +yy2313: + yych = *++p; + if (yych == 'A') goto yy2314; + if (yych != 'a') goto yy2280; +yy2314: + yych = *++p; + if (yych == 'G') goto yy2315; + if (yych != 'g') goto yy2280; +yy2315: + yych = *++p; + if (yych == 'E') goto yy2316; + if (yych != 'e') goto yy2280; +yy2316: + yych = *++p; + if (yych != '/') goto yy2280; + yych = *++p; + if (yych <= 'W') { + if (yych <= 'J') { + if (yych == 'G') goto yy2319; + if (yych <= 'I') goto yy2280; + goto yy2320; + } else { + if (yych == 'P') goto yy2318; + if (yych <= 'V') goto yy2280; + goto yy2321; + } + } else { + if (yych <= 'j') { + if (yych == 'g') goto yy2319; + if (yych <= 'i') goto yy2280; + goto yy2320; } else { - if (yych <= '`') goto yy1781; - if (yych <= 'f') goto yy1815; - goto yy1781; + if (yych <= 'p') { + if (yych <= 'o') goto yy2280; + } else { + if (yych == 'w') goto yy2321; + goto yy2280; + } } } +yy2318: + yych = *++p; + if (yych == 'N') goto yy2329; + if (yych == 'n') goto yy2329; + goto yy2280; +yy2319: + yych = *++p; + if (yych == 'I') goto yy2328; + if (yych == 'i') goto yy2328; + goto yy2280; +yy2320: + yych = *++p; + if (yych == 'P') goto yy2326; + if (yych == 'p') goto yy2326; + goto yy2280; +yy2321: + yych = *++p; + if (yych == 'E') goto yy2322; + if (yych != 'e') goto yy2280; +yy2322: + yych = *++p; + if (yych == 'B') goto yy2323; + if (yych != 'b') goto yy2280; +yy2323: + yych = *++p; + if (yych == 'P') goto yy2324; + if (yych != 'p') goto yy2280; +yy2324: + ++p; + { return 0; } +yy2326: + yych = *++p; + if (yych == 'E') goto yy2327; + if (yych != 'e') goto yy2280; +yy2327: + yych = *++p; + if (yych == 'G') goto yy2324; + if (yych == 'g') goto yy2324; + goto yy2280; +yy2328: + yych = *++p; + if (yych == 'F') goto yy2324; + if (yych == 'f') goto yy2324; + goto yy2280; +yy2329: + ++p; + if ((yych = *p) == 'G') goto yy2324; + if (yych == 'g') goto yy2324; + goto yy2280; } } + diff --git a/scanners.h b/scanners.h index bc5134e..a6a71bf 100644 --- a/scanners.h +++ b/scanners.h @@ -10,7 +10,13 @@ bufsize_t _scan_scheme(const unsigned char *p); bufsize_t _scan_autolink_uri(const unsigned char *p); bufsize_t _scan_autolink_email(const unsigned char *p); bufsize_t _scan_html_tag(const unsigned char *p); -bufsize_t _scan_html_block_tag(const unsigned char *p); +bufsize_t _scan_html_block_start(const unsigned char *p); +bufsize_t _scan_html_block_start_7(const unsigned char *p); +bufsize_t _scan_html_block_end_1(const unsigned char *p); +bufsize_t _scan_html_block_end_2(const unsigned char *p); +bufsize_t _scan_html_block_end_3(const unsigned char *p); +bufsize_t _scan_html_block_end_4(const unsigned char *p); +bufsize_t _scan_html_block_end_5(const unsigned char *p); bufsize_t _scan_link_url(const unsigned char *p); bufsize_t _scan_link_title(const unsigned char *p); bufsize_t _scan_spacechars(const unsigned char *p); @@ -20,12 +26,19 @@ bufsize_t _scan_hrule(const unsigned char *p); bufsize_t _scan_open_code_fence(const unsigned char *p); bufsize_t _scan_close_code_fence(const unsigned char *p); bufsize_t _scan_entity(const unsigned char *p); +bufsize_t _scan_dangerous_url(const unsigned char *p); #define scan_scheme(c, n) _scan_at(&_scan_scheme, c, n) #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_html_block_start(c, n) _scan_at(&_scan_html_block_start, c, n) +#define scan_html_block_start_7(c, n) _scan_at(&_scan_html_block_start_7, c, n) +#define scan_html_block_end_1(c, n) _scan_at(&_scan_html_block_end_1, c, n) +#define scan_html_block_end_2(c, n) _scan_at(&_scan_html_block_end_2, c, n) +#define scan_html_block_end_3(c, n) _scan_at(&_scan_html_block_end_3, c, n) +#define scan_html_block_end_4(c, n) _scan_at(&_scan_html_block_end_4, c, n) +#define scan_html_block_end_5(c, n) _scan_at(&_scan_html_block_end_5, 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) @@ -35,6 +48,7 @@ bufsize_t _scan_entity(const unsigned char *p); #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) +#define scan_dangerous_url(c, n) _scan_at(&_scan_dangerous_url, c, n) #ifdef __cplusplus } diff --git a/scanners.re b/scanners.re index 3722a99..fbe3283 100644 --- a/scanners.re +++ b/scanners.re @@ -30,9 +30,9 @@ bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, escaped_char = [\\][!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~-]; - tagname = [A-Za-z][A-Za-z0-9]*; + tagname = [A-Za-z][A-Za-z0-9-]*; - blocktagname = 'article'|'header'|'aside'|'hgroup'|'iframe'|'blockquote'|'hr'|'body'|'li'|'map'|'button'|'object'|'canvas'|'ol'|'caption'|'output'|'col'|'p'|'colgroup'|'pre'|'dd'|'progress'|'div'|'section'|'dl'|'table'|'td'|'dt'|'tbody'|'embed'|'textarea'|'fieldset'|'tfoot'|'figcaption'|'th'|'figure'|'thead'|'footer'|'footer'|'tr'|'form'|'ul'|'h1'|'h2'|'h3'|'h4'|'h5'|'h6'|'video'|'script'|'style'; + blocktagname = 'address'|'article'|'aside'|'base'|'basefont'|'blockquote'|'body'|'caption'|'center'|'col'|'colgroup'|'dd'|'details'|'dialog'|'dir'|'div'|'dl'|'dt'|'fieldset'|'figcaption'|'figure'|'footer'|'form'|'frame'|'frameset'|'h1'|'head'|'header'|'hr'|'html'|'legend'|'li'|'link'|'main'|'menu'|'menuitem'|'meta'|'nav'|'noframes'|'ol'|'optgroup'|'option'|'p'|'param'|'pre'|'section'|'source'|'title'|'summary'|'table'|'tbody'|'td'|'tfoot'|'th'|'thead'|'title'|'tr'|'track'|'ul'; attributename = [a-zA-Z_:][a-zA-Z0-9:._-]*; @@ -60,7 +60,7 @@ bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, htmltag = opentag | closetag | htmlcomment | processinginstruction | declaration | cdata; - in_parens_nosp = [(] (reg_char|escaped_char)* [)]; + in_parens_nosp = [(] (reg_char|escaped_char|[\\])* [)]; in_double_quotes = ["] (escaped_char|[^"\x00])* ["]; in_single_quotes = ['] (escaped_char|[^'\x00])* [']; @@ -117,16 +117,85 @@ bufsize_t _scan_html_tag(const unsigned char *p) */ } -// Try to match an HTML block tag including first <, -// returning num of chars matched. -bufsize_t _scan_html_block_tag(const unsigned char *p) +// Try to match an HTML block tag start line, returning +// an integer code for the type of block (1-6, matching the spec). +// #7 is handled by a separate function, below. +bufsize_t _scan_html_block_start(const unsigned char *p) +{ + const unsigned char *marker = NULL; +/*!re2c + [<] ('script'|'pre'|'style') (spacechar | [>]) { return 1; } + '' { return (bufsize_t)(p - start); } + .? { return 0; } +*/ +} + +// Try to match an HTML block end line of type 3 +bufsize_t _scan_html_block_end_3(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + .* '?>' { return (bufsize_t)(p - start); } + .? { return 0; } +*/ +} + +// Try to match an HTML block end line of type 4 +bufsize_t _scan_html_block_end_4(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + .* '>' { return (bufsize_t)(p - start); } + .? { return 0; } +*/ +} + +// Try to match an HTML block end line of type 5 +bufsize_t _scan_html_block_end_5(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - [<] [/] blocktagname (spacechar | [>]) { return (bufsize_t)(p - start); } - [<] blocktagname (spacechar | [/>]) { return (bufsize_t)(p - start); } - [<] [!?] { return (bufsize_t)(p - start); } + .* ']]>' { return (bufsize_t)(p - start); } .? { return 0; } */ } @@ -141,7 +210,7 @@ bufsize_t _scan_link_url(const unsigned char *p) const unsigned char *start = p; /*!re2c [ \r\n]* [<] ([^<>\r\n\\\x00] | escaped_char | [\\])* [>] { return (bufsize_t)(p - start); } - [ \r\n]* (reg_char+ | escaped_char | in_parens_nosp)* { return (bufsize_t)(p - start); } + [ \r\n]* (reg_char+ | escaped_char | in_parens_nosp | [\\][^()])* { return (bufsize_t)(p - start); } .? { return 0; } */ } @@ -164,6 +233,7 @@ bufsize_t _scan_link_title(const unsigned char *p) // Match space characters, including newlines. bufsize_t _scan_spacechars(const unsigned char *p) { + const unsigned char *marker = NULL; const unsigned char *start = p; \ /*!re2c [ \t\v\f\r\n]* { return (bufsize_t)(p - start); } @@ -245,3 +315,17 @@ bufsize_t _scan_entity(const unsigned char *p) .? { return 0; } */ } + +// Returns positive value if a URL begins in a way that is potentially +// dangerous, with javascript:, vbscript:, file:, or data:, otherwise 0. +bufsize_t _scan_dangerous_url(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + 'data:image/' ('png'|'gif'|'jpeg'|'webp') { return 0; } + 'javascript:' | 'vbscript:' | 'file:' | 'data:' { return (bufsize_t)(p - start); } + .? { return 0; } +*/ +} + diff --git a/utf8.c b/utf8.c index ba1d873..ffe6652 100644 --- a/utf8.c +++ b/utf8.c @@ -56,21 +56,18 @@ static int utf8proc_charlen(const uint8_t *str, bufsize_t str_len) // Validate a single UTF-8 character according to RFC 3629. static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) { - int length = utf8proc_charlen(str, str_len); + int length = utf8proc_utf8class[str[0]]; - if (length <= 0) - return length; + if (!length) + return -1; - switch (length) { - case 1: - if (str[0] == 0x00) { - // ASCII NUL is technically valid but rejected - // for security reasons. - return -length; - } - break; + if ((bufsize_t)length > str_len) + return -str_len; + switch (length) { case 2: + if ((str[1] & 0xC0) != 0x80) + return -1; if (str[0] < 0xC2) { // Overlong return -length; @@ -78,6 +75,10 @@ static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) break; case 3: + if ((str[1] & 0xC0) != 0x80) + return -1; + if ((str[2] & 0xC0) != 0x80) + return -2; if (str[0] == 0xE0) { if (str[1] < 0xA0) { // Overlong @@ -92,6 +93,12 @@ static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) break; case 4: + if ((str[1] & 0xC0) != 0x80) + return -1; + if ((str[2] & 0xC0) != 0x80) + return -2; + if ((str[3] & 0xC0) != 0x80) + return -3; if (str[0] == 0xF0) { if (str[1] < 0x90) { // Overlong @@ -109,44 +116,42 @@ static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) return length; } -void utf8proc_detab(cmark_strbuf *ob, const uint8_t *line, bufsize_t size) +void utf8proc_check(cmark_strbuf *ob, const uint8_t *line, bufsize_t size) { - static const uint8_t whitespace[] = " "; - - bufsize_t i = 0, tab = 0; + bufsize_t i = 0; while (i < size) { bufsize_t org = i; - - while (i < size && line[i] != '\t' && line[i] != '\0' - && line[i] < 0x80) { - i++; - tab++; + int charlen = 0; + + while (i < size) { + if (line[i] < 0x80 && line[i] != 0) { + i++; + } else if (line[i] >= 0x80) { + charlen = utf8proc_valid(line + i, size - i); + if (charlen < 0) { + charlen = -charlen; + break; + } + i += charlen; + } else if (line[i] == 0) { + // ASCII NUL is technically valid but rejected + // for security reasons. + charlen = 1; + break; + } } - if (i > org) + if (i > org) { cmark_strbuf_put(ob, line + org, i - org); + } - if (i >= size) + 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; - } - + // Invalid UTF-8 + encode_unknown(ob); i += charlen; - tab += 1; } } } diff --git a/utf8.h b/utf8.h index ed1d7ee..9f1a4ec 100644 --- a/utf8.h +++ b/utf8.h @@ -11,7 +11,7 @@ extern "C" { void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, bufsize_t len); void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf); int utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst); -void utf8proc_detab(cmark_strbuf *dest, const uint8_t *line, bufsize_t size); +void utf8proc_check(cmark_strbuf *dest, const uint8_t *line, bufsize_t size); int utf8proc_is_space(int32_t uc); int utf8proc_is_punctuation(int32_t uc); From 1f6aedd87c5c5cfea5ff38cdbb73d42fd3b6458b Mon Sep 17 00:00:00 2001 From: James Adam Date: Tue, 14 Jul 2015 21:42:23 -0400 Subject: [PATCH 14/26] New dependencies added to travis.yml --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index fd5ad9e..c2172cf 100644 --- a/.travis.yml +++ b/.travis.yml @@ -10,6 +10,7 @@ before_install: - sudo apt-get install python3 - sudo apt-get install re2c - sudo apt-get install pandoc + - sudo apt-get install texlive-latex-recommended - cd $HOME/gopath/src/github.com/rhinoman/go-commonmark script: - go test -v ./... From 80bd6c32ee452a3fc309840aa055b911be235ea4 Mon Sep 17 00:00:00 2001 From: James Adam Date: Tue, 14 Jul 2015 21:48:46 -0400 Subject: [PATCH 15/26] minor fix --- cmark.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cmark.h b/cmark.h index 4a85f26..e1bc891 100644 --- a/cmark.h +++ b/cmark.h @@ -2,8 +2,8 @@ #define CMARK_H #include -#include -#include +#include "cmark_export.h" +#include "cmark_version.h" #ifdef __cplusplus extern "C" { From 34af04fcb483f5e18c44c32c52efb59983df6d89 Mon Sep 17 00:00:00 2001 From: jcadam Date: Sun, 23 Aug 2015 16:35:46 -0400 Subject: [PATCH 16/26] added go 1.5 to travis.yml --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index c2172cf..e810723 100644 --- a/.travis.yml +++ b/.travis.yml @@ -2,6 +2,7 @@ language: go go: - 1.4 + - 1.5 before_install: - echo "yes" | sudo add-apt-repository ppa:kalakris/cmake - sudo apt-get update -qq From 205c04e228a7bc0060ef30440ff8980525eb19e8 Mon Sep 17 00:00:00 2001 From: jcadam Date: Tue, 25 Aug 2015 20:12:56 -0400 Subject: [PATCH 17/26] updated to cmark 0.22 --- bench.h | 16 +- blocks.c | 1863 +- buffer.c | 501 +- buffer.h | 40 +- chunk.h | 160 +- cmark.c | 26 +- cmark.h | 270 +- cmark_ctype.c | 59 +- cmark_export.h | 10 +- cmark_version.h | 4 +- commonmark.c | 815 +- config.h | 12 +- config.h.in | 12 +- debug.h | 36 - houdini.h | 36 +- houdini_href_e.c | 107 +- houdini_html_e.c | 87 +- houdini_html_u.c | 243 +- html.c | 596 +- html_unescape.gperf | 2130 -- html_unescape.h | 13375 ------------ inlines.c | 2043 +- inlines.h | 6 +- iterator.c | 222 +- iterator.h | 10 +- latex.c | 780 +- man.c | 438 +- node.c | 1585 +- node.h | 95 +- parser.h | 28 +- references.c | 212 +- references.h | 18 +- render.c | 311 +- render.h | 63 +- scanners.c | 48598 ++++++++++++++++++++++++------------------ scanners.h | 3 +- scanners.re | 2 +- utf8.c | 695 +- utf8.h | 12 +- xml.c | 273 +- 40 files changed, 33176 insertions(+), 42616 deletions(-) delete mode 100644 debug.h delete mode 100644 html_unescape.gperf delete mode 100644 html_unescape.h diff --git a/bench.h b/bench.h index bbea2c6..744dea3 100644 --- a/bench.h +++ b/bench.h @@ -9,15 +9,15 @@ 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 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; +#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() diff --git a/blocks.c b/blocks.c index f8b7495..49ac273 100644 --- a/blocks.c +++ b/blocks.c @@ -19,1035 +19,1006 @@ #define peek_at(i, n) (i)->data[n] -static inline bool -S_is_line_end_char(char c) -{ - return (c == '\n' || c == '\r'); +static inline bool S_is_line_end_char(char c) { + return (c == '\n' || c == '\r'); } -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, - bufsize_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; +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, + bufsize_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; +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->offset = 0; - parser->column = 0; - parser->first_nonspace = 0; - parser->first_nonspace_column = 0; - parser->indent = 0; - parser->blank = false; - parser->curline = line; - parser->last_line_length = 0; - parser->linebuf = buf; - parser->options = options; - - return parser; +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->offset = 0; + parser->column = 0; + parser->first_nonspace = 0; + parser->first_nonspace_column = 0; + parser->indent = 0; + parser->blank = false; + 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); +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); +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, bufsize_t offset) -{ - while (offset < s->size) { - switch (s->ptr[offset]) { - case '\r': - case '\n': - return true; - case ' ': - offset++; - break; - case '\t': - offset++; - break; - default: - return false; - } - } - - return true; +static bool is_blank(cmark_strbuf *s, bufsize_t offset) { + while (offset < s->size) { + switch (s->ptr[offset]) { + case '\r': + case '\n': + return true; + case ' ': + offset++; + break; + case '\t': + 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 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 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, bufsize_t offset) -{ - assert(node->open); - cmark_strbuf_put(&node->string_content, ch->data + offset, ch->len - offset); +static void add_line(cmark_node *node, cmark_chunk *ch, bufsize_t 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) -{ - bufsize_t i; - unsigned char c; - - for (i = ln->size - 1; i >= 0; --i) { - c = ln->ptr[i]; +static void remove_trailing_blank_lines(cmark_strbuf *ln) { + bufsize_t i; + unsigned char c; - if (c != ' ' && c != '\t' && !S_is_line_end_char(c)) - break; - } + for (i = ln->size - 1; i >= 0; --i) { + c = ln->ptr[i]; - if (i < 0) { - cmark_strbuf_clear(ln); - return; - } + if (c != ' ' && c != '\t' && !S_is_line_end_char(c)) + break; + } + if (i < 0) { + cmark_strbuf_clear(ln); + return; + } - for(; i < ln->size; ++i) { - c = ln->ptr[i]; + for (; i < ln->size; ++i) { + c = ln->ptr[i]; - if (!S_is_line_end_char(c)) - continue; + if (!S_is_line_end_char(c)) + continue; - cmark_strbuf_truncate(ln, i); - break; - } + cmark_strbuf_truncate(ln, i); + break; + } } // 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; +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 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) -{ - bufsize_t 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; - if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\n') - b->end_column -= 1; - if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\r') - b->end_column -= 1; - } 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 - for (pos = 0; pos < b->string_content.size; ++pos) { - if (S_is_line_end_char(b->string_content.ptr[pos])) - break; - } - assert(pos < b->string_content.size); - - cmark_strbuf tmp = GH_BUF_INIT; - houdini_unescape_html_f( - &tmp, - b->string_content.ptr, - pos - ); - cmark_strbuf_trim(&tmp); - cmark_strbuf_unescape(&tmp); - b->as.code.info = cmark_chunk_buf_detach(&tmp); - - if (b->string_content.ptr[pos] == '\r') - pos += 1; - if (b->string_content.ptr[pos] == '\n') - pos += 1; - cmark_strbuf_drop(&b->string_content, pos); - } - 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; +static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { + bufsize_t 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; + if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\n') + b->end_column -= 1; + if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\r') + b->end_column -= 1; + } 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 + for (pos = 0; pos < b->string_content.size; ++pos) { + if (S_is_line_end_char(b->string_content.ptr[pos])) + break; + } + assert(pos < b->string_content.size); + + cmark_strbuf tmp = GH_BUF_INIT; + houdini_unescape_html_f(&tmp, b->string_content.ptr, pos); + cmark_strbuf_trim(&tmp); + cmark_strbuf_unescape(&tmp); + b->as.code.info = cmark_chunk_buf_detach(&tmp); + + if (b->string_content.ptr[pos] == '\r') + pos += 1; + if (b->string_content.ptr[pos] == '\n') + pos += 1; + cmark_strbuf_drop(&b->string_content, pos); + } + 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; +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); +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 bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos, cmark_list **dataptr) -{ - unsigned char c; - bufsize_t startpos; - cmark_list *data; - - startpos = pos; - c = peek_at(input, pos); - - if (c == '*' || 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_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; - int digits = 0; - - do { - start = (10 * start) + (peek_at(input, pos) - '0'); - pos++; - digits++; - // We limit to 9 digits to avoid overflow, - // assuming max int is 2^31 - 1 - // This also seems to be the limit for 'start' in some browsers. - } while (digits < 9 && 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); +static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos, + cmark_list **dataptr) { + unsigned char c; + bufsize_t startpos; + cmark_list *data; + + startpos = pos; + c = peek_at(input, pos); + + if (c == '*' || 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_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; + int digits = 0; + + do { + start = (10 * start) + (peek_at(input, pos) - '0'); + pos++; + digits++; + // We limit to 9 digits to avoid overflow, + // assuming max int is 2^31 - 1 + // This also seems to be the limit for 'start' in some browsers. + } while (digits < 9 && 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 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); - } +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); + finalize(parser, parser->root); + process_inlines(parser->root, parser->refmap, parser->options); - return parser->root; + 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_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; +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); + S_parser_feed(parser, (const unsigned char *)buffer, len, true); - document = cmark_parser_finish(parser); - cmark_parser_free(parser); - return document; + 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); +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; - static const uint8_t repl[] = {239, 191, 189}; - - while (buffer < end) { - const unsigned char *eol; - bufsize_t chunk_len; - bool process = false; - for (eol = buffer; eol < end; ++eol) { - if (S_is_line_end_char(*eol)) { - if (eol < end && *eol == '\r') - eol++; - if (eol < end && *eol == '\n') - eol++; - process = true; - break; - } - if (*eol == '\0' && eol < end) { - break; - } - } - if (eol >= end && eof) { - process = true; - } - - chunk_len = cmark_strbuf_check_bufsize(eol - buffer); - if (process) { - if (parser->linebuf->size > 0) { - cmark_strbuf_put(parser->linebuf, buffer, chunk_len); - S_process_line(parser, parser->linebuf->ptr, - parser->linebuf->size); - cmark_strbuf_clear(parser->linebuf); - } else { - S_process_line(parser, buffer, chunk_len); - } - } else { - if (eol < end && *eol == '\0') { - // omit NULL byte - cmark_strbuf_put(parser->linebuf, buffer, chunk_len); - // add replacement character - cmark_strbuf_put(parser->linebuf, repl, 3); - chunk_len += 1; // so we advance the buffer past NULL - } else { - cmark_strbuf_put(parser->linebuf, buffer, chunk_len); - } - } - - buffer += chunk_len; - } +static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, + size_t len, bool eof) { + const unsigned char *end = buffer + len; + static const uint8_t repl[] = {239, 191, 189}; + + while (buffer < end) { + const unsigned char *eol; + bufsize_t chunk_len; + bool process = false; + for (eol = buffer; eol < end; ++eol) { + if (S_is_line_end_char(*eol)) { + process = true; + break; + } + if (*eol == '\0' && eol < end) { + break; + } + } + if (eol >= end && eof) { + process = true; + } + + chunk_len = cmark_strbuf_check_bufsize(eol - buffer); + if (process) { + if (parser->linebuf->size > 0) { + cmark_strbuf_put(parser->linebuf, buffer, chunk_len); + S_process_line(parser, parser->linebuf->ptr, parser->linebuf->size); + cmark_strbuf_clear(parser->linebuf); + } else { + S_process_line(parser, buffer, chunk_len); + } + } else { + if (eol < end && *eol == '\0') { + // omit NULL byte + cmark_strbuf_put(parser->linebuf, buffer, chunk_len); + // add replacement character + cmark_strbuf_put(parser->linebuf, repl, 3); + chunk_len += 1; // so we advance the buffer past NULL + } else { + cmark_strbuf_put(parser->linebuf, buffer, chunk_len); + } + } + + buffer += chunk_len; + // skip over line ending characters: + if (buffer < end && *buffer == '\r') + buffer++; + if (buffer < end && *buffer == '\n') + buffer++; + } } -static void chop_trailing_hashtags(cmark_chunk *ch) -{ - bufsize_t n, orig_n; +static void chop_trailing_hashtags(cmark_chunk *ch) { + bufsize_t n, orig_n; - cmark_chunk_rtrim(ch); - orig_n = n = ch->len - 1; + 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--; + // 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); - } + // Check for a space before the final #s: + if (n != orig_n && n >= 0 && + (peek_at(ch, n) == ' ' || peek_at(ch, n) == '\t')) { + ch->len = n; + cmark_chunk_rtrim(ch); + } } -static void -S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input) -{ - char c; - int chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); - - parser->first_nonspace = parser->offset; - parser->first_nonspace_column = parser->column; - while ((c = peek_at(input, parser->first_nonspace))) { - if (c == ' ') { - parser->first_nonspace += 1; - parser->first_nonspace_column += 1; - chars_to_tab = chars_to_tab - 1; - if (chars_to_tab == 0) { - chars_to_tab = TAB_STOP; - } - } else if (c == '\t') { - parser->first_nonspace += 1; - parser->first_nonspace_column += chars_to_tab; - chars_to_tab = TAB_STOP; - } else { - break; - } - } - - parser->indent = parser->first_nonspace_column - parser->column; - parser->blank = S_is_line_end_char(peek_at(input, parser->first_nonspace)); +static void S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input) { + char c; + int chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); + + parser->first_nonspace = parser->offset; + parser->first_nonspace_column = parser->column; + while ((c = peek_at(input, parser->first_nonspace))) { + if (c == ' ') { + parser->first_nonspace += 1; + parser->first_nonspace_column += 1; + chars_to_tab = chars_to_tab - 1; + if (chars_to_tab == 0) { + chars_to_tab = TAB_STOP; + } + } else if (c == '\t') { + parser->first_nonspace += 1; + parser->first_nonspace_column += chars_to_tab; + chars_to_tab = TAB_STOP; + } else { + break; + } + } + + parser->indent = parser->first_nonspace_column - parser->column; + parser->blank = S_is_line_end_char(peek_at(input, parser->first_nonspace)); } -static void -S_advance_offset(cmark_parser *parser, cmark_chunk *input, bufsize_t count, bool columns) -{ - char c; - int chars_to_tab; - while (count > 0 && (c = peek_at(input, parser->offset))) { - if (c == '\t') { - chars_to_tab = 4 - (parser->column % TAB_STOP); - parser->column += chars_to_tab; - parser->offset += 1; - count -= (columns ? chars_to_tab : 1); - } else { - parser->offset += 1; - parser->column += 1; // assume ascii; block starts are ascii - count -= 1; - } - } +static void S_advance_offset(cmark_parser *parser, cmark_chunk *input, + bufsize_t count, bool columns) { + char c; + int chars_to_tab; + while (count > 0 && (c = peek_at(input, parser->offset))) { + if (c == '\t') { + chars_to_tab = 4 - (parser->column % TAB_STOP); + parser->column += chars_to_tab; + parser->offset += 1; + count -= (columns ? chars_to_tab : 1); + } else { + parser->offset += 1; + parser->column += 1; // assume ascii; block starts are ascii + count -= 1; + } + } } - -static void -S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t bytes) -{ - cmark_node* last_matched_container; - bufsize_t matched = 0; - int lev = 0; - int i; - cmark_list *data = NULL; - bool all_matched = true; - cmark_node* container; - bool indented; - cmark_chunk input; - bool maybe_lazy; - - if (parser->options & CMARK_OPT_VALIDATE_UTF8) { - utf8proc_check(parser->curline, buffer, bytes); - } else { - cmark_strbuf_put(parser->curline, buffer, bytes); - } - parser->offset = 0; - parser->column = 0; - parser->blank = false; - - 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; - - S_find_first_nonspace(parser, &input); - - if (container->type == NODE_BLOCK_QUOTE) { - matched = parser->indent <= 3 && peek_at(&input, parser->first_nonspace) == '>'; - if (matched) { - S_advance_offset(parser, &input, parser->indent + 1, true); - if (peek_at(&input, parser->offset) == ' ') - parser->offset++; - } else { - all_matched = false; - } - - } else if (container->type == NODE_ITEM) { - if (parser->indent >= container->as.list.marker_offset + - container->as.list.padding) { - S_advance_offset(parser, &input, - container->as.list.marker_offset + - container->as.list.padding, true); - } else if (parser->blank) { - S_advance_offset(parser, &input, - parser->first_nonspace - parser->offset, false); - } else { - all_matched = false; - } - - } else if (container->type == NODE_CODE_BLOCK) { - - if (!container->as.code.fenced) { // indented - if (parser->indent >= CODE_INDENT) { - S_advance_offset(parser, &input, CODE_INDENT, true); - } else if (parser->blank) { - S_advance_offset(parser, &input, - parser->first_nonspace - parser->offset, - false); - } else { - all_matched = false; - } - } else { // fenced - matched = 0; - if (parser->indent <= 3 && - (peek_at(&input, parser->first_nonspace) == - container->as.code.fence_char)) { - matched = scan_close_code_fence(&input, - parser->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; - S_advance_offset(parser, &input, matched, false); - parser->current = finalize(parser, container); - goto finished; - } else { - // skip opt. spaces of fence parser->offset - i = container->as.code.fence_offset; - while (i > 0 && - peek_at(&input, parser->offset) == ' ') { - S_advance_offset(parser, &input, 1, false); - 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) { - - switch (container->as.html_block_type) { - case 1: - case 2: - case 3: - case 4: - case 5: - // these types of blocks can accept blanks - break; - case 6: - case 7: - if (parser->blank) { - all_matched = false; - } - break; - default: - fprintf(stderr, - "Error (%s:%d): Unknown HTML block type %d\n", - __FILE__, __LINE__, - container->as.html_block_type); - exit(1); - } - - } else if (container->type == NODE_PARAGRAPH) { - - if (parser->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 (parser->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) { - - S_find_first_nonspace(parser, &input); - indented = parser->indent >= CODE_INDENT; - - if (!indented && peek_at(&input, parser->first_nonspace) == '>') { - - S_advance_offset(parser, &input, parser->first_nonspace + 1 - parser->offset, false); - // optional following character - if (peek_at(&input, parser->offset) == ' ') - S_advance_offset(parser, &input, 1, false); - container = add_child(parser, container, NODE_BLOCK_QUOTE, parser->offset + 1); - - } else if (!indented && (matched = scan_atx_header_start(&input, parser->first_nonspace))) { - - S_advance_offset(parser, &input, - parser->first_nonspace + matched - parser->offset, false); - container = add_child(parser, container, NODE_HEADER, parser->offset + 1); - - bufsize_t hashpos = cmark_chunk_strchr(&input, '#', parser->first_nonspace); - int level = 0; - - while (peek_at(&input, hashpos) == '#') { - level++; - hashpos++; - } - container->as.header.level = level; - container->as.header.setext = false; - - } else if (!indented && (matched = scan_open_code_fence(&input, parser->first_nonspace))) { - - container = add_child(parser, container, NODE_CODE_BLOCK, parser->first_nonspace + 1); - container->as.code.fenced = true; - container->as.code.fence_char = peek_at(&input, parser->first_nonspace); - container->as.code.fence_length = matched; - container->as.code.fence_offset = parser->first_nonspace - parser->offset; - container->as.code.info = cmark_chunk_literal(""); - S_advance_offset(parser, &input, parser->first_nonspace + matched - parser->offset, false); - - } else if (!indented && - ((matched = scan_html_block_start(&input, parser->first_nonspace)) || - (container->type != NODE_PARAGRAPH && - (matched = scan_html_block_start_7(&input, parser->first_nonspace))))) { - - container = add_child(parser, container, NODE_HTML, parser->first_nonspace + 1); - container->as.html_block_type = matched; - // note, we don't adjust parser->offset because the tag is part of the text - - } else if (!indented && - container->type == NODE_PARAGRAPH && - (lev = scan_setext_header_line(&input, parser->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; - S_advance_offset(parser, &input, input.len - 1 - parser->offset, false); - - } else if (!indented && - !(container->type == NODE_PARAGRAPH && - !all_matched) && - (matched = scan_hrule(&input, parser->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, parser->first_nonspace + 1); - container = finalize(parser, container); - S_advance_offset(parser, &input, input.len - 1 - parser->offset, false); - - } else if ((matched = parse_list_marker(&input, parser->first_nonspace, &data)) && - (!indented || container->type == NODE_LIST)) { - // Note that we can have new list items starting with >= 4 - // spaces indent, as long as the list container is still open. - - // compute padding: - S_advance_offset(parser, &input, parser->first_nonspace + matched - parser->offset, false); - i = 0; - while (i <= 5 && peek_at(&input, parser->offset + i) == ' ') { - i++; - } - // i = number of spaces after marker, up to 5 - if (i >= 5 || i < 1 || - S_is_line_end_char(peek_at(&input, parser->offset))) { - data->padding = matched + 1; - if (i > 0) { - S_advance_offset(parser, &input, 1, false); - } - } else { - data->padding = matched + i; - S_advance_offset(parser, &input, i, true); - } - - // check container; if it's a list, see if this list item - // can continue the list; otherwise, create a list container. - - data->marker_offset = parser->indent; - - if (container->type != NODE_LIST || - !lists_match(&container->as.list, data)) { - container = add_child(parser, container, NODE_LIST, - parser->first_nonspace + 1); - - memcpy(&container->as.list, data, sizeof(*data)); - } - - // add the list item - container = add_child(parser, container, NODE_ITEM, - parser->first_nonspace + 1); - /* TODO: static */ - memcpy(&container->as.list, data, sizeof(*data)); - free(data); - - } else if (indented && !maybe_lazy && !parser->blank) { - S_advance_offset(parser, &input, CODE_INDENT, true); - container = add_child(parser, container, NODE_CODE_BLOCK, parser->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 { - 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 parser->offset is a text line. add the text to the - // appropriate container. - - S_find_first_nonspace(parser, &input); - - if (parser->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 = (parser->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 && - !parser->blank && - parser->current->type == NODE_PARAGRAPH && - cmark_strbuf_len(&parser->current->string_content) > 0) { - - add_line(parser->current, &input, parser->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) { - - add_line(container, &input, parser->offset); - - } else if (container->type == NODE_HTML) { - - add_line(container, &input, parser->offset); - - int matches_end_condition; - switch (container->as.html_block_type) { - case 1: - // , , - matches_end_condition = - scan_html_block_end_1(&input, parser->first_nonspace); - break; - case 2: - // --> - matches_end_condition = - scan_html_block_end_2(&input, parser->first_nonspace); - break; - case 3: - // ?> - matches_end_condition = - scan_html_block_end_3(&input, parser->first_nonspace); - break; - case 4: - // > - matches_end_condition = - scan_html_block_end_4(&input, parser->first_nonspace); - break; - case 5: - // ]]> - matches_end_condition = - scan_html_block_end_5(&input, parser->first_nonspace); - break; - default: - matches_end_condition = 0; - break; - } - - if (matches_end_condition) { - container = finalize(parser, container); - assert(parser->current != NULL); - } - - } else if (parser->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, parser->first_nonspace); - - } else { - // create paragraph container for line - container = add_child(parser, container, NODE_PARAGRAPH, parser->first_nonspace + 1); - add_line(container, &input, parser->first_nonspace); - - } - - parser->current = container; - } +static void S_process_line(cmark_parser *parser, const unsigned char *buffer, + bufsize_t bytes) { + cmark_node *last_matched_container; + bufsize_t matched = 0; + int lev = 0; + int i; + cmark_list *data = NULL; + bool all_matched = true; + cmark_node *container; + bool indented; + cmark_chunk input; + bool maybe_lazy; + + if (parser->options & CMARK_OPT_VALIDATE_UTF8) { + cmark_utf8proc_check(parser->curline, buffer, bytes); + } else { + cmark_strbuf_put(parser->curline, buffer, bytes); + } + // ensure line ends with a newline: + if (bytes == 0 || !S_is_line_end_char(parser->curline->ptr[bytes - 1])) { + cmark_strbuf_putc(parser->curline, '\n'); + } + parser->offset = 0; + parser->column = 0; + parser->blank = false; + + 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; + + S_find_first_nonspace(parser, &input); + + if (container->type == NODE_BLOCK_QUOTE) { + matched = + parser->indent <= 3 && peek_at(&input, parser->first_nonspace) == '>'; + if (matched) { + S_advance_offset(parser, &input, parser->indent + 1, true); + if (peek_at(&input, parser->offset) == ' ') + parser->offset++; + } else { + all_matched = false; + } + + } else if (container->type == NODE_ITEM) { + if (parser->indent >= + container->as.list.marker_offset + container->as.list.padding) { + S_advance_offset(parser, &input, container->as.list.marker_offset + + container->as.list.padding, + true); + } else if (parser->blank && container->first_child != NULL) { + // if container->first_child is NULL, then the opening line + // of the list item was blank after the list marker; in this + // case, we are done with the list item. + S_advance_offset(parser, &input, + parser->first_nonspace - parser->offset, false); + } else { + all_matched = false; + } + + } else if (container->type == NODE_CODE_BLOCK) { + + if (!container->as.code.fenced) { // indented + if (parser->indent >= CODE_INDENT) { + S_advance_offset(parser, &input, CODE_INDENT, true); + } else if (parser->blank) { + S_advance_offset(parser, &input, + parser->first_nonspace - parser->offset, false); + } else { + all_matched = false; + } + } else { // fenced + matched = 0; + if (parser->indent <= 3 && (peek_at(&input, parser->first_nonspace) == + container->as.code.fence_char)) { + matched = scan_close_code_fence(&input, parser->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; + S_advance_offset(parser, &input, matched, false); + parser->current = finalize(parser, container); + goto finished; + } else { + // skip opt. spaces of fence parser->offset + i = container->as.code.fence_offset; + while (i > 0 && peek_at(&input, parser->offset) == ' ') { + S_advance_offset(parser, &input, 1, false); + 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) { + + switch (container->as.html_block_type) { + case 1: + case 2: + case 3: + case 4: + case 5: + // these types of blocks can accept blanks + break; + case 6: + case 7: + if (parser->blank) { + all_matched = false; + } + break; + default: + fprintf(stderr, "Error (%s:%d): Unknown HTML block type %d\n", __FILE__, + __LINE__, container->as.html_block_type); + exit(1); + } + + } else if (container->type == NODE_PARAGRAPH) { + + if (parser->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 (parser->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) { + + S_find_first_nonspace(parser, &input); + indented = parser->indent >= CODE_INDENT; + + if (!indented && peek_at(&input, parser->first_nonspace) == '>') { + + S_advance_offset(parser, &input, + parser->first_nonspace + 1 - parser->offset, false); + // optional following character + if (peek_at(&input, parser->offset) == ' ') + S_advance_offset(parser, &input, 1, false); + container = + add_child(parser, container, NODE_BLOCK_QUOTE, parser->offset + 1); + + } else if (!indented && (matched = scan_atx_header_start( + &input, parser->first_nonspace))) { + + S_advance_offset(parser, &input, + parser->first_nonspace + matched - parser->offset, + false); + container = add_child(parser, container, NODE_HEADER, parser->offset + 1); + + bufsize_t hashpos = + cmark_chunk_strchr(&input, '#', parser->first_nonspace); + int level = 0; + + while (peek_at(&input, hashpos) == '#') { + level++; + hashpos++; + } + container->as.header.level = level; + container->as.header.setext = false; + + } else if (!indented && (matched = scan_open_code_fence( + &input, parser->first_nonspace))) { + + container = add_child(parser, container, NODE_CODE_BLOCK, + parser->first_nonspace + 1); + container->as.code.fenced = true; + container->as.code.fence_char = peek_at(&input, parser->first_nonspace); + container->as.code.fence_length = matched; + container->as.code.fence_offset = (int8_t)(parser->first_nonspace - parser->offset); + container->as.code.info = cmark_chunk_literal(""); + S_advance_offset(parser, &input, + parser->first_nonspace + matched - parser->offset, + false); + + } else if (!indented && ((matched = scan_html_block_start( + &input, parser->first_nonspace)) || + (container->type != NODE_PARAGRAPH && + (matched = scan_html_block_start_7( + &input, parser->first_nonspace))))) { + + container = + add_child(parser, container, NODE_HTML, parser->first_nonspace + 1); + container->as.html_block_type = matched; + // note, we don't adjust parser->offset because the tag is part of the + // text + + } else if (!indented && container->type == NODE_PARAGRAPH && + (lev = + scan_setext_header_line(&input, parser->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; + S_advance_offset(parser, &input, input.len - 1 - parser->offset, false); + + } else if (!indented && + !(container->type == NODE_PARAGRAPH && !all_matched) && + (matched = scan_hrule(&input, parser->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, parser->first_nonspace + 1); + S_advance_offset(parser, &input, input.len - 1 - parser->offset, false); + + } else if ((matched = + parse_list_marker(&input, parser->first_nonspace, &data)) && + (!indented || container->type == NODE_LIST)) { + // Note that we can have new list items starting with >= 4 + // spaces indent, as long as the list container is still open. + + // compute padding: + S_advance_offset(parser, &input, + parser->first_nonspace + matched - parser->offset, + false); + i = 0; + while (i <= 5 && peek_at(&input, parser->offset + i) == ' ') { + i++; + } + // i = number of spaces after marker, up to 5 + if (i >= 5 || i < 1 || + S_is_line_end_char(peek_at(&input, parser->offset))) { + data->padding = matched + 1; + if (i > 0) { + S_advance_offset(parser, &input, 1, false); + } + } else { + data->padding = matched + i; + S_advance_offset(parser, &input, i, true); + } + + // check container; if it's a list, see if this list item + // can continue the list; otherwise, create a list container. + + data->marker_offset = parser->indent; + + if (container->type != NODE_LIST || + !lists_match(&container->as.list, data)) { + container = + add_child(parser, container, NODE_LIST, parser->first_nonspace + 1); + + memcpy(&container->as.list, data, sizeof(*data)); + } + + // add the list item + container = + add_child(parser, container, NODE_ITEM, parser->first_nonspace + 1); + /* TODO: static */ + memcpy(&container->as.list, data, sizeof(*data)); + free(data); + + } else if (indented && !maybe_lazy && !parser->blank) { + S_advance_offset(parser, &input, CODE_INDENT, true); + container = + add_child(parser, container, NODE_CODE_BLOCK, parser->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 { + 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 parser->offset is a text line. add the text to the + // appropriate container. + + S_find_first_nonspace(parser, &input); + + if (parser->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 = + (parser->blank && container->type != NODE_BLOCK_QUOTE && + container->type != NODE_HEADER && + container->type != NODE_HRULE && + !(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 && !parser->blank && + parser->current->type == NODE_PARAGRAPH && + cmark_strbuf_len(&parser->current->string_content) > 0) { + + add_line(parser->current, &input, parser->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) { + + add_line(container, &input, parser->offset); + + } else if (container->type == NODE_HTML) { + + add_line(container, &input, parser->offset); + + int matches_end_condition; + switch (container->as.html_block_type) { + case 1: + // , , + matches_end_condition = + scan_html_block_end_1(&input, parser->first_nonspace); + break; + case 2: + // --> + matches_end_condition = + scan_html_block_end_2(&input, parser->first_nonspace); + break; + case 3: + // ?> + matches_end_condition = + scan_html_block_end_3(&input, parser->first_nonspace); + break; + case 4: + // > + matches_end_condition = + scan_html_block_end_4(&input, parser->first_nonspace); + break; + case 5: + // ]]> + matches_end_condition = + scan_html_block_end_5(&input, parser->first_nonspace); + break; + default: + matches_end_condition = 0; + break; + } + + if (matches_end_condition) { + container = finalize(parser, container); + assert(parser->current != NULL); + } + + } else if (parser->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, parser->first_nonspace); + + } else { + // create paragraph container for line + container = add_child(parser, container, NODE_PARAGRAPH, + parser->first_nonspace + 1); + add_line(container, &input, parser->first_nonspace); + } + + parser->current = container; + } finished: - parser->last_line_length = parser->curline->size; - if (parser->last_line_length && - parser->curline->ptr[parser->last_line_length - 1] == '\n') - parser->last_line_length -= 1; - if (parser->last_line_length && - parser->curline->ptr[parser->last_line_length - 1] == '\r') - parser->last_line_length -= 1; - - cmark_strbuf_clear(parser->curline); - + parser->last_line_length = parser->curline->size; + if (parser->last_line_length && + parser->curline->ptr[parser->last_line_length - 1] == '\n') + parser->last_line_length -= 1; + if (parser->last_line_length && + parser->curline->ptr[parser->last_line_length - 1] == '\r') + parser->last_line_length -= 1; + + 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); - } +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); + finalize_document(parser); - if (parser->options & CMARK_OPT_NORMALIZE) { - cmark_consolidate_text_nodes(parser->root); - } + if (parser->options & CMARK_OPT_NORMALIZE) { + cmark_consolidate_text_nodes(parser->root); + } - cmark_strbuf_free(parser->curline); + cmark_strbuf_free(parser->curline); #if CMARK_DEBUG_NODES - if (cmark_node_check(parser->root, stderr)) { - abort(); - } + if (cmark_node_check(parser->root, stderr)) { + abort(); + } #endif - return parser->root; + return parser->root; } diff --git a/buffer.c b/buffer.c index e07fba6..a89c82e 100644 --- a/buffer.c +++ b/buffer.c @@ -16,371 +16,296 @@ unsigned char cmark_strbuf__initbuf[1]; #ifndef MIN -#define MIN(x,y) ((xasize = 0; - buf->size = 0; - buf->ptr = cmark_strbuf__initbuf; +void cmark_strbuf_init(cmark_strbuf *buf, bufsize_t initial_size) { + buf->asize = 0; + buf->size = 0; + buf->ptr = cmark_strbuf__initbuf; - if (initial_size > 0) - cmark_strbuf_grow(buf, initial_size); + if (initial_size > 0) + cmark_strbuf_grow(buf, initial_size); } -void cmark_strbuf_overflow_err() -{ - fprintf(stderr, "String buffer overflow"); - abort(); +void cmark_strbuf_overflow_err() { + fprintf(stderr, "String buffer overflow"); + abort(); } -static inline void -S_strbuf_grow_by(cmark_strbuf *buf, size_t add) -{ - size_t target_size = (size_t)buf->size + add; +static inline void S_strbuf_grow_by(cmark_strbuf *buf, size_t add) { + size_t target_size = (size_t)buf->size + add; - if (target_size < add /* Integer overflow. */ - || target_size > BUFSIZE_MAX /* Truncation overflow. */ - ) { - cmark_strbuf_overflow_err(); - return; /* unreachable */ - } + if (target_size < add /* Integer overflow. */ + || target_size > BUFSIZE_MAX /* Truncation overflow. */ + ) { + cmark_strbuf_overflow_err(); + return; /* unreachable */ + } - if ((bufsize_t)target_size >= buf->asize) - cmark_strbuf_grow(buf, (bufsize_t)target_size); + if ((bufsize_t)target_size >= buf->asize) + cmark_strbuf_grow(buf, (bufsize_t)target_size); } -void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) -{ - unsigned char *new_ptr; - - if (target_size < buf->asize) - return; - - if (buf->asize == 0) { - new_ptr = NULL; - } else { - new_ptr = buf->ptr; - } - - /* Oversize the buffer by 50% to guarantee amortized linear time - * complexity on append operations. */ - size_t new_size = (size_t)target_size + (size_t)target_size / 2; - - /* Account for terminating null byte. */ - new_size += 1; - - /* round allocation up to multiple of 8 */ - new_size = (new_size + 7) & ~7; - - if (new_size < (size_t)target_size /* Integer overflow. */ - || new_size > BUFSIZE_MAX /* Truncation overflow. */ - ) { - if (target_size >= BUFSIZE_MAX) { - /* No space for terminating null byte. */ - cmark_strbuf_overflow_err(); - return; /* unreachable */ - } - /* Oversize by the maximum possible amount. */ - new_size = BUFSIZE_MAX; - } - - new_ptr = (unsigned char *)realloc(new_ptr, new_size); - - if (!new_ptr) { - perror("realloc in cmark_strbuf_grow"); - abort(); - } - - buf->asize = (bufsize_t)new_size; - buf->ptr = new_ptr; +void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) { + unsigned char *new_ptr; + + if (target_size < buf->asize) + return; + + if (buf->asize == 0) { + new_ptr = NULL; + } else { + new_ptr = buf->ptr; + } + + /* Oversize the buffer by 50% to guarantee amortized linear time + * complexity on append operations. */ + size_t new_size = (size_t)target_size + (size_t)target_size / 2; + + /* Account for terminating null byte. */ + new_size += 1; + + /* round allocation up to multiple of 8 */ + new_size = (new_size + 7) & ~7; + + if (new_size < (size_t)target_size /* Integer overflow. */ + || new_size > BUFSIZE_MAX /* Truncation overflow. */ + ) { + if (target_size >= BUFSIZE_MAX) { + /* No space for terminating null byte. */ + cmark_strbuf_overflow_err(); + return; /* unreachable */ + } + /* Oversize by the maximum possible amount. */ + new_size = BUFSIZE_MAX; + } + + new_ptr = (unsigned char *)realloc(new_ptr, new_size); + + if (!new_ptr) { + perror("realloc in cmark_strbuf_grow"); + abort(); + } + + buf->asize = (bufsize_t)new_size; + buf->ptr = new_ptr; } -bufsize_t cmark_strbuf_len(const cmark_strbuf *buf) -{ - return buf->size; -} +bufsize_t cmark_strbuf_len(const cmark_strbuf *buf) { return buf->size; } -void cmark_strbuf_free(cmark_strbuf *buf) -{ - if (!buf) return; +void cmark_strbuf_free(cmark_strbuf *buf) { + if (!buf) + return; - if (buf->ptr != cmark_strbuf__initbuf) - free(buf->ptr); + if (buf->ptr != cmark_strbuf__initbuf) + free(buf->ptr); - cmark_strbuf_init(buf, 0); + cmark_strbuf_init(buf, 0); } -void cmark_strbuf_clear(cmark_strbuf *buf) -{ - buf->size = 0; +void cmark_strbuf_clear(cmark_strbuf *buf) { + buf->size = 0; - if (buf->asize > 0) - buf->ptr[0] = '\0'; + if (buf->asize > 0) + buf->ptr[0] = '\0'; } -void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, bufsize_t len) -{ - if (len <= 0 || data == NULL) { - cmark_strbuf_clear(buf); - } else { - if (data != buf->ptr) { - if (len >= buf->asize) - cmark_strbuf_grow(buf, len); - memmove(buf->ptr, data, len); - } - buf->size = len; - buf->ptr[buf->size] = '\0'; - } +void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, + bufsize_t len) { + if (len <= 0 || data == NULL) { + cmark_strbuf_clear(buf); + } else { + if (data != buf->ptr) { + if (len >= buf->asize) + cmark_strbuf_grow(buf, len); + memmove(buf->ptr, data, len); + } + buf->size = len; + buf->ptr[buf->size] = '\0'; + } } -void cmark_strbuf_sets(cmark_strbuf *buf, const char *string) -{ - cmark_strbuf_set(buf, (const unsigned char *)string, - string ? cmark_strbuf_safe_strlen(string) : 0); +void cmark_strbuf_sets(cmark_strbuf *buf, const char *string) { + cmark_strbuf_set(buf, (const unsigned char *)string, + string ? cmark_strbuf_safe_strlen(string) : 0); } -void cmark_strbuf_putc(cmark_strbuf *buf, int c) -{ - S_strbuf_grow_by(buf, 1); - buf->ptr[buf->size++] = c; - buf->ptr[buf->size] = '\0'; +void cmark_strbuf_putc(cmark_strbuf *buf, int c) { + S_strbuf_grow_by(buf, 1); + buf->ptr[buf->size++] = (unsigned char)(c & 0xFF); + buf->ptr[buf->size] = '\0'; } -void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, bufsize_t len) -{ - if (len <= 0) - return; +void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, + bufsize_t len) { + if (len <= 0) + return; - S_strbuf_grow_by(buf, len); - memmove(buf->ptr + buf->size, data, len); - buf->size += len; - buf->ptr[buf->size] = '\0'; + S_strbuf_grow_by(buf, len); + memmove(buf->ptr + buf->size, data, len); + buf->size += len; + buf->ptr[buf->size] = '\0'; } -void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) -{ - cmark_strbuf_put(buf, (const unsigned char *)string, - cmark_strbuf_safe_strlen(string)); +void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) { + cmark_strbuf_put(buf, (const unsigned char *)string, + cmark_strbuf_safe_strlen(string)); } -void cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap) -{ - size_t expected_size = strlen(format); - if (expected_size <= SIZE_MAX / 2) - expected_size *= 2; - S_strbuf_grow_by(buf, expected_size); - - while (1) { - va_list args; - va_copy(args, ap); - - int len = vsnprintf( - (char *)buf->ptr + buf->size, - buf->asize - buf->size, - format, args - ); -#ifndef HAVE_C99_SNPRINTF - // Assume we're on Windows. - if (len < 0) { - len = _vscprintf(format, args); - } -#endif +void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, + const cmark_strbuf *buf) { + bufsize_t copylen; - va_end(args); + assert(buf); + if (!data || datasize <= 0) + return; - if (len < 0) { - perror("vsnprintf in cmark_strbuf_vprintf"); - abort(); - } + data[0] = '\0'; - if ((size_t)len < (size_t)(buf->asize - buf->size)) { - buf->size += len; - break; - } + if (buf->size == 0 || buf->asize <= 0) + return; - S_strbuf_grow_by(buf, len); - } + copylen = buf->size; + if (copylen > datasize - 1) + copylen = datasize - 1; + memmove(data, buf->ptr, copylen); + data[copylen] = '\0'; } -void cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) -{ - va_list ap; - - va_start(ap, format); - cmark_strbuf_vprintf(buf, format, ap); - va_end(ap); +void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) { + cmark_strbuf t = *buf_a; + *buf_a = *buf_b; + *buf_b = t; } -void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, const cmark_strbuf *buf) -{ - bufsize_t copylen; - - assert(buf); - if (!data || datasize <= 0) - return; - - data[0] = '\0'; +unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) { + unsigned char *data = buf->ptr; - if (buf->size == 0 || buf->asize <= 0) - return; + if (buf->asize == 0) { + /* return an empty string */ + return (unsigned char *)calloc(1, 1); + } - copylen = buf->size; - if (copylen > datasize - 1) - copylen = datasize - 1; - memmove(data, buf->ptr, copylen); - data[copylen] = '\0'; + cmark_strbuf_init(buf, 0); + return data; } -void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) -{ - cmark_strbuf t = *buf_a; - *buf_a = *buf_b; - *buf_b = t; +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; } -unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) -{ - unsigned char *data = buf->ptr; +bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos) { + if (pos >= buf->size) + return -1; + if (pos < 0) + pos = 0; - if (buf->asize == 0) { - /* return an empty string */ - return (unsigned char *)calloc(1, 1); - } + const unsigned char *p = + (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos); + if (!p) + return -1; - cmark_strbuf_init(buf, 0); - return data; + return (bufsize_t)(p - (const unsigned char *)buf->ptr); } -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; -} - -bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos) -{ - if (pos >= buf->size) - return -1; - if (pos < 0) - pos = 0; +bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos) { + if (pos < 0 || buf->size == 0) + return -1; + if (pos >= buf->size) + pos = buf->size - 1; - const unsigned char *p = (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos); - if (!p) - return -1; + for (bufsize_t i = pos; i >= 0; i--) { + if (buf->ptr[i] == (unsigned char)c) + return i; + } - return (bufsize_t)(p - (const unsigned char *)buf->ptr); + return -1; } -bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos) -{ - if (pos < 0 || buf->size == 0) - return -1; - if (pos >= buf->size) - pos = buf->size - 1; - - for (bufsize_t i = pos; i >= 0; i--) { - if (buf->ptr[i] == (unsigned char) c) - return i; - } +void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len) { + if (len < 0) + len = 0; - return -1; + if (len < buf->size) { + buf->size = len; + buf->ptr[buf->size] = '\0'; + } } -void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len) -{ - if (len < 0) - len = 0; - - if (len < buf->size) { - buf->size = len; - buf->ptr[buf->size] = '\0'; - } -} +void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n) { + if (n > 0) { + if (n > buf->size) + n = buf->size; + buf->size = buf->size - n; + if (buf->size) + memmove(buf->ptr, buf->ptr + n, buf->size); -void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n) -{ - if (n > 0) { - if (n > buf->size) - n = buf->size; - buf->size = buf->size - n; - if (buf->size) - memmove(buf->ptr, buf->ptr + n, buf->size); - - buf->ptr[buf->size] = '\0'; - } + buf->ptr[buf->size] = '\0'; + } } -void cmark_strbuf_rtrim(cmark_strbuf *buf) -{ - if (!buf->size) - return; +void cmark_strbuf_rtrim(cmark_strbuf *buf) { + if (!buf->size) + return; - while (buf->size > 0) { - if (!cmark_isspace(buf->ptr[buf->size - 1])) - break; + while (buf->size > 0) { + if (!cmark_isspace(buf->ptr[buf->size - 1])) + break; - buf->size--; - } + buf->size--; + } - buf->ptr[buf->size] = '\0'; + buf->ptr[buf->size] = '\0'; } -void cmark_strbuf_trim(cmark_strbuf *buf) -{ - bufsize_t i = 0; +void cmark_strbuf_trim(cmark_strbuf *buf) { + bufsize_t i = 0; - if (!buf->size) - return; + if (!buf->size) + return; - while (i < buf->size && cmark_isspace(buf->ptr[i])) - i++; + while (i < buf->size && cmark_isspace(buf->ptr[i])) + i++; - cmark_strbuf_drop(buf, i); + cmark_strbuf_drop(buf, i); - cmark_strbuf_rtrim(buf); + 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; - bufsize_t 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); +void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) { + bool last_char_was_space = false; + bufsize_t r, w; + + for (r = 0, w = 0; r < s->size; ++r) { + if (cmark_isspace(s->ptr[r])) { + if (!last_char_was_space) { + s->ptr[w++] = ' '; + last_char_was_space = true; + } + } else { + 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) -{ - bufsize_t r, w; +extern void cmark_strbuf_unescape(cmark_strbuf *buf) { + bufsize_t r, w; - for (r = 0, w = 0; r < buf->size; ++r) { - if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1])) - r++; + for (r = 0, w = 0; r < buf->size; ++r) { + if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1])) + r++; - buf->ptr[w++] = buf->ptr[r]; - } + buf->ptr[w++] = buf->ptr[r]; + } - cmark_strbuf_truncate(buf, w); + cmark_strbuf_truncate(buf, w); } diff --git a/buffer.h b/buffer.h index babd051..6fd0cae 100644 --- a/buffer.h +++ b/buffer.h @@ -14,13 +14,14 @@ extern "C" { typedef int bufsize_t; typedef struct { - unsigned char *ptr; - bufsize_t asize, size; + unsigned char *ptr; + bufsize_t asize, size; } cmark_strbuf; extern unsigned char cmark_strbuf__initbuf[]; -#define GH_BUF_INIT { cmark_strbuf__initbuf, 0, 0 } +#define GH_BUF_INIT \ + { cmark_strbuf__initbuf, 0, 0 } #define BUFSIZE_MAX INT_MAX /** @@ -44,23 +45,22 @@ bufsize_t cmark_strbuf_len(const cmark_strbuf *buf); int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b); unsigned char *cmark_strbuf_detach(cmark_strbuf *buf); -void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, const cmark_strbuf *buf); +void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, + const cmark_strbuf *buf); -static inline const char *cmark_strbuf_cstr(const cmark_strbuf *buf) -{ - return (char *)buf->ptr; +static CMARK_INLINE const char *cmark_strbuf_cstr(const cmark_strbuf *buf) { + return (char *)buf->ptr; } #define cmark_strbuf_at(buf, n) ((buf)->ptr[n]) -void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, bufsize_t len); +void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, + bufsize_t len); void cmark_strbuf_sets(cmark_strbuf *buf, const char *string); void cmark_strbuf_putc(cmark_strbuf *buf, int c); -void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, bufsize_t len); +void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, + bufsize_t len); void cmark_strbuf_puts(cmark_strbuf *buf, const char *string); -void cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) - CMARK_ATTRIBUTE((format (printf, 2, 3))); -void cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap); void cmark_strbuf_clear(cmark_strbuf *buf); bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos); @@ -75,17 +75,15 @@ void cmark_strbuf_unescape(cmark_strbuf *s); /* Print error and abort. */ void cmark_strbuf_overflow_err(void); -static inline bufsize_t -cmark_strbuf_check_bufsize(size_t size) { - if (size > BUFSIZE_MAX) { - cmark_strbuf_overflow_err(); - } - return (bufsize_t)size; +static CMARK_INLINE bufsize_t cmark_strbuf_check_bufsize(size_t size) { + if (size > BUFSIZE_MAX) { + cmark_strbuf_overflow_err(); + } + return (bufsize_t)size; } -static inline bufsize_t -cmark_strbuf_safe_strlen(const char *str) { - return cmark_strbuf_check_bufsize(strlen(str)); +static CMARK_INLINE bufsize_t cmark_strbuf_safe_strlen(const char *str) { + return cmark_strbuf_check_bufsize(strlen(str)); } #ifdef __cplusplus diff --git a/chunk.h b/chunk.h index f23a02d..a8a11f6 100644 --- a/chunk.h +++ b/chunk.h @@ -7,115 +7,111 @@ #include "cmark_ctype.h" #include "buffer.h" -#define CMARK_CHUNK_EMPTY { NULL, 0, 0 } +#define CMARK_CHUNK_EMPTY \ + { NULL, 0, 0 } typedef struct { - unsigned char *data; - bufsize_t len; - bufsize_t alloc; // also implies a NULL-terminated string + unsigned char *data; + bufsize_t len; + bufsize_t alloc; // also implies a NULL-terminated string } cmark_chunk; -static inline void cmark_chunk_free(cmark_chunk *c) -{ - if (c->alloc) - free(c->data); +static CMARK_INLINE void cmark_chunk_free(cmark_chunk *c) { + if (c->alloc) + free(c->data); - c->data = NULL; - c->alloc = 0; - c->len = 0; + c->data = NULL; + c->alloc = 0; + c->len = 0; } -static inline void cmark_chunk_ltrim(cmark_chunk *c) -{ - assert(!c->alloc); +static CMARK_INLINE void cmark_chunk_ltrim(cmark_chunk *c) { + assert(!c->alloc); - while (c->len && cmark_isspace(c->data[0])) { - c->data++; - c->len--; - } + 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; +static CMARK_INLINE void cmark_chunk_rtrim(cmark_chunk *c) { + while (c->len > 0) { + if (!cmark_isspace(c->data[c->len - 1])) + break; - c->len--; - } + c->len--; + } } -static inline void cmark_chunk_trim(cmark_chunk *c) -{ - cmark_chunk_ltrim(c); - cmark_chunk_rtrim(c); +static CMARK_INLINE void cmark_chunk_trim(cmark_chunk *c) { + cmark_chunk_ltrim(c); + cmark_chunk_rtrim(c); } -static inline bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c, bufsize_t offset) -{ - const unsigned char *p = (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); - return p ? (bufsize_t)(p - ch->data) : ch->len; +static CMARK_INLINE bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c, + bufsize_t offset) { + const unsigned char *p = + (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); + return p ? (bufsize_t)(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) { - if(c->len > 0) { - memcpy(str, c->data, c->len); - } - str[c->len] = 0; - } - c->data = str; - c->alloc = 1; - - return (char *)str; +static CMARK_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) { + if (c->len > 0) { + 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); - } - if (str == NULL) { - c->len = 0; - c->data = NULL; - c->alloc = 0; - } else { - c->len = cmark_strbuf_safe_strlen(str); - c->data = (unsigned char *)malloc(c->len + 1); - c->alloc = 1; - memcpy(c->data, str, c->len + 1); - } +static CMARK_INLINE void +cmark_chunk_set_cstr(cmark_chunk *c, const char *str) { + if (c->alloc) { + free(c->data); + } + if (str == NULL) { + c->len = 0; + c->data = NULL; + c->alloc = 0; + } else { + c->len = cmark_strbuf_safe_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) -{ - bufsize_t len = data ? cmark_strbuf_safe_strlen(data) : 0; - cmark_chunk c = {(unsigned char *)data, len, 0}; - return c; +static CMARK_INLINE cmark_chunk cmark_chunk_literal(const char *data) { + bufsize_t len = data ? cmark_strbuf_safe_strlen(data) : 0; + cmark_chunk c = {(unsigned char *)data, len, 0}; + return c; } -static inline cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, bufsize_t pos, bufsize_t len) -{ - cmark_chunk c = {ch->data + pos, len, 0}; - return c; +static CMARK_INLINE +cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, bufsize_t pos, + bufsize_t 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; +static CMARK_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; + c.len = buf->size; + c.data = cmark_strbuf_detach(buf); + c.alloc = 1; - return c; + return c; } #endif diff --git a/cmark.c b/cmark.c index ca9807b..3491199 100644 --- a/cmark.c +++ b/cmark.c @@ -6,26 +6,18 @@ #include "cmark.h" #include "buffer.h" -int cmark_version() -{ - return CMARK_VERSION; -} +int cmark_version() { return CMARK_VERSION; } -const char *cmark_version_string() -{ - return CMARK_VERSION_STRING; -} +const char *cmark_version_string() { return CMARK_VERSION_STRING; } -char *cmark_markdown_to_html(const char *text, size_t len, int options) -{ - cmark_node *doc; - char *result; +char *cmark_markdown_to_html(const char *text, size_t len, int options) { + cmark_node *doc; + char *result; - doc = cmark_parse_document(text, len, options); + doc = cmark_parse_document(text, len, options); - result = cmark_render_html(doc, options); - cmark_node_free(doc); + result = cmark_render_html(doc, options); + cmark_node_free(doc); - return result; + return result; } - diff --git a/cmark.h b/cmark.h index e1bc891..37cacd3 100644 --- a/cmark.h +++ b/cmark.h @@ -30,49 +30,48 @@ char *cmark_markdown_to_html(const char *text, size_t len, int options); */ 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, + /* 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; + CMARK_NO_LIST, + CMARK_BULLET_LIST, + CMARK_ORDERED_LIST +} cmark_list_type; typedef enum { - CMARK_NO_DELIM, - CMARK_PERIOD_DELIM, - CMARK_PAREN_DELIM + CMARK_NO_DELIM, + CMARK_PERIOD_DELIM, + CMARK_PAREN_DELIM } cmark_delim_type; typedef struct cmark_node cmark_node; @@ -80,10 +79,10 @@ 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_NONE, + CMARK_EVENT_DONE, + CMARK_EVENT_ENTER, + CMARK_EVENT_EXIT } cmark_event_type; /** @@ -94,13 +93,11 @@ typedef enum { * other required properties, which it is the caller's responsibility * to assign. */ -CMARK_EXPORT cmark_node* -cmark_node_new(cmark_node_type type); +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); +CMARK_EXPORT void cmark_node_free(cmark_node *node); /** * ## Tree Traversal @@ -109,29 +106,24 @@ cmark_node_free(cmark_node *node); /** 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); +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); +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); +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); +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); +CMARK_EXPORT cmark_node *cmark_node_last_child(cmark_node *node); /** * ## Iterator @@ -182,48 +174,41 @@ cmark_node_last_child(cmark_node *node); * type are undefined until `cmark_iter_next` is called for the first time. */ CMARK_EXPORT -cmark_iter* -cmark_iter_new(cmark_node *root); +cmark_iter *cmark_iter_new(cmark_node *root); /** Frees the memory allocated for an iterator. */ CMARK_EXPORT -void -cmark_iter_free(cmark_iter *iter); +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); +cmark_event_type cmark_iter_next(cmark_iter *iter); /** Returns the current node. */ CMARK_EXPORT -cmark_node* -cmark_iter_get_node(cmark_iter *iter); +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); +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); +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); +void cmark_iter_reset(cmark_iter *iter, cmark_node *current, + cmark_event_type event_type); /** * ## Accessors @@ -231,144 +216,120 @@ cmark_iter_reset(cmark_iter *iter, cmark_node *current, /** Returns the user data of 'node'. */ -CMARK_EXPORT void* -cmark_node_get_user_data(cmark_node *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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +CMARK_EXPORT int cmark_node_get_end_column(cmark_node *node); /** * ## Tree Manipulation @@ -377,35 +338,30 @@ cmark_node_get_end_column(cmark_node *node); /** 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); +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); +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); +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); +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); +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); +CMARK_EXPORT void cmark_consolidate_text_nodes(cmark_node *root); /** * ## Parsing @@ -552,28 +508,28 @@ const char *cmark_version_string(); */ #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 +#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 diff --git a/cmark_ctype.c b/cmark_ctype.c index 5de8199..863c35e 100644 --- a/cmark_ctype.c +++ b/cmark_ctype.c @@ -5,49 +5,38 @@ /** 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 -}; + /* 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; -} +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_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_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; -} +int cmark_isdigit(char c) { return cmark_ctype_class[(int8_t)c] == 3; } diff --git a/cmark_export.h b/cmark_export.h index 3f437dc..1102c36 100644 --- a/cmark_export.h +++ b/cmark_export.h @@ -23,14 +23,8 @@ #ifndef CMARK_DEPRECATED # define CMARK_DEPRECATED __attribute__ ((__deprecated__)) -#endif - -#ifndef CMARK_DEPRECATED_EXPORT -# define CMARK_DEPRECATED_EXPORT CMARK_EXPORT CMARK_DEPRECATED -#endif - -#ifndef CMARK_DEPRECATED_NO_EXPORT -# define CMARK_DEPRECATED_NO_EXPORT CMARK_NO_EXPORT CMARK_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 diff --git a/cmark_version.h b/cmark_version.h index 09b1b82..2084b2c 100644 --- a/cmark_version.h +++ b/cmark_version.h @@ -1,7 +1,7 @@ #ifndef CMARK_VERSION_H #define CMARK_VERSION_H -#define CMARK_VERSION ((0 << 16) | (18 << 8) | 0) -#define CMARK_VERSION_STRING "0.18.0" +#define CMARK_VERSION ((0 << 16) | (22 << 8) | 0) +#define CMARK_VERSION_STRING "0.22.0" #endif diff --git a/commonmark.c b/commonmark.c index 0f4c2bc..da81623 100644 --- a/commonmark.c +++ b/commonmark.c @@ -20,443 +20,408 @@ // Functions to convert cmark_nodes to commonmark strings. -static inline void outc(cmark_renderer *renderer, - cmark_escaping escape, - int32_t c, - unsigned char nextc) -{ - bool needs_escaping = false; - needs_escaping = - escape != LITERAL && - ((escape == NORMAL && - (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || - c == '<' || c == '>' || c == '\\' || c == '`' || c == '!' || - (c == '&' && isalpha(nextc)) || - (c == '!' && nextc == '[') || - (renderer->begin_line && - (c == '-' || c == '+' || c == '=')) || - ((c == '.' || c == ')') && - isdigit(renderer->buffer->ptr[renderer->buffer->size - 1])))) || - (escape == URL && - (c == '`' || c == '<' || c == '>' || isspace(c) || - c == '\\' || c == ')' || c == '(')) || - (escape == TITLE && - (c == '`' || c == '<' || c == '>' || c == '"' || - c == '\\'))); - - if (needs_escaping) { - if (isspace(c)) { - // use percent encoding for spaces - cmark_strbuf_printf(renderer->buffer, "%%%2x", c); - renderer->column += 3; - } else { - cmark_render_ascii(renderer, "\\"); - cmark_render_code_point(renderer, c); - } - } else { - cmark_render_code_point(renderer, c); - } +static inline void outc(cmark_renderer *renderer, cmark_escaping escape, + int32_t c, unsigned char nextc) { + bool needs_escaping = false; + char encoded[20]; + + needs_escaping = + escape != LITERAL && + ((escape == NORMAL && + (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' || + c == '>' || c == '\\' || c == '`' || c == '!' || + (c == '&' && isalpha(nextc)) || (c == '!' && nextc == '[') || + (renderer->begin_line && (c == '-' || c == '+' || c == '=')) || + ((c == '.' || c == ')') && + isdigit(renderer->buffer->ptr[renderer->buffer->size - 1])))) || + (escape == URL && (c == '`' || c == '<' || c == '>' || isspace(c) || + c == '\\' || c == ')' || c == '(')) || + (escape == TITLE && + (c == '`' || c == '<' || c == '>' || c == '"' || c == '\\'))); + + if (needs_escaping) { + if (isspace(c)) { + // use percent encoding for spaces + sprintf(encoded, "%%%2x", c); + cmark_strbuf_puts(renderer->buffer, encoded); + renderer->column += 3; + } else { + cmark_render_ascii(renderer, "\\"); + cmark_render_code_point(renderer, c); + } + } else { + cmark_render_code_point(renderer, c); + } } -static int -longest_backtick_sequence(const char *code) -{ - int longest = 0; - int current = 0; - size_t i = 0; - size_t code_len = safe_strlen(code); - while (i <= code_len) { - if (code[i] == '`') { - current++; - } else { - if (current > longest) { - longest = current; - } - current = 0; - } - i++; - } - return longest; +static int longest_backtick_sequence(const char *code) { + int longest = 0; + int current = 0; + size_t i = 0; + size_t code_len = safe_strlen(code); + while (i <= code_len) { + if (code[i] == '`') { + current++; + } else { + if (current > longest) { + longest = current; + } + current = 0; + } + i++; + } + return longest; } -static int -shortest_unused_backtick_sequence(const char *code) -{ - int32_t used = 1; - int current = 0; - size_t i = 0; - size_t code_len = safe_strlen(code); - while (i <= code_len) { - if (code[i] == '`') { - current++; - } else { - if (current) { - used |= (1 << current); - } - current = 0; - } - i++; - } - // return number of first bit that is 0: - i = 0; - while (used & 1) { - used = used >> 1; - i++; - } - return i; +static int shortest_unused_backtick_sequence(const char *code) { + int32_t used = 1; + int current = 0; + size_t i = 0; + size_t code_len = safe_strlen(code); + while (i <= code_len) { + if (code[i] == '`') { + current++; + } else { + if (current) { + used |= (1 << current); + } + current = 0; + } + i++; + } + // return number of first bit that is 0: + i = 0; + while (used & 1) { + used = used >> 1; + i++; + } + return i; } -static bool -is_autolink(cmark_node *node) -{ - cmark_chunk *title; - cmark_chunk *url; - cmark_node *link_text; - char *realurl; - int realurllen; - - if (node->type != CMARK_NODE_LINK) { - return false; - } - - url = &node->as.link.url; - if (url->len == 0 || scan_scheme(url, 0) == 0) { - return false; - } - - title = &node->as.link.title; - // if it has a title, we can't treat it as an autolink: - if (title->len > 0) { - return false; - } - - link_text = node->first_child; - cmark_consolidate_text_nodes(link_text); - realurl = (char*)url->data; - realurllen = url->len; - if (strncmp(realurl, "mailto:", 7) == 0) { - realurl += 7; - realurllen -= 7; - } - return (realurllen == link_text->as.literal.len && - strncmp(realurl, - (char*)link_text->as.literal.data, - link_text->as.literal.len) == 0); +static bool is_autolink(cmark_node *node) { + cmark_chunk *title; + cmark_chunk *url; + cmark_node *link_text; + char *realurl; + int realurllen; + + if (node->type != CMARK_NODE_LINK) { + return false; + } + + url = &node->as.link.url; + if (url->len == 0 || scan_scheme(url, 0) == 0) { + return false; + } + + title = &node->as.link.title; + // if it has a title, we can't treat it as an autolink: + if (title->len > 0) { + return false; + } + + link_text = node->first_child; + cmark_consolidate_text_nodes(link_text); + realurl = (char *)url->data; + realurllen = url->len; + if (strncmp(realurl, "mailto:", 7) == 0) { + realurl += 7; + realurllen -= 7; + } + return (realurllen == link_text->as.literal.len && + strncmp(realurl, (char *)link_text->as.literal.data, + link_text->as.literal.len) == 0); } // if node is a block node, returns node. // otherwise returns first block-level node that is an ancestor of node. -static cmark_node* -get_containing_block(cmark_node *node) -{ - while (node && - (node->type < CMARK_NODE_FIRST_BLOCK || - node->type > CMARK_NODE_LAST_BLOCK)) { - node = node->parent; - } - return node; +static cmark_node *get_containing_block(cmark_node *node) { + while (node && (node->type < CMARK_NODE_FIRST_BLOCK || + node->type > CMARK_NODE_LAST_BLOCK)) { + node = node->parent; + } + return node; } -static int -S_render_node(cmark_renderer *renderer, - cmark_node *node, - cmark_event_type ev_type, - int options) -{ - cmark_node *tmp; - int list_number; - cmark_delim_type list_delim; - int numticks; - int i; - bool entering = (ev_type == CMARK_EVENT_ENTER); - const char *info, *code, *title; - size_t info_len, code_len; - cmark_strbuf listmarker = GH_BUF_INIT; - char *emph_delim; - bufsize_t marker_width; - - // Don't adjust tight list status til we've started the list. - // Otherwise we loose the blank line between a paragraph and - // a following list. - if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && - entering)) { - tmp = get_containing_block(node); - renderer->in_tight_list_item = - (tmp->type == CMARK_NODE_ITEM && - cmark_node_get_list_tight(tmp->parent)) || - (tmp && - tmp->parent && - tmp->parent->type == CMARK_NODE_ITEM && - cmark_node_get_list_tight(tmp->parent->parent)); - } - - switch (node->type) { - case CMARK_NODE_DOCUMENT: - break; - - case CMARK_NODE_BLOCK_QUOTE: - if (entering) { - LIT("> "); - cmark_strbuf_puts(renderer->prefix, "> "); - } else { - cmark_strbuf_truncate(renderer->prefix, - renderer->prefix->size - 2); - BLANKLINE(); - } - break; - - case CMARK_NODE_LIST: - if (!entering && node->next && - (node->next->type == CMARK_NODE_CODE_BLOCK || - node->next->type == CMARK_NODE_LIST)) { - // this ensures 2 blank lines after list, - // if before code block or list: - LIT("\n"); - } - break; - - case CMARK_NODE_ITEM: - if (cmark_node_get_list_type(node->parent) == - CMARK_BULLET_LIST) { - marker_width = 2; - } else { - list_number = cmark_node_get_list_start(node->parent); - list_delim = cmark_node_get_list_delim(node->parent); - tmp = node; - while (tmp->prev) { - tmp = tmp->prev; - list_number += 1; - } - // we ensure a width of at least 4 so - // we get nice transition from single digits - // to double - cmark_strbuf_printf(&listmarker, - "%d%s%s", list_number, - list_delim == CMARK_PAREN_DELIM ? - ")" : ".", - list_number < 10 ? " " : " "); - marker_width = listmarker.size; - } - if (entering) { - if (cmark_node_get_list_type(node->parent) == - CMARK_BULLET_LIST) { - LIT("* "); - cmark_strbuf_puts(renderer->prefix, " "); - } else { - LIT((char *)listmarker.ptr); - for (i = marker_width; i--;) { - cmark_strbuf_putc(renderer->prefix, ' '); - } - } - } else { - cmark_strbuf_truncate(renderer->prefix, - renderer->prefix->size - - marker_width); - CR(); - } - cmark_strbuf_free(&listmarker); - break; - - case CMARK_NODE_HEADER: - if (entering) { - for (int i = cmark_node_get_header_level(node); i > 0; i--) { - LIT("#"); - } - LIT(" "); - renderer->no_wrap = true; - } else { - renderer->no_wrap = false; - BLANKLINE(); - } - break; - - case CMARK_NODE_CODE_BLOCK: - BLANKLINE(); - info = cmark_node_get_fence_info(node); - info_len = safe_strlen(info); - code = cmark_node_get_literal(node); - code_len = safe_strlen(code); - // use indented form if no info, and code doesn't - // begin or end with a blank line, and code isn't - // first thing in a list item - if (info_len == 0 && - (code_len > 2 && - !isspace(code[0]) && - !(isspace(code[code_len - 1]) && - isspace(code[code_len - 2]))) && - !(node->prev == NULL && node->parent && - node->parent->type == CMARK_NODE_ITEM)) { - LIT(" "); - cmark_strbuf_puts(renderer->prefix, " "); - OUT(cmark_node_get_literal(node), false, LITERAL); - cmark_strbuf_truncate(renderer->prefix, - renderer->prefix->size - 4); - } else { - numticks = longest_backtick_sequence(code) + 1; - if (numticks < 3) { - numticks = 3; - } - for (i = 0; i < numticks; i++) { - LIT("`"); - } - LIT(" "); - OUT(info, false, LITERAL); - CR(); - OUT(cmark_node_get_literal(node), false, LITERAL); - CR(); - for (i = 0; i < numticks; i++) { - LIT("`"); - } - } - BLANKLINE(); - break; - - case CMARK_NODE_HTML: - BLANKLINE(); - OUT(cmark_node_get_literal(node), false, LITERAL); - BLANKLINE(); - break; - - case CMARK_NODE_HRULE: - BLANKLINE(); - LIT("-----"); - BLANKLINE(); - break; - - case CMARK_NODE_PARAGRAPH: - if (!entering) { - BLANKLINE(); - } - break; - - case CMARK_NODE_TEXT: - OUT(cmark_node_get_literal(node), true, NORMAL); - break; - - case CMARK_NODE_LINEBREAK: - if (!(CMARK_OPT_HARDBREAKS & options)) { - LIT("\\"); - } - CR(); - break; - - case CMARK_NODE_SOFTBREAK: - if (renderer->width == 0 && - !(CMARK_OPT_HARDBREAKS & options)) { - CR(); - } else { - OUT(" ", true, LITERAL); - } - break; - - case CMARK_NODE_CODE: - code = cmark_node_get_literal(node); - code_len = safe_strlen(code); - numticks = shortest_unused_backtick_sequence(code); - for (i = 0; i < numticks; i++) { - LIT("`"); - } - if (code_len == 0 || code[0] == '`') { - LIT(" "); - } - OUT(cmark_node_get_literal(node), true, LITERAL); - if (code_len == 0 || code[code_len - 1] == '`') { - LIT(" "); - } - for (i = 0; i < numticks; i++) { - LIT("`"); - } - break; - - case CMARK_NODE_INLINE_HTML: - OUT(cmark_node_get_literal(node), false, LITERAL); - break; - - case CMARK_NODE_STRONG: - if (entering) { - LIT("**"); - } else { - LIT("**"); - } - break; - - case CMARK_NODE_EMPH: - // If we have EMPH(EMPH(x)), we need to use *_x_* - // because **x** is STRONG(x): - if (node->parent && node->parent->type == CMARK_NODE_EMPH && - node->next == NULL && node->prev == NULL) { - emph_delim = "_"; - } else { - emph_delim = "*"; - } - if (entering) { - LIT(emph_delim); - } else { - LIT(emph_delim); - } - break; - - case CMARK_NODE_LINK: - if (is_autolink(node)) { - if (entering) { - LIT("<"); - if (strncmp(cmark_node_get_url(node), - "mailto:", 7) == 0) { - LIT((char *)cmark_node_get_url(node) + 7); - } else { - LIT((char *)cmark_node_get_url(node)); - } - LIT(">"); - // return signal to skip contents of node... - return 0; - } - } else { - if (entering) { - LIT("["); - } else { - LIT("]("); - OUT(cmark_node_get_url(node), false, URL); - title = cmark_node_get_title(node); - if (safe_strlen(title) > 0) { - LIT(" \""); - OUT(title, false, TITLE); - LIT("\""); - } - LIT(")"); - } - } - break; - - case CMARK_NODE_IMAGE: - if (entering) { - LIT("!["); - } else { - LIT("]("); - OUT(cmark_node_get_url(node), false, URL); - title = cmark_node_get_title(node); - if (safe_strlen(title) > 0) { - OUT(" \"", true, LITERAL); - OUT(title, false, TITLE); - LIT("\""); - } - LIT(")"); - } - break; - - default: - assert(false); - break; - } - - return 1; +static int S_render_node(cmark_renderer *renderer, cmark_node *node, + cmark_event_type ev_type, int options) { + cmark_node *tmp; + int list_number; + cmark_delim_type list_delim; + int numticks; + int i; + bool entering = (ev_type == CMARK_EVENT_ENTER); + const char *info, *code, *title; + size_t info_len, code_len; + char listmarker[20]; + char *emph_delim; + bufsize_t marker_width; + + // Don't adjust tight list status til we've started the list. + // Otherwise we loose the blank line between a paragraph and + // a following list. + if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && entering)) { + tmp = get_containing_block(node); + renderer->in_tight_list_item = + (tmp->type == CMARK_NODE_ITEM && + cmark_node_get_list_tight(tmp->parent)) || + (tmp && tmp->parent && tmp->parent->type == CMARK_NODE_ITEM && + cmark_node_get_list_tight(tmp->parent->parent)); + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + LIT("> "); + cmark_strbuf_puts(renderer->prefix, "> "); + } else { + cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 2); + BLANKLINE(); + } + break; + + case CMARK_NODE_LIST: + if (!entering && node->next && (node->next->type == CMARK_NODE_CODE_BLOCK || + node->next->type == CMARK_NODE_LIST)) { + // this ensures 2 blank lines after list, + // if before code block or list: + LIT("\n"); + } + break; + + case CMARK_NODE_ITEM: + if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { + marker_width = 2; + } else { + list_number = cmark_node_get_list_start(node->parent); + list_delim = cmark_node_get_list_delim(node->parent); + tmp = node; + while (tmp->prev) { + tmp = tmp->prev; + list_number += 1; + } + // we ensure a width of at least 4 so + // we get nice transition from single digits + // to double + sprintf(listmarker, "%d%s%s", list_number, + list_delim == CMARK_PAREN_DELIM ? ")" : ".", + list_number < 10 ? " " : " "); + marker_width = safe_strlen(listmarker); + } + if (entering) { + if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { + LIT("* "); + cmark_strbuf_puts(renderer->prefix, " "); + } else { + LIT(listmarker); + for (i = marker_width; i--;) { + cmark_strbuf_putc(renderer->prefix, ' '); + } + } + } else { + cmark_strbuf_truncate(renderer->prefix, + renderer->prefix->size - marker_width); + CR(); + } + break; + + case CMARK_NODE_HEADER: + if (entering) { + for (int i = cmark_node_get_header_level(node); i > 0; i--) { + LIT("#"); + } + LIT(" "); + renderer->no_wrap = true; + } else { + renderer->no_wrap = false; + BLANKLINE(); + } + break; + + case CMARK_NODE_CODE_BLOCK: + BLANKLINE(); + info = cmark_node_get_fence_info(node); + info_len = safe_strlen(info); + code = cmark_node_get_literal(node); + code_len = safe_strlen(code); + // use indented form if no info, and code doesn't + // begin or end with a blank line, and code isn't + // first thing in a list item + if (info_len == 0 && + (code_len > 2 && !isspace(code[0]) && + !(isspace(code[code_len - 1]) && isspace(code[code_len - 2]))) && + !(node->prev == NULL && node->parent && + node->parent->type == CMARK_NODE_ITEM)) { + LIT(" "); + cmark_strbuf_puts(renderer->prefix, " "); + OUT(cmark_node_get_literal(node), false, LITERAL); + cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 4); + } else { + numticks = longest_backtick_sequence(code) + 1; + if (numticks < 3) { + numticks = 3; + } + for (i = 0; i < numticks; i++) { + LIT("`"); + } + LIT(" "); + OUT(info, false, LITERAL); + CR(); + OUT(cmark_node_get_literal(node), false, LITERAL); + CR(); + for (i = 0; i < numticks; i++) { + LIT("`"); + } + } + BLANKLINE(); + break; + + case CMARK_NODE_HTML: + BLANKLINE(); + OUT(cmark_node_get_literal(node), false, LITERAL); + BLANKLINE(); + break; + + case CMARK_NODE_HRULE: + BLANKLINE(); + LIT("-----"); + BLANKLINE(); + break; + + case CMARK_NODE_PARAGRAPH: + if (!entering) { + BLANKLINE(); + } + break; + + case CMARK_NODE_TEXT: + OUT(cmark_node_get_literal(node), true, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + if (!(CMARK_OPT_HARDBREAKS & options)) { + LIT("\\"); + } + CR(); + break; + + case CMARK_NODE_SOFTBREAK: + if (renderer->width == 0 && !(CMARK_OPT_HARDBREAKS & options)) { + CR(); + } else { + OUT(" ", true, LITERAL); + } + break; + + case CMARK_NODE_CODE: + code = cmark_node_get_literal(node); + code_len = safe_strlen(code); + numticks = shortest_unused_backtick_sequence(code); + for (i = 0; i < numticks; i++) { + LIT("`"); + } + if (code_len == 0 || code[0] == '`') { + LIT(" "); + } + OUT(cmark_node_get_literal(node), true, LITERAL); + if (code_len == 0 || code[code_len - 1] == '`') { + LIT(" "); + } + for (i = 0; i < numticks; i++) { + LIT("`"); + } + break; + + case CMARK_NODE_INLINE_HTML: + OUT(cmark_node_get_literal(node), false, LITERAL); + break; + + case CMARK_NODE_STRONG: + if (entering) { + LIT("**"); + } else { + LIT("**"); + } + break; + + case CMARK_NODE_EMPH: + // If we have EMPH(EMPH(x)), we need to use *_x_* + // because **x** is STRONG(x): + if (node->parent && node->parent->type == CMARK_NODE_EMPH && + node->next == NULL && node->prev == NULL) { + emph_delim = "_"; + } else { + emph_delim = "*"; + } + if (entering) { + LIT(emph_delim); + } else { + LIT(emph_delim); + } + break; + + case CMARK_NODE_LINK: + if (is_autolink(node)) { + if (entering) { + LIT("<"); + if (strncmp(cmark_node_get_url(node), "mailto:", 7) == 0) { + LIT((char *)cmark_node_get_url(node) + 7); + } else { + LIT((char *)cmark_node_get_url(node)); + } + LIT(">"); + // return signal to skip contents of node... + return 0; + } + } else { + if (entering) { + LIT("["); + } else { + LIT("]("); + OUT(cmark_node_get_url(node), false, URL); + title = cmark_node_get_title(node); + if (safe_strlen(title) > 0) { + LIT(" \""); + OUT(title, false, TITLE); + LIT("\""); + } + LIT(")"); + } + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + LIT("!["); + } else { + LIT("]("); + OUT(cmark_node_get_url(node), false, URL); + title = cmark_node_get_title(node); + if (safe_strlen(title) > 0) { + OUT(" \"", true, LITERAL); + OUT(title, false, TITLE); + LIT("\""); + } + LIT(")"); + } + break; + + default: + assert(false); + break; + } + + return 1; } -char *cmark_render_commonmark(cmark_node *root, int options, int width) -{ - if (options & CMARK_OPT_HARDBREAKS) { - // disable breaking on width, since it has - // a different meaning with OPT_HARDBREAKS - width = 0; - } - return cmark_render(root, options, width, outc, S_render_node); +char *cmark_render_commonmark(cmark_node *root, int options, int width) { + if (options & CMARK_OPT_HARDBREAKS) { + // disable breaking on width, since it has + // a different meaning with OPT_HARDBREAKS + width = 0; + } + return cmark_render(root, options, width, outc, S_render_node); } diff --git a/config.h b/config.h index 8eb09a1..2af3403 100644 --- a/config.h +++ b/config.h @@ -16,10 +16,10 @@ #define CMARK_ATTRIBUTE(list) #endif -#define HAVE_VA_COPY - -#ifndef HAVE_VA_COPY - #define va_copy(dest, src) ((dest) = (src)) +#ifndef CMARK_INLINE + #if defined(_MSC_VER) && !defined(__cplusplus) + #define CMARK_INLINE __inline + #else + #define CMARK_INLINE inline + #endif #endif - -#define HAVE_C99_SNPRINTF diff --git a/config.h.in b/config.h.in index 5960928..2792313 100644 --- a/config.h.in +++ b/config.h.in @@ -16,10 +16,10 @@ #define CMARK_ATTRIBUTE(list) #endif -#cmakedefine HAVE_VA_COPY - -#ifndef HAVE_VA_COPY - #define va_copy(dest, src) ((dest) = (src)) +#ifndef CMARK_INLINE + #if defined(_MSC_VER) && !defined(__cplusplus) + #define CMARK_INLINE __inline + #else + #define CMARK_INLINE inline + #endif #endif - -#cmakedefine HAVE_C99_SNPRINTF diff --git a/debug.h b/debug.h deleted file mode 100644 index fd2ef62..0000000 --- a/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/houdini.h b/houdini.h index b926cf3..f738e82 100644 --- a/houdini.h +++ b/houdini.h @@ -10,33 +10,39 @@ extern "C" { #include "buffer.h" #ifdef HAVE___BUILTIN_EXPECT -# define likely(x) __builtin_expect((x),1) -# define unlikely(x) __builtin_expect((x),0) +#define likely(x) __builtin_expect((x), 1) +#define unlikely(x) __builtin_expect((x), 0) #else -# define likely(x) (x) -# define unlikely(x) (x) +#define likely(x) (x) +#define unlikely(x) (x) #endif #ifdef HOUDINI_USE_LOCALE -# define _isxdigit(c) isxdigit(c) -# define _isdigit(c) isdigit(c) +#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') +#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_ESCAPED_SIZE(x) (((x)*12) / 10) #define HOUDINI_UNESCAPED_SIZE(x) (x) -extern bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, bufsize_t size); -extern int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size); -extern int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, bufsize_t size, int secure); -extern int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size); -extern void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, bufsize_t size); -extern int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, bufsize_t size); +extern bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +extern int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +extern int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size, int secure); +extern int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +extern void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +extern int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); #ifdef __cplusplus } diff --git a/houdini_href_e.c b/houdini_href_e.c index 7fb958a..9152803 100644 --- a/houdini_href_e.c +++ b/houdini_href_e.c @@ -30,78 +30,71 @@ * */ 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, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, bufsize_t size) -{ - static const uint8_t hex_chars[] = "0123456789ABCDEF"; - bufsize_t i = 0, org; - uint8_t hex_str[3]; +int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { + static const uint8_t hex_chars[] = "0123456789ABCDEF"; + bufsize_t i = 0, org; + uint8_t hex_str[3]; - hex_str[0] = '%'; + hex_str[0] = '%'; - while (i < size) { - org = i; - while (i < size && HREF_SAFE[src[i]] != 0) - i++; + 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); + if (likely(i > org)) + cmark_strbuf_put(ob, src + org, i - org); - /* escaping */ - if (i >= size) - break; + /* 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; + 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 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 */ +/* 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); - } + /* 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++; - } + i++; + } - return 1; + return 1; } diff --git a/houdini_html_e.c b/houdini_html_e.c index 7f4b91f..0e539f0 100644 --- a/houdini_html_e.c +++ b/houdini_html_e.c @@ -16,66 +16,51 @@ * */ 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, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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[] = { - "", - """, - "&", - "'", - "/", - "<", - ">" -}; +static const char *HTML_ESCAPES[] = {"", """, "&", "'", + "/", "<", ">"}; -int -houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, bufsize_t size, int secure) -{ - bufsize_t i = 0, org, esc = 0; +int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, bufsize_t size, + int secure) { + bufsize_t i = 0, org, esc = 0; - while (i < size) { - org = i; - while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0) - i++; + 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); + if (i > org) + cmark_strbuf_put(ob, src + org, i - org); - /* escaping */ - if (unlikely(i >= size)) - break; + /* 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]); - } + /* 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++; - } + i++; + } - return 1; + return 1; } -int -houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) -{ - return houdini_escape_html0(ob, src, size, 1); +int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { + return houdini_escape_html0(ob, src, size, 1); } diff --git a/houdini_html_u.c b/houdini_html_u.c index 002357d..a2d927b 100644 --- a/houdini_html_u.c +++ b/houdini_html_u.c @@ -9,145 +9,140 @@ /* Binary tree lookup code for entities added by JGM */ -static unsigned char * -S_lookup(int i, int low, int hi, const unsigned char *s, int len) -{ - int j; - int cmp = strncmp((char *)s, (char *)cmark_entities[i].entity, len); - if (cmp == 0 && cmark_entities[i].entity[len] == 0) { - return (unsigned char *)cmark_entities[i].bytes; - } else if (cmp < 0 && i > low) { - j = i - ((i - low) / 2); - if (j == i) j -= 1; - return S_lookup(j, low, i - 1, s, len); - } else if (cmp > 0 && i < hi) { - j = i + ((hi - i) / 2); - if (j == i) j += 1; - return S_lookup(j, i + 1, hi, s, len); - } else { - return NULL; - } +static unsigned char *S_lookup(int i, int low, int hi, const unsigned char *s, + int len) { + int j; + int cmp = strncmp((char *)s, (char *)cmark_entities[i].entity, len); + if (cmp == 0 && cmark_entities[i].entity[len] == 0) { + return (unsigned char *)cmark_entities[i].bytes; + } else if (cmp < 0 && i > low) { + j = i - ((i - low) / 2); + if (j == i) + j -= 1; + return S_lookup(j, low, i - 1, s, len); + } else if (cmp > 0 && i < hi) { + j = i + ((hi - i) / 2); + if (j == i) + j += 1; + return S_lookup(j, i + 1, hi, s, len); + } else { + return NULL; + } } -static unsigned char * -S_lookup_entity(const unsigned char *s, int len) -{ - return S_lookup(CMARK_NUM_ENTITIES / 2, 0, CMARK_NUM_ENTITIES - 1, s, len); +static unsigned char *S_lookup_entity(const unsigned char *s, int len) { + return S_lookup(CMARK_NUM_ENTITIES / 2, 0, CMARK_NUM_ENTITIES - 1, s, len); } -bufsize_t -houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) -{ - bufsize_t i = 0; - - if (size >= 3 && src[0] == '#') { - int codepoint = 0; - int num_digits = 0; - - if (_isdigit(src[1])) { - for (i = 1; i < size && _isdigit(src[i]); ++i) { - codepoint = (codepoint * 10) + (src[i] - '0'); - - if (codepoint >= 0x110000) { - // Keep counting digits but - // avoid integer overflow. - codepoint = 0x110000; - } - } - - num_digits = i - 1; - } - - else if (src[1] == 'x' || src[1] == 'X') { - for (i = 2; i < size && _isxdigit(src[i]); ++i) { - codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9); - - if (codepoint >= 0x110000) { - // Keep counting digits but - // avoid integer overflow. - codepoint = 0x110000; - } - } - - num_digits = i - 2; - } - - if (num_digits >= 1 && num_digits <= 8 && - i < size && src[i] == ';') { - if (codepoint == 0 || - (codepoint >= 0xD800 && codepoint < 0xE000) || - codepoint >= 0x110000) { - codepoint = 0xFFFD; - } - utf8proc_encode_char(codepoint, ob); - return i + 1; - } - } - - else { - if (size > CMARK_ENTITY_MAX_LENGTH) - size = CMARK_ENTITY_MAX_LENGTH; - - for (i = CMARK_ENTITY_MIN_LENGTH; i < size; ++i) { - if (src[i] == ' ') - break; - - if (src[i] == ';') { - const unsigned char *entity = S_lookup_entity(src, i); - - if (entity != NULL) { - cmark_strbuf_puts(ob, (const char *)entity); - return i + 1; - } - - break; - } - } - } - - return 0; +bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size) { + bufsize_t i = 0; + + if (size >= 3 && src[0] == '#') { + int codepoint = 0; + int num_digits = 0; + + if (_isdigit(src[1])) { + for (i = 1; i < size && _isdigit(src[i]); ++i) { + codepoint = (codepoint * 10) + (src[i] - '0'); + + if (codepoint >= 0x110000) { + // Keep counting digits but + // avoid integer overflow. + codepoint = 0x110000; + } + } + + num_digits = i - 1; + } + + else if (src[1] == 'x' || src[1] == 'X') { + for (i = 2; i < size && _isxdigit(src[i]); ++i) { + codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9); + + if (codepoint >= 0x110000) { + // Keep counting digits but + // avoid integer overflow. + codepoint = 0x110000; + } + } + + num_digits = i - 2; + } + + if (num_digits >= 1 && num_digits <= 8 && i < size && src[i] == ';') { + if (codepoint == 0 || (codepoint >= 0xD800 && codepoint < 0xE000) || + codepoint >= 0x110000) { + codepoint = 0xFFFD; + } + cmark_utf8proc_encode_char(codepoint, ob); + return i + 1; + } + } + + else { + if (size > CMARK_ENTITY_MAX_LENGTH) + size = CMARK_ENTITY_MAX_LENGTH; + + for (i = CMARK_ENTITY_MIN_LENGTH; i < size; ++i) { + if (src[i] == ' ') + break; + + if (src[i] == ';') { + const unsigned char *entity = S_lookup_entity(src, i); + + if (entity != NULL) { + cmark_strbuf_puts(ob, (const char *)entity); + return i + 1; + } + + break; + } + } + } + + return 0; } -int -houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) -{ - bufsize_t i = 0, org, ent; +int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size) { + bufsize_t i = 0, org, ent; - while (i < size) { - org = i; - while (i < size && src[i] != '&') - i++; + while (i < size) { + org = i; + while (i < size && src[i] != '&') + i++; - if (likely(i > org)) { - if (unlikely(org == 0)) { - if (i >= size) - return 0; + if (likely(i > org)) { + if (unlikely(org == 0)) { + if (i >= size) + return 0; - cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size)); - } + cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size)); + } - cmark_strbuf_put(ob, src + org, i - org); - } + cmark_strbuf_put(ob, src + org, i - org); + } - /* escaping */ - if (i >= size) - break; + /* escaping */ + if (i >= size) + break; - i++; + i++; - ent = houdini_unescape_ent(ob, src + i, size - i); - i += ent; + ent = houdini_unescape_ent(ob, src + i, size - i); + i += ent; - /* not really an entity */ - if (ent == 0) - cmark_strbuf_putc(ob, '&'); - } + /* not really an entity */ + if (ent == 0) + cmark_strbuf_putc(ob, '&'); + } - return 1; + return 1; } -void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) -{ - if (!houdini_unescape_html(ob, src, size)) - cmark_strbuf_put(ob, src, size); +void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size) { + if (!houdini_unescape_html(ob, src, size)) + cmark_strbuf_put(ob, src, size); } diff --git a/html.c b/html.c index c6bbea6..dfe2aec 100644 --- a/html.c +++ b/html.c @@ -12,322 +12,304 @@ // Functions to convert cmark_nodes to HTML strings. -static void escape_html(cmark_strbuf *dest, const unsigned char *source, bufsize_t length) -{ - houdini_escape_html0(dest, source, length, 0); +static void escape_html(cmark_strbuf *dest, const unsigned char *source, + bufsize_t length) { + houdini_escape_html0(dest, source, length, 0); } -static inline void cr(cmark_strbuf *html) -{ - if (html->size && html->ptr[html->size - 1] != '\n') - cmark_strbuf_putc(html, '\n'); +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; + 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 void S_render_sourcepos(cmark_node *node, cmark_strbuf *html, + int options) { + char buffer[100]; + if (CMARK_OPT_SOURCEPOS & options) { + sprintf(buffer, " 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)); + cmark_strbuf_puts(html, buffer); + } } -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 { - bufsize_t first_tag = 0; - while (first_tag < node->as.code.info.len && - !cmark_isspace(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); - if (options & CMARK_OPT_SAFE) { - cmark_strbuf_puts(html, ""); - } else { - cmark_strbuf_put(html, node->as.literal.data, - node->as.literal.len); - } - cr(html); - 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: - if (options & CMARK_OPT_SAFE) { - cmark_strbuf_puts(html, ""); - } else { - 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, 0))) { - houdini_escape_href(html, - node->as.link.url.data, - node->as.link.url.len); - - } - if (node->as.link.title.len) { - cmark_strbuf_puts(html, "\" title=\""); - escape_html(html, - node->as.link.title.data, - node->as.link.title.len); - } - cmark_strbuf_puts(html, "\">"); - } else { - cmark_strbuf_puts(html, ""); - } - break; - - case CMARK_NODE_IMAGE: - if (entering) { - cmark_strbuf_puts(html, "as.link.url, 0))) { - houdini_escape_href(html, - node->as.link.url.data, - node->as.link.url.len); - - } - cmark_strbuf_puts(html, "\" alt=\""); - state->plain = node; - } else { - if (node->as.link.title.len) { - cmark_strbuf_puts(html, "\" title=\""); - escape_html(html, node->as.link.title.data, - node->as.link.title.len); - } - - cmark_strbuf_puts(html, "\" />"); - } - break; - - default: - assert(false); - break; - } - - // cmark_strbuf_putc(html, 'x'); - return 1; +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 { + sprintf(buffer, "
    \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] = (char)('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] = (char)('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 { + bufsize_t first_tag = 0; + while (first_tag < node->as.code.info.len && + !cmark_isspace(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); + if (options & CMARK_OPT_SAFE) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); + } + cr(html); + 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: + if (options & CMARK_OPT_SAFE) { + cmark_strbuf_puts(html, ""); + } else { + 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, 0))) { + houdini_escape_href(html, node->as.link.url.data, + node->as.link.url.len); + } + if (node->as.link.title.len) { + cmark_strbuf_puts(html, "\" title=\""); + escape_html(html, node->as.link.title.data, node->as.link.title.len); + } + cmark_strbuf_puts(html, "\">"); + } else { + cmark_strbuf_puts(html, ""); + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + cmark_strbuf_puts(html, "as.link.url, 0))) { + houdini_escape_href(html, node->as.link.url.data, + node->as.link.url.len); + } + cmark_strbuf_puts(html, "\" alt=\""); + state->plain = node; + } else { + if (node->as.link.title.len) { + cmark_strbuf_puts(html, "\" title=\""); + escape_html(html, node->as.link.title.data, node->as.link.title.len); + } + + 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; +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/html_unescape.gperf b/html_unescape.gperf deleted file mode 100644 index 74173a6..0000000 --- a/html_unescape.gperf +++ /dev/null @@ -1,2130 +0,0 @@ -struct html_ent { - int entity; - unsigned char utf8[4]; -}; -%% -"Aacute", {195, 129, 0} -"aacute", {195, 161, 0} -"Abreve", {196, 130, 0} -"abreve", {196, 131, 0} -"ac", {226, 136, 190, 0} -"acd", {226, 136, 191, 0} -"acE", {226, 136, 190, 0} -"Acirc", {195, 130, 0} -"acirc", {195, 162, 0} -"acute", {194, 180, 0} -"Acy", {208, 144, 0} -"acy", {208, 176, 0} -"AElig", {195, 134, 0} -"aelig", {195, 166, 0} -"af", {226, 129, 161, 0} -"Afr", {240, 157, 148, 132} -"afr", {240, 157, 148, 158} -"Agrave", {195, 128, 0} -"agrave", {195, 160, 0} -"alefsym", {226, 132, 181, 0} -"aleph", {226, 132, 181, 0} -"Alpha", {206, 145, 0} -"alpha", {206, 177, 0} -"Amacr", {196, 128, 0} -"amacr", {196, 129, 0} -"amalg", {226, 168, 191, 0} -"amp", {38, 0} -"AMP", {38, 0} -"andand", {226, 169, 149, 0} -"And", {226, 169, 147, 0} -"and", {226, 136, 167, 0} -"andd", {226, 169, 156, 0} -"andslope", {226, 169, 152, 0} -"andv", {226, 169, 154, 0} -"ang", {226, 136, 160, 0} -"ange", {226, 166, 164, 0} -"angle", {226, 136, 160, 0} -"angmsdaa", {226, 166, 168, 0} -"angmsdab", {226, 166, 169, 0} -"angmsdac", {226, 166, 170, 0} -"angmsdad", {226, 166, 171, 0} -"angmsdae", {226, 166, 172, 0} -"angmsdaf", {226, 166, 173, 0} -"angmsdag", {226, 166, 174, 0} -"angmsdah", {226, 166, 175, 0} -"angmsd", {226, 136, 161, 0} -"angrt", {226, 136, 159, 0} -"angrtvb", {226, 138, 190, 0} -"angrtvbd", {226, 166, 157, 0} -"angsph", {226, 136, 162, 0} -"angst", {195, 133, 0} -"angzarr", {226, 141, 188, 0} -"Aogon", {196, 132, 0} -"aogon", {196, 133, 0} -"Aopf", {240, 157, 148, 184} -"aopf", {240, 157, 149, 146} -"apacir", {226, 169, 175, 0} -"ap", {226, 137, 136, 0} -"apE", {226, 169, 176, 0} -"ape", {226, 137, 138, 0} -"apid", {226, 137, 139, 0} -"apos", {39, 0} -"ApplyFunction", {226, 129, 161, 0} -"approx", {226, 137, 136, 0} -"approxeq", {226, 137, 138, 0} -"Aring", {195, 133, 0} -"aring", {195, 165, 0} -"Ascr", {240, 157, 146, 156} -"ascr", {240, 157, 146, 182} -"Assign", {226, 137, 148, 0} -"ast", {42, 0} -"asymp", {226, 137, 136, 0} -"asympeq", {226, 137, 141, 0} -"Atilde", {195, 131, 0} -"atilde", {195, 163, 0} -"Auml", {195, 132, 0} -"auml", {195, 164, 0} -"awconint", {226, 136, 179, 0} -"awint", {226, 168, 145, 0} -"backcong", {226, 137, 140, 0} -"backepsilon", {207, 182, 0} -"backprime", {226, 128, 181, 0} -"backsim", {226, 136, 189, 0} -"backsimeq", {226, 139, 141, 0} -"Backslash", {226, 136, 150, 0} -"Barv", {226, 171, 167, 0} -"barvee", {226, 138, 189, 0} -"barwed", {226, 140, 133, 0} -"Barwed", {226, 140, 134, 0} -"barwedge", {226, 140, 133, 0} -"bbrk", {226, 142, 181, 0} -"bbrktbrk", {226, 142, 182, 0} -"bcong", {226, 137, 140, 0} -"Bcy", {208, 145, 0} -"bcy", {208, 177, 0} -"bdquo", {226, 128, 158, 0} -"becaus", {226, 136, 181, 0} -"because", {226, 136, 181, 0} -"Because", {226, 136, 181, 0} -"bemptyv", {226, 166, 176, 0} -"bepsi", {207, 182, 0} -"bernou", {226, 132, 172, 0} -"Bernoullis", {226, 132, 172, 0} -"Beta", {206, 146, 0} -"beta", {206, 178, 0} -"beth", {226, 132, 182, 0} -"between", {226, 137, 172, 0} -"Bfr", {240, 157, 148, 133} -"bfr", {240, 157, 148, 159} -"bigcap", {226, 139, 130, 0} -"bigcirc", {226, 151, 175, 0} -"bigcup", {226, 139, 131, 0} -"bigodot", {226, 168, 128, 0} -"bigoplus", {226, 168, 129, 0} -"bigotimes", {226, 168, 130, 0} -"bigsqcup", {226, 168, 134, 0} -"bigstar", {226, 152, 133, 0} -"bigtriangledown", {226, 150, 189, 0} -"bigtriangleup", {226, 150, 179, 0} -"biguplus", {226, 168, 132, 0} -"bigvee", {226, 139, 129, 0} -"bigwedge", {226, 139, 128, 0} -"bkarow", {226, 164, 141, 0} -"blacklozenge", {226, 167, 171, 0} -"blacksquare", {226, 150, 170, 0} -"blacktriangle", {226, 150, 180, 0} -"blacktriangledown", {226, 150, 190, 0} -"blacktriangleleft", {226, 151, 130, 0} -"blacktriangleright", {226, 150, 184, 0} -"blank", {226, 144, 163, 0} -"blk12", {226, 150, 146, 0} -"blk14", {226, 150, 145, 0} -"blk34", {226, 150, 147, 0} -"block", {226, 150, 136, 0} -"bne", {61, 0} -"bnequiv", {226, 137, 161, 0} -"bNot", {226, 171, 173, 0} -"bnot", {226, 140, 144, 0} -"Bopf", {240, 157, 148, 185} -"bopf", {240, 157, 149, 147} -"bot", {226, 138, 165, 0} -"bottom", {226, 138, 165, 0} -"bowtie", {226, 139, 136, 0} -"boxbox", {226, 167, 137, 0} -"boxdl", {226, 148, 144, 0} -"boxdL", {226, 149, 149, 0} -"boxDl", {226, 149, 150, 0} -"boxDL", {226, 149, 151, 0} -"boxdr", {226, 148, 140, 0} -"boxdR", {226, 149, 146, 0} -"boxDr", {226, 149, 147, 0} -"boxDR", {226, 149, 148, 0} -"boxh", {226, 148, 128, 0} -"boxH", {226, 149, 144, 0} -"boxhd", {226, 148, 172, 0} -"boxHd", {226, 149, 164, 0} -"boxhD", {226, 149, 165, 0} -"boxHD", {226, 149, 166, 0} -"boxhu", {226, 148, 180, 0} -"boxHu", {226, 149, 167, 0} -"boxhU", {226, 149, 168, 0} -"boxHU", {226, 149, 169, 0} -"boxminus", {226, 138, 159, 0} -"boxplus", {226, 138, 158, 0} -"boxtimes", {226, 138, 160, 0} -"boxul", {226, 148, 152, 0} -"boxuL", {226, 149, 155, 0} -"boxUl", {226, 149, 156, 0} -"boxUL", {226, 149, 157, 0} -"boxur", {226, 148, 148, 0} -"boxuR", {226, 149, 152, 0} -"boxUr", {226, 149, 153, 0} -"boxUR", {226, 149, 154, 0} -"boxv", {226, 148, 130, 0} -"boxV", {226, 149, 145, 0} -"boxvh", {226, 148, 188, 0} -"boxvH", {226, 149, 170, 0} -"boxVh", {226, 149, 171, 0} -"boxVH", {226, 149, 172, 0} -"boxvl", {226, 148, 164, 0} -"boxvL", {226, 149, 161, 0} -"boxVl", {226, 149, 162, 0} -"boxVL", {226, 149, 163, 0} -"boxvr", {226, 148, 156, 0} -"boxvR", {226, 149, 158, 0} -"boxVr", {226, 149, 159, 0} -"boxVR", {226, 149, 160, 0} -"bprime", {226, 128, 181, 0} -"breve", {203, 152, 0} -"Breve", {203, 152, 0} -"brvbar", {194, 166, 0} -"bscr", {240, 157, 146, 183} -"Bscr", {226, 132, 172, 0} -"bsemi", {226, 129, 143, 0} -"bsim", {226, 136, 189, 0} -"bsime", {226, 139, 141, 0} -"bsolb", {226, 167, 133, 0} -"bsol", {92, 0} -"bsolhsub", {226, 159, 136, 0} -"bull", {226, 128, 162, 0} -"bullet", {226, 128, 162, 0} -"bump", {226, 137, 142, 0} -"bumpE", {226, 170, 174, 0} -"bumpe", {226, 137, 143, 0} -"Bumpeq", {226, 137, 142, 0} -"bumpeq", {226, 137, 143, 0} -"Cacute", {196, 134, 0} -"cacute", {196, 135, 0} -"capand", {226, 169, 132, 0} -"capbrcup", {226, 169, 137, 0} -"capcap", {226, 169, 139, 0} -"cap", {226, 136, 169, 0} -"Cap", {226, 139, 146, 0} -"capcup", {226, 169, 135, 0} -"capdot", {226, 169, 128, 0} -"CapitalDifferentialD", {226, 133, 133, 0} -"caps", {226, 136, 169, 0} -"caret", {226, 129, 129, 0} -"caron", {203, 135, 0} -"Cayleys", {226, 132, 173, 0} -"ccaps", {226, 169, 141, 0} -"Ccaron", {196, 140, 0} -"ccaron", {196, 141, 0} -"Ccedil", {195, 135, 0} -"ccedil", {195, 167, 0} -"Ccirc", {196, 136, 0} -"ccirc", {196, 137, 0} -"Cconint", {226, 136, 176, 0} -"ccups", {226, 169, 140, 0} -"ccupssm", {226, 169, 144, 0} -"Cdot", {196, 138, 0} -"cdot", {196, 139, 0} -"cedil", {194, 184, 0} -"Cedilla", {194, 184, 0} -"cemptyv", {226, 166, 178, 0} -"cent", {194, 162, 0} -"centerdot", {194, 183, 0} -"CenterDot", {194, 183, 0} -"cfr", {240, 157, 148, 160} -"Cfr", {226, 132, 173, 0} -"CHcy", {208, 167, 0} -"chcy", {209, 135, 0} -"check", {226, 156, 147, 0} -"checkmark", {226, 156, 147, 0} -"Chi", {206, 167, 0} -"chi", {207, 135, 0} -"circ", {203, 134, 0} -"circeq", {226, 137, 151, 0} -"circlearrowleft", {226, 134, 186, 0} -"circlearrowright", {226, 134, 187, 0} -"circledast", {226, 138, 155, 0} -"circledcirc", {226, 138, 154, 0} -"circleddash", {226, 138, 157, 0} -"CircleDot", {226, 138, 153, 0} -"circledR", {194, 174, 0} -"circledS", {226, 147, 136, 0} -"CircleMinus", {226, 138, 150, 0} -"CirclePlus", {226, 138, 149, 0} -"CircleTimes", {226, 138, 151, 0} -"cir", {226, 151, 139, 0} -"cirE", {226, 167, 131, 0} -"cire", {226, 137, 151, 0} -"cirfnint", {226, 168, 144, 0} -"cirmid", {226, 171, 175, 0} -"cirscir", {226, 167, 130, 0} -"ClockwiseContourIntegral", {226, 136, 178, 0} -"CloseCurlyDoubleQuote", {226, 128, 157, 0} -"CloseCurlyQuote", {226, 128, 153, 0} -"clubs", {226, 153, 163, 0} -"clubsuit", {226, 153, 163, 0} -"colon", {58, 0} -"Colon", {226, 136, 183, 0} -"Colone", {226, 169, 180, 0} -"colone", {226, 137, 148, 0} -"coloneq", {226, 137, 148, 0} -"comma", {44, 0} -"commat", {64, 0} -"comp", {226, 136, 129, 0} -"compfn", {226, 136, 152, 0} -"complement", {226, 136, 129, 0} -"complexes", {226, 132, 130, 0} -"cong", {226, 137, 133, 0} -"congdot", {226, 169, 173, 0} -"Congruent", {226, 137, 161, 0} -"conint", {226, 136, 174, 0} -"Conint", {226, 136, 175, 0} -"ContourIntegral", {226, 136, 174, 0} -"copf", {240, 157, 149, 148} -"Copf", {226, 132, 130, 0} -"coprod", {226, 136, 144, 0} -"Coproduct", {226, 136, 144, 0} -"copy", {194, 169, 0} -"COPY", {194, 169, 0} -"copysr", {226, 132, 151, 0} -"CounterClockwiseContourIntegral", {226, 136, 179, 0} -"crarr", {226, 134, 181, 0} -"cross", {226, 156, 151, 0} -"Cross", {226, 168, 175, 0} -"Cscr", {240, 157, 146, 158} -"cscr", {240, 157, 146, 184} -"csub", {226, 171, 143, 0} -"csube", {226, 171, 145, 0} -"csup", {226, 171, 144, 0} -"csupe", {226, 171, 146, 0} -"ctdot", {226, 139, 175, 0} -"cudarrl", {226, 164, 184, 0} -"cudarrr", {226, 164, 181, 0} -"cuepr", {226, 139, 158, 0} -"cuesc", {226, 139, 159, 0} -"cularr", {226, 134, 182, 0} -"cularrp", {226, 164, 189, 0} -"cupbrcap", {226, 169, 136, 0} -"cupcap", {226, 169, 134, 0} -"CupCap", {226, 137, 141, 0} -"cup", {226, 136, 170, 0} -"Cup", {226, 139, 147, 0} -"cupcup", {226, 169, 138, 0} -"cupdot", {226, 138, 141, 0} -"cupor", {226, 169, 133, 0} -"cups", {226, 136, 170, 0} -"curarr", {226, 134, 183, 0} -"curarrm", {226, 164, 188, 0} -"curlyeqprec", {226, 139, 158, 0} -"curlyeqsucc", {226, 139, 159, 0} -"curlyvee", {226, 139, 142, 0} -"curlywedge", {226, 139, 143, 0} -"curren", {194, 164, 0} -"curvearrowleft", {226, 134, 182, 0} -"curvearrowright", {226, 134, 183, 0} -"cuvee", {226, 139, 142, 0} -"cuwed", {226, 139, 143, 0} -"cwconint", {226, 136, 178, 0} -"cwint", {226, 136, 177, 0} -"cylcty", {226, 140, 173, 0} -"dagger", {226, 128, 160, 0} -"Dagger", {226, 128, 161, 0} -"daleth", {226, 132, 184, 0} -"darr", {226, 134, 147, 0} -"Darr", {226, 134, 161, 0} -"dArr", {226, 135, 147, 0} -"dash", {226, 128, 144, 0} -"Dashv", {226, 171, 164, 0} -"dashv", {226, 138, 163, 0} -"dbkarow", {226, 164, 143, 0} -"dblac", {203, 157, 0} -"Dcaron", {196, 142, 0} -"dcaron", {196, 143, 0} -"Dcy", {208, 148, 0} -"dcy", {208, 180, 0} -"ddagger", {226, 128, 161, 0} -"ddarr", {226, 135, 138, 0} -"DD", {226, 133, 133, 0} -"dd", {226, 133, 134, 0} -"DDotrahd", {226, 164, 145, 0} -"ddotseq", {226, 169, 183, 0} -"deg", {194, 176, 0} -"Del", {226, 136, 135, 0} -"Delta", {206, 148, 0} -"delta", {206, 180, 0} -"demptyv", {226, 166, 177, 0} -"dfisht", {226, 165, 191, 0} -"Dfr", {240, 157, 148, 135} -"dfr", {240, 157, 148, 161} -"dHar", {226, 165, 165, 0} -"dharl", {226, 135, 131, 0} -"dharr", {226, 135, 130, 0} -"DiacriticalAcute", {194, 180, 0} -"DiacriticalDot", {203, 153, 0} -"DiacriticalDoubleAcute", {203, 157, 0} -"DiacriticalGrave", {96, 0} -"DiacriticalTilde", {203, 156, 0} -"diam", {226, 139, 132, 0} -"diamond", {226, 139, 132, 0} -"Diamond", {226, 139, 132, 0} -"diamondsuit", {226, 153, 166, 0} -"diams", {226, 153, 166, 0} -"die", {194, 168, 0} -"DifferentialD", {226, 133, 134, 0} -"digamma", {207, 157, 0} -"disin", {226, 139, 178, 0} -"div", {195, 183, 0} -"divide", {195, 183, 0} -"divideontimes", {226, 139, 135, 0} -"divonx", {226, 139, 135, 0} -"DJcy", {208, 130, 0} -"djcy", {209, 146, 0} -"dlcorn", {226, 140, 158, 0} -"dlcrop", {226, 140, 141, 0} -"dollar", {36, 0} -"Dopf", {240, 157, 148, 187} -"dopf", {240, 157, 149, 149} -"Dot", {194, 168, 0} -"dot", {203, 153, 0} -"DotDot", {226, 131, 156, 0} -"doteq", {226, 137, 144, 0} -"doteqdot", {226, 137, 145, 0} -"DotEqual", {226, 137, 144, 0} -"dotminus", {226, 136, 184, 0} -"dotplus", {226, 136, 148, 0} -"dotsquare", {226, 138, 161, 0} -"doublebarwedge", {226, 140, 134, 0} -"DoubleContourIntegral", {226, 136, 175, 0} -"DoubleDot", {194, 168, 0} -"DoubleDownArrow", {226, 135, 147, 0} -"DoubleLeftArrow", {226, 135, 144, 0} -"DoubleLeftRightArrow", {226, 135, 148, 0} -"DoubleLeftTee", {226, 171, 164, 0} -"DoubleLongLeftArrow", {226, 159, 184, 0} -"DoubleLongLeftRightArrow", {226, 159, 186, 0} -"DoubleLongRightArrow", {226, 159, 185, 0} -"DoubleRightArrow", {226, 135, 146, 0} -"DoubleRightTee", {226, 138, 168, 0} -"DoubleUpArrow", {226, 135, 145, 0} -"DoubleUpDownArrow", {226, 135, 149, 0} -"DoubleVerticalBar", {226, 136, 165, 0} -"DownArrowBar", {226, 164, 147, 0} -"downarrow", {226, 134, 147, 0} -"DownArrow", {226, 134, 147, 0} -"Downarrow", {226, 135, 147, 0} -"DownArrowUpArrow", {226, 135, 181, 0} -"DownBreve", {204, 145, 0} -"downdownarrows", {226, 135, 138, 0} -"downharpoonleft", {226, 135, 131, 0} -"downharpoonright", {226, 135, 130, 0} -"DownLeftRightVector", {226, 165, 144, 0} -"DownLeftTeeVector", {226, 165, 158, 0} -"DownLeftVectorBar", {226, 165, 150, 0} -"DownLeftVector", {226, 134, 189, 0} -"DownRightTeeVector", {226, 165, 159, 0} -"DownRightVectorBar", {226, 165, 151, 0} -"DownRightVector", {226, 135, 129, 0} -"DownTeeArrow", {226, 134, 167, 0} -"DownTee", {226, 138, 164, 0} -"drbkarow", {226, 164, 144, 0} -"drcorn", {226, 140, 159, 0} -"drcrop", {226, 140, 140, 0} -"Dscr", {240, 157, 146, 159} -"dscr", {240, 157, 146, 185} -"DScy", {208, 133, 0} -"dscy", {209, 149, 0} -"dsol", {226, 167, 182, 0} -"Dstrok", {196, 144, 0} -"dstrok", {196, 145, 0} -"dtdot", {226, 139, 177, 0} -"dtri", {226, 150, 191, 0} -"dtrif", {226, 150, 190, 0} -"duarr", {226, 135, 181, 0} -"duhar", {226, 165, 175, 0} -"dwangle", {226, 166, 166, 0} -"DZcy", {208, 143, 0} -"dzcy", {209, 159, 0} -"dzigrarr", {226, 159, 191, 0} -"Eacute", {195, 137, 0} -"eacute", {195, 169, 0} -"easter", {226, 169, 174, 0} -"Ecaron", {196, 154, 0} -"ecaron", {196, 155, 0} -"Ecirc", {195, 138, 0} -"ecirc", {195, 170, 0} -"ecir", {226, 137, 150, 0} -"ecolon", {226, 137, 149, 0} -"Ecy", {208, 173, 0} -"ecy", {209, 141, 0} -"eDDot", {226, 169, 183, 0} -"Edot", {196, 150, 0} -"edot", {196, 151, 0} -"eDot", {226, 137, 145, 0} -"ee", {226, 133, 135, 0} -"efDot", {226, 137, 146, 0} -"Efr", {240, 157, 148, 136} -"efr", {240, 157, 148, 162} -"eg", {226, 170, 154, 0} -"Egrave", {195, 136, 0} -"egrave", {195, 168, 0} -"egs", {226, 170, 150, 0} -"egsdot", {226, 170, 152, 0} -"el", {226, 170, 153, 0} -"Element", {226, 136, 136, 0} -"elinters", {226, 143, 167, 0} -"ell", {226, 132, 147, 0} -"els", {226, 170, 149, 0} -"elsdot", {226, 170, 151, 0} -"Emacr", {196, 146, 0} -"emacr", {196, 147, 0} -"empty", {226, 136, 133, 0} -"emptyset", {226, 136, 133, 0} -"EmptySmallSquare", {226, 151, 187, 0} -"emptyv", {226, 136, 133, 0} -"EmptyVerySmallSquare", {226, 150, 171, 0} -"emsp13", {226, 128, 132, 0} -"emsp14", {226, 128, 133, 0} -"emsp", {226, 128, 131, 0} -"ENG", {197, 138, 0} -"eng", {197, 139, 0} -"ensp", {226, 128, 130, 0} -"Eogon", {196, 152, 0} -"eogon", {196, 153, 0} -"Eopf", {240, 157, 148, 188} -"eopf", {240, 157, 149, 150} -"epar", {226, 139, 149, 0} -"eparsl", {226, 167, 163, 0} -"eplus", {226, 169, 177, 0} -"epsi", {206, 181, 0} -"Epsilon", {206, 149, 0} -"epsilon", {206, 181, 0} -"epsiv", {207, 181, 0} -"eqcirc", {226, 137, 150, 0} -"eqcolon", {226, 137, 149, 0} -"eqsim", {226, 137, 130, 0} -"eqslantgtr", {226, 170, 150, 0} -"eqslantless", {226, 170, 149, 0} -"Equal", {226, 169, 181, 0} -"equals", {61, 0} -"EqualTilde", {226, 137, 130, 0} -"equest", {226, 137, 159, 0} -"Equilibrium", {226, 135, 140, 0} -"equiv", {226, 137, 161, 0} -"equivDD", {226, 169, 184, 0} -"eqvparsl", {226, 167, 165, 0} -"erarr", {226, 165, 177, 0} -"erDot", {226, 137, 147, 0} -"escr", {226, 132, 175, 0} -"Escr", {226, 132, 176, 0} -"esdot", {226, 137, 144, 0} -"Esim", {226, 169, 179, 0} -"esim", {226, 137, 130, 0} -"Eta", {206, 151, 0} -"eta", {206, 183, 0} -"ETH", {195, 144, 0} -"eth", {195, 176, 0} -"Euml", {195, 139, 0} -"euml", {195, 171, 0} -"euro", {226, 130, 172, 0} -"excl", {33, 0} -"exist", {226, 136, 131, 0} -"Exists", {226, 136, 131, 0} -"expectation", {226, 132, 176, 0} -"exponentiale", {226, 133, 135, 0} -"ExponentialE", {226, 133, 135, 0} -"fallingdotseq", {226, 137, 146, 0} -"Fcy", {208, 164, 0} -"fcy", {209, 132, 0} -"female", {226, 153, 128, 0} -"ffilig", {239, 172, 131, 0} -"fflig", {239, 172, 128, 0} -"ffllig", {239, 172, 132, 0} -"Ffr", {240, 157, 148, 137} -"ffr", {240, 157, 148, 163} -"filig", {239, 172, 129, 0} -"FilledSmallSquare", {226, 151, 188, 0} -"FilledVerySmallSquare", {226, 150, 170, 0} -"fjlig", {102, 0} -"flat", {226, 153, 173, 0} -"fllig", {239, 172, 130, 0} -"fltns", {226, 150, 177, 0} -"fnof", {198, 146, 0} -"Fopf", {240, 157, 148, 189} -"fopf", {240, 157, 149, 151} -"forall", {226, 136, 128, 0} -"ForAll", {226, 136, 128, 0} -"fork", {226, 139, 148, 0} -"forkv", {226, 171, 153, 0} -"Fouriertrf", {226, 132, 177, 0} -"fpartint", {226, 168, 141, 0} -"frac12", {194, 189, 0} -"frac13", {226, 133, 147, 0} -"frac14", {194, 188, 0} -"frac15", {226, 133, 149, 0} -"frac16", {226, 133, 153, 0} -"frac18", {226, 133, 155, 0} -"frac23", {226, 133, 148, 0} -"frac25", {226, 133, 150, 0} -"frac34", {194, 190, 0} -"frac35", {226, 133, 151, 0} -"frac38", {226, 133, 156, 0} -"frac45", {226, 133, 152, 0} -"frac56", {226, 133, 154, 0} -"frac58", {226, 133, 157, 0} -"frac78", {226, 133, 158, 0} -"frasl", {226, 129, 132, 0} -"frown", {226, 140, 162, 0} -"fscr", {240, 157, 146, 187} -"Fscr", {226, 132, 177, 0} -"gacute", {199, 181, 0} -"Gamma", {206, 147, 0} -"gamma", {206, 179, 0} -"Gammad", {207, 156, 0} -"gammad", {207, 157, 0} -"gap", {226, 170, 134, 0} -"Gbreve", {196, 158, 0} -"gbreve", {196, 159, 0} -"Gcedil", {196, 162, 0} -"Gcirc", {196, 156, 0} -"gcirc", {196, 157, 0} -"Gcy", {208, 147, 0} -"gcy", {208, 179, 0} -"Gdot", {196, 160, 0} -"gdot", {196, 161, 0} -"ge", {226, 137, 165, 0} -"gE", {226, 137, 167, 0} -"gEl", {226, 170, 140, 0} -"gel", {226, 139, 155, 0} -"geq", {226, 137, 165, 0} -"geqq", {226, 137, 167, 0} -"geqslant", {226, 169, 190, 0} -"gescc", {226, 170, 169, 0} -"ges", {226, 169, 190, 0} -"gesdot", {226, 170, 128, 0} -"gesdoto", {226, 170, 130, 0} -"gesdotol", {226, 170, 132, 0} -"gesl", {226, 139, 155, 0} -"gesles", {226, 170, 148, 0} -"Gfr", {240, 157, 148, 138} -"gfr", {240, 157, 148, 164} -"gg", {226, 137, 171, 0} -"Gg", {226, 139, 153, 0} -"ggg", {226, 139, 153, 0} -"gimel", {226, 132, 183, 0} -"GJcy", {208, 131, 0} -"gjcy", {209, 147, 0} -"gla", {226, 170, 165, 0} -"gl", {226, 137, 183, 0} -"glE", {226, 170, 146, 0} -"glj", {226, 170, 164, 0} -"gnap", {226, 170, 138, 0} -"gnapprox", {226, 170, 138, 0} -"gne", {226, 170, 136, 0} -"gnE", {226, 137, 169, 0} -"gneq", {226, 170, 136, 0} -"gneqq", {226, 137, 169, 0} -"gnsim", {226, 139, 167, 0} -"Gopf", {240, 157, 148, 190} -"gopf", {240, 157, 149, 152} -"grave", {96, 0} -"GreaterEqual", {226, 137, 165, 0} -"GreaterEqualLess", {226, 139, 155, 0} -"GreaterFullEqual", {226, 137, 167, 0} -"GreaterGreater", {226, 170, 162, 0} -"GreaterLess", {226, 137, 183, 0} -"GreaterSlantEqual", {226, 169, 190, 0} -"GreaterTilde", {226, 137, 179, 0} -"Gscr", {240, 157, 146, 162} -"gscr", {226, 132, 138, 0} -"gsim", {226, 137, 179, 0} -"gsime", {226, 170, 142, 0} -"gsiml", {226, 170, 144, 0} -"gtcc", {226, 170, 167, 0} -"gtcir", {226, 169, 186, 0} -"gt", {62, 0} -"GT", {62, 0} -"Gt", {226, 137, 171, 0} -"gtdot", {226, 139, 151, 0} -"gtlPar", {226, 166, 149, 0} -"gtquest", {226, 169, 188, 0} -"gtrapprox", {226, 170, 134, 0} -"gtrarr", {226, 165, 184, 0} -"gtrdot", {226, 139, 151, 0} -"gtreqless", {226, 139, 155, 0} -"gtreqqless", {226, 170, 140, 0} -"gtrless", {226, 137, 183, 0} -"gtrsim", {226, 137, 179, 0} -"gvertneqq", {226, 137, 169, 0} -"gvnE", {226, 137, 169, 0} -"Hacek", {203, 135, 0} -"hairsp", {226, 128, 138, 0} -"half", {194, 189, 0} -"hamilt", {226, 132, 139, 0} -"HARDcy", {208, 170, 0} -"hardcy", {209, 138, 0} -"harrcir", {226, 165, 136, 0} -"harr", {226, 134, 148, 0} -"hArr", {226, 135, 148, 0} -"harrw", {226, 134, 173, 0} -"Hat", {94, 0} -"hbar", {226, 132, 143, 0} -"Hcirc", {196, 164, 0} -"hcirc", {196, 165, 0} -"hearts", {226, 153, 165, 0} -"heartsuit", {226, 153, 165, 0} -"hellip", {226, 128, 166, 0} -"hercon", {226, 138, 185, 0} -"hfr", {240, 157, 148, 165} -"Hfr", {226, 132, 140, 0} -"HilbertSpace", {226, 132, 139, 0} -"hksearow", {226, 164, 165, 0} -"hkswarow", {226, 164, 166, 0} -"hoarr", {226, 135, 191, 0} -"homtht", {226, 136, 187, 0} -"hookleftarrow", {226, 134, 169, 0} -"hookrightarrow", {226, 134, 170, 0} -"hopf", {240, 157, 149, 153} -"Hopf", {226, 132, 141, 0} -"horbar", {226, 128, 149, 0} -"HorizontalLine", {226, 148, 128, 0} -"hscr", {240, 157, 146, 189} -"Hscr", {226, 132, 139, 0} -"hslash", {226, 132, 143, 0} -"Hstrok", {196, 166, 0} -"hstrok", {196, 167, 0} -"HumpDownHump", {226, 137, 142, 0} -"HumpEqual", {226, 137, 143, 0} -"hybull", {226, 129, 131, 0} -"hyphen", {226, 128, 144, 0} -"Iacute", {195, 141, 0} -"iacute", {195, 173, 0} -"ic", {226, 129, 163, 0} -"Icirc", {195, 142, 0} -"icirc", {195, 174, 0} -"Icy", {208, 152, 0} -"icy", {208, 184, 0} -"Idot", {196, 176, 0} -"IEcy", {208, 149, 0} -"iecy", {208, 181, 0} -"iexcl", {194, 161, 0} -"iff", {226, 135, 148, 0} -"ifr", {240, 157, 148, 166} -"Ifr", {226, 132, 145, 0} -"Igrave", {195, 140, 0} -"igrave", {195, 172, 0} -"ii", {226, 133, 136, 0} -"iiiint", {226, 168, 140, 0} -"iiint", {226, 136, 173, 0} -"iinfin", {226, 167, 156, 0} -"iiota", {226, 132, 169, 0} -"IJlig", {196, 178, 0} -"ijlig", {196, 179, 0} -"Imacr", {196, 170, 0} -"imacr", {196, 171, 0} -"image", {226, 132, 145, 0} -"ImaginaryI", {226, 133, 136, 0} -"imagline", {226, 132, 144, 0} -"imagpart", {226, 132, 145, 0} -"imath", {196, 177, 0} -"Im", {226, 132, 145, 0} -"imof", {226, 138, 183, 0} -"imped", {198, 181, 0} -"Implies", {226, 135, 146, 0} -"incare", {226, 132, 133, 0} -"in", {226, 136, 136, 0} -"infin", {226, 136, 158, 0} -"infintie", {226, 167, 157, 0} -"inodot", {196, 177, 0} -"intcal", {226, 138, 186, 0} -"int", {226, 136, 171, 0} -"Int", {226, 136, 172, 0} -"integers", {226, 132, 164, 0} -"Integral", {226, 136, 171, 0} -"intercal", {226, 138, 186, 0} -"Intersection", {226, 139, 130, 0} -"intlarhk", {226, 168, 151, 0} -"intprod", {226, 168, 188, 0} -"InvisibleComma", {226, 129, 163, 0} -"InvisibleTimes", {226, 129, 162, 0} -"IOcy", {208, 129, 0} -"iocy", {209, 145, 0} -"Iogon", {196, 174, 0} -"iogon", {196, 175, 0} -"Iopf", {240, 157, 149, 128} -"iopf", {240, 157, 149, 154} -"Iota", {206, 153, 0} -"iota", {206, 185, 0} -"iprod", {226, 168, 188, 0} -"iquest", {194, 191, 0} -"iscr", {240, 157, 146, 190} -"Iscr", {226, 132, 144, 0} -"isin", {226, 136, 136, 0} -"isindot", {226, 139, 181, 0} -"isinE", {226, 139, 185, 0} -"isins", {226, 139, 180, 0} -"isinsv", {226, 139, 179, 0} -"isinv", {226, 136, 136, 0} -"it", {226, 129, 162, 0} -"Itilde", {196, 168, 0} -"itilde", {196, 169, 0} -"Iukcy", {208, 134, 0} -"iukcy", {209, 150, 0} -"Iuml", {195, 143, 0} -"iuml", {195, 175, 0} -"Jcirc", {196, 180, 0} -"jcirc", {196, 181, 0} -"Jcy", {208, 153, 0} -"jcy", {208, 185, 0} -"Jfr", {240, 157, 148, 141} -"jfr", {240, 157, 148, 167} -"jmath", {200, 183, 0} -"Jopf", {240, 157, 149, 129} -"jopf", {240, 157, 149, 155} -"Jscr", {240, 157, 146, 165} -"jscr", {240, 157, 146, 191} -"Jsercy", {208, 136, 0} -"jsercy", {209, 152, 0} -"Jukcy", {208, 132, 0} -"jukcy", {209, 148, 0} -"Kappa", {206, 154, 0} -"kappa", {206, 186, 0} -"kappav", {207, 176, 0} -"Kcedil", {196, 182, 0} -"kcedil", {196, 183, 0} -"Kcy", {208, 154, 0} -"kcy", {208, 186, 0} -"Kfr", {240, 157, 148, 142} -"kfr", {240, 157, 148, 168} -"kgreen", {196, 184, 0} -"KHcy", {208, 165, 0} -"khcy", {209, 133, 0} -"KJcy", {208, 140, 0} -"kjcy", {209, 156, 0} -"Kopf", {240, 157, 149, 130} -"kopf", {240, 157, 149, 156} -"Kscr", {240, 157, 146, 166} -"kscr", {240, 157, 147, 128} -"lAarr", {226, 135, 154, 0} -"Lacute", {196, 185, 0} -"lacute", {196, 186, 0} -"laemptyv", {226, 166, 180, 0} -"lagran", {226, 132, 146, 0} -"Lambda", {206, 155, 0} -"lambda", {206, 187, 0} -"lang", {226, 159, 168, 0} -"Lang", {226, 159, 170, 0} -"langd", {226, 166, 145, 0} -"langle", {226, 159, 168, 0} -"lap", {226, 170, 133, 0} -"Laplacetrf", {226, 132, 146, 0} -"laquo", {194, 171, 0} -"larrb", {226, 135, 164, 0} -"larrbfs", {226, 164, 159, 0} -"larr", {226, 134, 144, 0} -"Larr", {226, 134, 158, 0} -"lArr", {226, 135, 144, 0} -"larrfs", {226, 164, 157, 0} -"larrhk", {226, 134, 169, 0} -"larrlp", {226, 134, 171, 0} -"larrpl", {226, 164, 185, 0} -"larrsim", {226, 165, 179, 0} -"larrtl", {226, 134, 162, 0} -"latail", {226, 164, 153, 0} -"lAtail", {226, 164, 155, 0} -"lat", {226, 170, 171, 0} -"late", {226, 170, 173, 0} -"lates", {226, 170, 173, 0} -"lbarr", {226, 164, 140, 0} -"lBarr", {226, 164, 142, 0} -"lbbrk", {226, 157, 178, 0} -"lbrace", {123, 0} -"lbrack", {91, 0} -"lbrke", {226, 166, 139, 0} -"lbrksld", {226, 166, 143, 0} -"lbrkslu", {226, 166, 141, 0} -"Lcaron", {196, 189, 0} -"lcaron", {196, 190, 0} -"Lcedil", {196, 187, 0} -"lcedil", {196, 188, 0} -"lceil", {226, 140, 136, 0} -"lcub", {123, 0} -"Lcy", {208, 155, 0} -"lcy", {208, 187, 0} -"ldca", {226, 164, 182, 0} -"ldquo", {226, 128, 156, 0} -"ldquor", {226, 128, 158, 0} -"ldrdhar", {226, 165, 167, 0} -"ldrushar", {226, 165, 139, 0} -"ldsh", {226, 134, 178, 0} -"le", {226, 137, 164, 0} -"lE", {226, 137, 166, 0} -"LeftAngleBracket", {226, 159, 168, 0} -"LeftArrowBar", {226, 135, 164, 0} -"leftarrow", {226, 134, 144, 0} -"LeftArrow", {226, 134, 144, 0} -"Leftarrow", {226, 135, 144, 0} -"LeftArrowRightArrow", {226, 135, 134, 0} -"leftarrowtail", {226, 134, 162, 0} -"LeftCeiling", {226, 140, 136, 0} -"LeftDoubleBracket", {226, 159, 166, 0} -"LeftDownTeeVector", {226, 165, 161, 0} -"LeftDownVectorBar", {226, 165, 153, 0} -"LeftDownVector", {226, 135, 131, 0} -"LeftFloor", {226, 140, 138, 0} -"leftharpoondown", {226, 134, 189, 0} -"leftharpoonup", {226, 134, 188, 0} -"leftleftarrows", {226, 135, 135, 0} -"leftrightarrow", {226, 134, 148, 0} -"LeftRightArrow", {226, 134, 148, 0} -"Leftrightarrow", {226, 135, 148, 0} -"leftrightarrows", {226, 135, 134, 0} -"leftrightharpoons", {226, 135, 139, 0} -"leftrightsquigarrow", {226, 134, 173, 0} -"LeftRightVector", {226, 165, 142, 0} -"LeftTeeArrow", {226, 134, 164, 0} -"LeftTee", {226, 138, 163, 0} -"LeftTeeVector", {226, 165, 154, 0} -"leftthreetimes", {226, 139, 139, 0} -"LeftTriangleBar", {226, 167, 143, 0} -"LeftTriangle", {226, 138, 178, 0} -"LeftTriangleEqual", {226, 138, 180, 0} -"LeftUpDownVector", {226, 165, 145, 0} -"LeftUpTeeVector", {226, 165, 160, 0} -"LeftUpVectorBar", {226, 165, 152, 0} -"LeftUpVector", {226, 134, 191, 0} -"LeftVectorBar", {226, 165, 146, 0} -"LeftVector", {226, 134, 188, 0} -"lEg", {226, 170, 139, 0} -"leg", {226, 139, 154, 0} -"leq", {226, 137, 164, 0} -"leqq", {226, 137, 166, 0} -"leqslant", {226, 169, 189, 0} -"lescc", {226, 170, 168, 0} -"les", {226, 169, 189, 0} -"lesdot", {226, 169, 191, 0} -"lesdoto", {226, 170, 129, 0} -"lesdotor", {226, 170, 131, 0} -"lesg", {226, 139, 154, 0} -"lesges", {226, 170, 147, 0} -"lessapprox", {226, 170, 133, 0} -"lessdot", {226, 139, 150, 0} -"lesseqgtr", {226, 139, 154, 0} -"lesseqqgtr", {226, 170, 139, 0} -"LessEqualGreater", {226, 139, 154, 0} -"LessFullEqual", {226, 137, 166, 0} -"LessGreater", {226, 137, 182, 0} -"lessgtr", {226, 137, 182, 0} -"LessLess", {226, 170, 161, 0} -"lesssim", {226, 137, 178, 0} -"LessSlantEqual", {226, 169, 189, 0} -"LessTilde", {226, 137, 178, 0} -"lfisht", {226, 165, 188, 0} -"lfloor", {226, 140, 138, 0} -"Lfr", {240, 157, 148, 143} -"lfr", {240, 157, 148, 169} -"lg", {226, 137, 182, 0} -"lgE", {226, 170, 145, 0} -"lHar", {226, 165, 162, 0} -"lhard", {226, 134, 189, 0} -"lharu", {226, 134, 188, 0} -"lharul", {226, 165, 170, 0} -"lhblk", {226, 150, 132, 0} -"LJcy", {208, 137, 0} -"ljcy", {209, 153, 0} -"llarr", {226, 135, 135, 0} -"ll", {226, 137, 170, 0} -"Ll", {226, 139, 152, 0} -"llcorner", {226, 140, 158, 0} -"Lleftarrow", {226, 135, 154, 0} -"llhard", {226, 165, 171, 0} -"lltri", {226, 151, 186, 0} -"Lmidot", {196, 191, 0} -"lmidot", {197, 128, 0} -"lmoustache", {226, 142, 176, 0} -"lmoust", {226, 142, 176, 0} -"lnap", {226, 170, 137, 0} -"lnapprox", {226, 170, 137, 0} -"lne", {226, 170, 135, 0} -"lnE", {226, 137, 168, 0} -"lneq", {226, 170, 135, 0} -"lneqq", {226, 137, 168, 0} -"lnsim", {226, 139, 166, 0} -"loang", {226, 159, 172, 0} -"loarr", {226, 135, 189, 0} -"lobrk", {226, 159, 166, 0} -"longleftarrow", {226, 159, 181, 0} -"LongLeftArrow", {226, 159, 181, 0} -"Longleftarrow", {226, 159, 184, 0} -"longleftrightarrow", {226, 159, 183, 0} -"LongLeftRightArrow", {226, 159, 183, 0} -"Longleftrightarrow", {226, 159, 186, 0} -"longmapsto", {226, 159, 188, 0} -"longrightarrow", {226, 159, 182, 0} -"LongRightArrow", {226, 159, 182, 0} -"Longrightarrow", {226, 159, 185, 0} -"looparrowleft", {226, 134, 171, 0} -"looparrowright", {226, 134, 172, 0} -"lopar", {226, 166, 133, 0} -"Lopf", {240, 157, 149, 131} -"lopf", {240, 157, 149, 157} -"loplus", {226, 168, 173, 0} -"lotimes", {226, 168, 180, 0} -"lowast", {226, 136, 151, 0} -"lowbar", {95, 0} -"LowerLeftArrow", {226, 134, 153, 0} -"LowerRightArrow", {226, 134, 152, 0} -"loz", {226, 151, 138, 0} -"lozenge", {226, 151, 138, 0} -"lozf", {226, 167, 171, 0} -"lpar", {40, 0} -"lparlt", {226, 166, 147, 0} -"lrarr", {226, 135, 134, 0} -"lrcorner", {226, 140, 159, 0} -"lrhar", {226, 135, 139, 0} -"lrhard", {226, 165, 173, 0} -"lrm", {226, 128, 142, 0} -"lrtri", {226, 138, 191, 0} -"lsaquo", {226, 128, 185, 0} -"lscr", {240, 157, 147, 129} -"Lscr", {226, 132, 146, 0} -"lsh", {226, 134, 176, 0} -"Lsh", {226, 134, 176, 0} -"lsim", {226, 137, 178, 0} -"lsime", {226, 170, 141, 0} -"lsimg", {226, 170, 143, 0} -"lsqb", {91, 0} -"lsquo", {226, 128, 152, 0} -"lsquor", {226, 128, 154, 0} -"Lstrok", {197, 129, 0} -"lstrok", {197, 130, 0} -"ltcc", {226, 170, 166, 0} -"ltcir", {226, 169, 185, 0} -"lt", {60, 0} -"LT", {60, 0} -"Lt", {226, 137, 170, 0} -"ltdot", {226, 139, 150, 0} -"lthree", {226, 139, 139, 0} -"ltimes", {226, 139, 137, 0} -"ltlarr", {226, 165, 182, 0} -"ltquest", {226, 169, 187, 0} -"ltri", {226, 151, 131, 0} -"ltrie", {226, 138, 180, 0} -"ltrif", {226, 151, 130, 0} -"ltrPar", {226, 166, 150, 0} -"lurdshar", {226, 165, 138, 0} -"luruhar", {226, 165, 166, 0} -"lvertneqq", {226, 137, 168, 0} -"lvnE", {226, 137, 168, 0} -"macr", {194, 175, 0} -"male", {226, 153, 130, 0} -"malt", {226, 156, 160, 0} -"maltese", {226, 156, 160, 0} -"Map", {226, 164, 133, 0} -"map", {226, 134, 166, 0} -"mapsto", {226, 134, 166, 0} -"mapstodown", {226, 134, 167, 0} -"mapstoleft", {226, 134, 164, 0} -"mapstoup", {226, 134, 165, 0} -"marker", {226, 150, 174, 0} -"mcomma", {226, 168, 169, 0} -"Mcy", {208, 156, 0} -"mcy", {208, 188, 0} -"mdash", {226, 128, 148, 0} -"mDDot", {226, 136, 186, 0} -"measuredangle", {226, 136, 161, 0} -"MediumSpace", {226, 129, 159, 0} -"Mellintrf", {226, 132, 179, 0} -"Mfr", {240, 157, 148, 144} -"mfr", {240, 157, 148, 170} -"mho", {226, 132, 167, 0} -"micro", {194, 181, 0} -"midast", {42, 0} -"midcir", {226, 171, 176, 0} -"mid", {226, 136, 163, 0} -"middot", {194, 183, 0} -"minusb", {226, 138, 159, 0} -"minus", {226, 136, 146, 0} -"minusd", {226, 136, 184, 0} -"minusdu", {226, 168, 170, 0} -"MinusPlus", {226, 136, 147, 0} -"mlcp", {226, 171, 155, 0} -"mldr", {226, 128, 166, 0} -"mnplus", {226, 136, 147, 0} -"models", {226, 138, 167, 0} -"Mopf", {240, 157, 149, 132} -"mopf", {240, 157, 149, 158} -"mp", {226, 136, 147, 0} -"mscr", {240, 157, 147, 130} -"Mscr", {226, 132, 179, 0} -"mstpos", {226, 136, 190, 0} -"Mu", {206, 156, 0} -"mu", {206, 188, 0} -"multimap", {226, 138, 184, 0} -"mumap", {226, 138, 184, 0} -"nabla", {226, 136, 135, 0} -"Nacute", {197, 131, 0} -"nacute", {197, 132, 0} -"nang", {226, 136, 160, 0} -"nap", {226, 137, 137, 0} -"napE", {226, 169, 176, 0} -"napid", {226, 137, 139, 0} -"napos", {197, 137, 0} -"napprox", {226, 137, 137, 0} -"natural", {226, 153, 174, 0} -"naturals", {226, 132, 149, 0} -"natur", {226, 153, 174, 0} -"nbsp", {194, 160, 0} -"nbump", {226, 137, 142, 0} -"nbumpe", {226, 137, 143, 0} -"ncap", {226, 169, 131, 0} -"Ncaron", {197, 135, 0} -"ncaron", {197, 136, 0} -"Ncedil", {197, 133, 0} -"ncedil", {197, 134, 0} -"ncong", {226, 137, 135, 0} -"ncongdot", {226, 169, 173, 0} -"ncup", {226, 169, 130, 0} -"Ncy", {208, 157, 0} -"ncy", {208, 189, 0} -"ndash", {226, 128, 147, 0} -"nearhk", {226, 164, 164, 0} -"nearr", {226, 134, 151, 0} -"neArr", {226, 135, 151, 0} -"nearrow", {226, 134, 151, 0} -"ne", {226, 137, 160, 0} -"nedot", {226, 137, 144, 0} -"NegativeMediumSpace", {226, 128, 139, 0} -"NegativeThickSpace", {226, 128, 139, 0} -"NegativeThinSpace", {226, 128, 139, 0} -"NegativeVeryThinSpace", {226, 128, 139, 0} -"nequiv", {226, 137, 162, 0} -"nesear", {226, 164, 168, 0} -"nesim", {226, 137, 130, 0} -"NestedGreaterGreater", {226, 137, 171, 0} -"NestedLessLess", {226, 137, 170, 0} -"NewLine", {10, 0} -"nexist", {226, 136, 132, 0} -"nexists", {226, 136, 132, 0} -"Nfr", {240, 157, 148, 145} -"nfr", {240, 157, 148, 171} -"ngE", {226, 137, 167, 0} -"nge", {226, 137, 177, 0} -"ngeq", {226, 137, 177, 0} -"ngeqq", {226, 137, 167, 0} -"ngeqslant", {226, 169, 190, 0} -"nges", {226, 169, 190, 0} -"nGg", {226, 139, 153, 0} -"ngsim", {226, 137, 181, 0} -"nGt", {226, 137, 171, 0} -"ngt", {226, 137, 175, 0} -"ngtr", {226, 137, 175, 0} -"nGtv", {226, 137, 171, 0} -"nharr", {226, 134, 174, 0} -"nhArr", {226, 135, 142, 0} -"nhpar", {226, 171, 178, 0} -"ni", {226, 136, 139, 0} -"nis", {226, 139, 188, 0} -"nisd", {226, 139, 186, 0} -"niv", {226, 136, 139, 0} -"NJcy", {208, 138, 0} -"njcy", {209, 154, 0} -"nlarr", {226, 134, 154, 0} -"nlArr", {226, 135, 141, 0} -"nldr", {226, 128, 165, 0} -"nlE", {226, 137, 166, 0} -"nle", {226, 137, 176, 0} -"nleftarrow", {226, 134, 154, 0} -"nLeftarrow", {226, 135, 141, 0} -"nleftrightarrow", {226, 134, 174, 0} -"nLeftrightarrow", {226, 135, 142, 0} -"nleq", {226, 137, 176, 0} -"nleqq", {226, 137, 166, 0} -"nleqslant", {226, 169, 189, 0} -"nles", {226, 169, 189, 0} -"nless", {226, 137, 174, 0} -"nLl", {226, 139, 152, 0} -"nlsim", {226, 137, 180, 0} -"nLt", {226, 137, 170, 0} -"nlt", {226, 137, 174, 0} -"nltri", {226, 139, 170, 0} -"nltrie", {226, 139, 172, 0} -"nLtv", {226, 137, 170, 0} -"nmid", {226, 136, 164, 0} -"NoBreak", {226, 129, 160, 0} -"NonBreakingSpace", {194, 160, 0} -"nopf", {240, 157, 149, 159} -"Nopf", {226, 132, 149, 0} -"Not", {226, 171, 172, 0} -"not", {194, 172, 0} -"NotCongruent", {226, 137, 162, 0} -"NotCupCap", {226, 137, 173, 0} -"NotDoubleVerticalBar", {226, 136, 166, 0} -"NotElement", {226, 136, 137, 0} -"NotEqual", {226, 137, 160, 0} -"NotEqualTilde", {226, 137, 130, 0} -"NotExists", {226, 136, 132, 0} -"NotGreater", {226, 137, 175, 0} -"NotGreaterEqual", {226, 137, 177, 0} -"NotGreaterFullEqual", {226, 137, 167, 0} -"NotGreaterGreater", {226, 137, 171, 0} -"NotGreaterLess", {226, 137, 185, 0} -"NotGreaterSlantEqual", {226, 169, 190, 0} -"NotGreaterTilde", {226, 137, 181, 0} -"NotHumpDownHump", {226, 137, 142, 0} -"NotHumpEqual", {226, 137, 143, 0} -"notin", {226, 136, 137, 0} -"notindot", {226, 139, 181, 0} -"notinE", {226, 139, 185, 0} -"notinva", {226, 136, 137, 0} -"notinvb", {226, 139, 183, 0} -"notinvc", {226, 139, 182, 0} -"NotLeftTriangleBar", {226, 167, 143, 0} -"NotLeftTriangle", {226, 139, 170, 0} -"NotLeftTriangleEqual", {226, 139, 172, 0} -"NotLess", {226, 137, 174, 0} -"NotLessEqual", {226, 137, 176, 0} -"NotLessGreater", {226, 137, 184, 0} -"NotLessLess", {226, 137, 170, 0} -"NotLessSlantEqual", {226, 169, 189, 0} -"NotLessTilde", {226, 137, 180, 0} -"NotNestedGreaterGreater", {226, 170, 162, 0} -"NotNestedLessLess", {226, 170, 161, 0} -"notni", {226, 136, 140, 0} -"notniva", {226, 136, 140, 0} -"notnivb", {226, 139, 190, 0} -"notnivc", {226, 139, 189, 0} -"NotPrecedes", {226, 138, 128, 0} -"NotPrecedesEqual", {226, 170, 175, 0} -"NotPrecedesSlantEqual", {226, 139, 160, 0} -"NotReverseElement", {226, 136, 140, 0} -"NotRightTriangleBar", {226, 167, 144, 0} -"NotRightTriangle", {226, 139, 171, 0} -"NotRightTriangleEqual", {226, 139, 173, 0} -"NotSquareSubset", {226, 138, 143, 0} -"NotSquareSubsetEqual", {226, 139, 162, 0} -"NotSquareSuperset", {226, 138, 144, 0} -"NotSquareSupersetEqual", {226, 139, 163, 0} -"NotSubset", {226, 138, 130, 0} -"NotSubsetEqual", {226, 138, 136, 0} -"NotSucceeds", {226, 138, 129, 0} -"NotSucceedsEqual", {226, 170, 176, 0} -"NotSucceedsSlantEqual", {226, 139, 161, 0} -"NotSucceedsTilde", {226, 137, 191, 0} -"NotSuperset", {226, 138, 131, 0} -"NotSupersetEqual", {226, 138, 137, 0} -"NotTilde", {226, 137, 129, 0} -"NotTildeEqual", {226, 137, 132, 0} -"NotTildeFullEqual", {226, 137, 135, 0} -"NotTildeTilde", {226, 137, 137, 0} -"NotVerticalBar", {226, 136, 164, 0} -"nparallel", {226, 136, 166, 0} -"npar", {226, 136, 166, 0} -"nparsl", {226, 171, 189, 0} -"npart", {226, 136, 130, 0} -"npolint", {226, 168, 148, 0} -"npr", {226, 138, 128, 0} -"nprcue", {226, 139, 160, 0} -"nprec", {226, 138, 128, 0} -"npreceq", {226, 170, 175, 0} -"npre", {226, 170, 175, 0} -"nrarrc", {226, 164, 179, 0} -"nrarr", {226, 134, 155, 0} -"nrArr", {226, 135, 143, 0} -"nrarrw", {226, 134, 157, 0} -"nrightarrow", {226, 134, 155, 0} -"nRightarrow", {226, 135, 143, 0} -"nrtri", {226, 139, 171, 0} -"nrtrie", {226, 139, 173, 0} -"nsc", {226, 138, 129, 0} -"nsccue", {226, 139, 161, 0} -"nsce", {226, 170, 176, 0} -"Nscr", {240, 157, 146, 169} -"nscr", {240, 157, 147, 131} -"nshortmid", {226, 136, 164, 0} -"nshortparallel", {226, 136, 166, 0} -"nsim", {226, 137, 129, 0} -"nsime", {226, 137, 132, 0} -"nsimeq", {226, 137, 132, 0} -"nsmid", {226, 136, 164, 0} -"nspar", {226, 136, 166, 0} -"nsqsube", {226, 139, 162, 0} -"nsqsupe", {226, 139, 163, 0} -"nsub", {226, 138, 132, 0} -"nsubE", {226, 171, 133, 0} -"nsube", {226, 138, 136, 0} -"nsubset", {226, 138, 130, 0} -"nsubseteq", {226, 138, 136, 0} -"nsubseteqq", {226, 171, 133, 0} -"nsucc", {226, 138, 129, 0} -"nsucceq", {226, 170, 176, 0} -"nsup", {226, 138, 133, 0} -"nsupE", {226, 171, 134, 0} -"nsupe", {226, 138, 137, 0} -"nsupset", {226, 138, 131, 0} -"nsupseteq", {226, 138, 137, 0} -"nsupseteqq", {226, 171, 134, 0} -"ntgl", {226, 137, 185, 0} -"Ntilde", {195, 145, 0} -"ntilde", {195, 177, 0} -"ntlg", {226, 137, 184, 0} -"ntriangleleft", {226, 139, 170, 0} -"ntrianglelefteq", {226, 139, 172, 0} -"ntriangleright", {226, 139, 171, 0} -"ntrianglerighteq", {226, 139, 173, 0} -"Nu", {206, 157, 0} -"nu", {206, 189, 0} -"num", {35, 0} -"numero", {226, 132, 150, 0} -"numsp", {226, 128, 135, 0} -"nvap", {226, 137, 141, 0} -"nvdash", {226, 138, 172, 0} -"nvDash", {226, 138, 173, 0} -"nVdash", {226, 138, 174, 0} -"nVDash", {226, 138, 175, 0} -"nvge", {226, 137, 165, 0} -"nvgt", {62, 0} -"nvHarr", {226, 164, 132, 0} -"nvinfin", {226, 167, 158, 0} -"nvlArr", {226, 164, 130, 0} -"nvle", {226, 137, 164, 0} -"nvlt", {60, 0} -"nvltrie", {226, 138, 180, 0} -"nvrArr", {226, 164, 131, 0} -"nvrtrie", {226, 138, 181, 0} -"nvsim", {226, 136, 188, 0} -"nwarhk", {226, 164, 163, 0} -"nwarr", {226, 134, 150, 0} -"nwArr", {226, 135, 150, 0} -"nwarrow", {226, 134, 150, 0} -"nwnear", {226, 164, 167, 0} -"Oacute", {195, 147, 0} -"oacute", {195, 179, 0} -"oast", {226, 138, 155, 0} -"Ocirc", {195, 148, 0} -"ocirc", {195, 180, 0} -"ocir", {226, 138, 154, 0} -"Ocy", {208, 158, 0} -"ocy", {208, 190, 0} -"odash", {226, 138, 157, 0} -"Odblac", {197, 144, 0} -"odblac", {197, 145, 0} -"odiv", {226, 168, 184, 0} -"odot", {226, 138, 153, 0} -"odsold", {226, 166, 188, 0} -"OElig", {197, 146, 0} -"oelig", {197, 147, 0} -"ofcir", {226, 166, 191, 0} -"Ofr", {240, 157, 148, 146} -"ofr", {240, 157, 148, 172} -"ogon", {203, 155, 0} -"Ograve", {195, 146, 0} -"ograve", {195, 178, 0} -"ogt", {226, 167, 129, 0} -"ohbar", {226, 166, 181, 0} -"ohm", {206, 169, 0} -"oint", {226, 136, 174, 0} -"olarr", {226, 134, 186, 0} -"olcir", {226, 166, 190, 0} -"olcross", {226, 166, 187, 0} -"oline", {226, 128, 190, 0} -"olt", {226, 167, 128, 0} -"Omacr", {197, 140, 0} -"omacr", {197, 141, 0} -"Omega", {206, 169, 0} -"omega", {207, 137, 0} -"Omicron", {206, 159, 0} -"omicron", {206, 191, 0} -"omid", {226, 166, 182, 0} -"ominus", {226, 138, 150, 0} -"Oopf", {240, 157, 149, 134} -"oopf", {240, 157, 149, 160} -"opar", {226, 166, 183, 0} -"OpenCurlyDoubleQuote", {226, 128, 156, 0} -"OpenCurlyQuote", {226, 128, 152, 0} -"operp", {226, 166, 185, 0} -"oplus", {226, 138, 149, 0} -"orarr", {226, 134, 187, 0} -"Or", {226, 169, 148, 0} -"or", {226, 136, 168, 0} -"ord", {226, 169, 157, 0} -"order", {226, 132, 180, 0} -"orderof", {226, 132, 180, 0} -"ordf", {194, 170, 0} -"ordm", {194, 186, 0} -"origof", {226, 138, 182, 0} -"oror", {226, 169, 150, 0} -"orslope", {226, 169, 151, 0} -"orv", {226, 169, 155, 0} -"oS", {226, 147, 136, 0} -"Oscr", {240, 157, 146, 170} -"oscr", {226, 132, 180, 0} -"Oslash", {195, 152, 0} -"oslash", {195, 184, 0} -"osol", {226, 138, 152, 0} -"Otilde", {195, 149, 0} -"otilde", {195, 181, 0} -"otimesas", {226, 168, 182, 0} -"Otimes", {226, 168, 183, 0} -"otimes", {226, 138, 151, 0} -"Ouml", {195, 150, 0} -"ouml", {195, 182, 0} -"ovbar", {226, 140, 189, 0} -"OverBar", {226, 128, 190, 0} -"OverBrace", {226, 143, 158, 0} -"OverBracket", {226, 142, 180, 0} -"OverParenthesis", {226, 143, 156, 0} -"para", {194, 182, 0} -"parallel", {226, 136, 165, 0} -"par", {226, 136, 165, 0} -"parsim", {226, 171, 179, 0} -"parsl", {226, 171, 189, 0} -"part", {226, 136, 130, 0} -"PartialD", {226, 136, 130, 0} -"Pcy", {208, 159, 0} -"pcy", {208, 191, 0} -"percnt", {37, 0} -"period", {46, 0} -"permil", {226, 128, 176, 0} -"perp", {226, 138, 165, 0} -"pertenk", {226, 128, 177, 0} -"Pfr", {240, 157, 148, 147} -"pfr", {240, 157, 148, 173} -"Phi", {206, 166, 0} -"phi", {207, 134, 0} -"phiv", {207, 149, 0} -"phmmat", {226, 132, 179, 0} -"phone", {226, 152, 142, 0} -"Pi", {206, 160, 0} -"pi", {207, 128, 0} -"pitchfork", {226, 139, 148, 0} -"piv", {207, 150, 0} -"planck", {226, 132, 143, 0} -"planckh", {226, 132, 142, 0} -"plankv", {226, 132, 143, 0} -"plusacir", {226, 168, 163, 0} -"plusb", {226, 138, 158, 0} -"pluscir", {226, 168, 162, 0} -"plus", {43, 0} -"plusdo", {226, 136, 148, 0} -"plusdu", {226, 168, 165, 0} -"pluse", {226, 169, 178, 0} -"PlusMinus", {194, 177, 0} -"plusmn", {194, 177, 0} -"plussim", {226, 168, 166, 0} -"plustwo", {226, 168, 167, 0} -"pm", {194, 177, 0} -"Poincareplane", {226, 132, 140, 0} -"pointint", {226, 168, 149, 0} -"popf", {240, 157, 149, 161} -"Popf", {226, 132, 153, 0} -"pound", {194, 163, 0} -"prap", {226, 170, 183, 0} -"Pr", {226, 170, 187, 0} -"pr", {226, 137, 186, 0} -"prcue", {226, 137, 188, 0} -"precapprox", {226, 170, 183, 0} -"prec", {226, 137, 186, 0} -"preccurlyeq", {226, 137, 188, 0} -"Precedes", {226, 137, 186, 0} -"PrecedesEqual", {226, 170, 175, 0} -"PrecedesSlantEqual", {226, 137, 188, 0} -"PrecedesTilde", {226, 137, 190, 0} -"preceq", {226, 170, 175, 0} -"precnapprox", {226, 170, 185, 0} -"precneqq", {226, 170, 181, 0} -"precnsim", {226, 139, 168, 0} -"pre", {226, 170, 175, 0} -"prE", {226, 170, 179, 0} -"precsim", {226, 137, 190, 0} -"prime", {226, 128, 178, 0} -"Prime", {226, 128, 179, 0} -"primes", {226, 132, 153, 0} -"prnap", {226, 170, 185, 0} -"prnE", {226, 170, 181, 0} -"prnsim", {226, 139, 168, 0} -"prod", {226, 136, 143, 0} -"Product", {226, 136, 143, 0} -"profalar", {226, 140, 174, 0} -"profline", {226, 140, 146, 0} -"profsurf", {226, 140, 147, 0} -"prop", {226, 136, 157, 0} -"Proportional", {226, 136, 157, 0} -"Proportion", {226, 136, 183, 0} -"propto", {226, 136, 157, 0} -"prsim", {226, 137, 190, 0} -"prurel", {226, 138, 176, 0} -"Pscr", {240, 157, 146, 171} -"pscr", {240, 157, 147, 133} -"Psi", {206, 168, 0} -"psi", {207, 136, 0} -"puncsp", {226, 128, 136, 0} -"Qfr", {240, 157, 148, 148} -"qfr", {240, 157, 148, 174} -"qint", {226, 168, 140, 0} -"qopf", {240, 157, 149, 162} -"Qopf", {226, 132, 154, 0} -"qprime", {226, 129, 151, 0} -"Qscr", {240, 157, 146, 172} -"qscr", {240, 157, 147, 134} -"quaternions", {226, 132, 141, 0} -"quatint", {226, 168, 150, 0} -"quest", {63, 0} -"questeq", {226, 137, 159, 0} -"quot", {34, 0} -"QUOT", {34, 0} -"rAarr", {226, 135, 155, 0} -"race", {226, 136, 189, 0} -"Racute", {197, 148, 0} -"racute", {197, 149, 0} -"radic", {226, 136, 154, 0} -"raemptyv", {226, 166, 179, 0} -"rang", {226, 159, 169, 0} -"Rang", {226, 159, 171, 0} -"rangd", {226, 166, 146, 0} -"range", {226, 166, 165, 0} -"rangle", {226, 159, 169, 0} -"raquo", {194, 187, 0} -"rarrap", {226, 165, 181, 0} -"rarrb", {226, 135, 165, 0} -"rarrbfs", {226, 164, 160, 0} -"rarrc", {226, 164, 179, 0} -"rarr", {226, 134, 146, 0} -"Rarr", {226, 134, 160, 0} -"rArr", {226, 135, 146, 0} -"rarrfs", {226, 164, 158, 0} -"rarrhk", {226, 134, 170, 0} -"rarrlp", {226, 134, 172, 0} -"rarrpl", {226, 165, 133, 0} -"rarrsim", {226, 165, 180, 0} -"Rarrtl", {226, 164, 150, 0} -"rarrtl", {226, 134, 163, 0} -"rarrw", {226, 134, 157, 0} -"ratail", {226, 164, 154, 0} -"rAtail", {226, 164, 156, 0} -"ratio", {226, 136, 182, 0} -"rationals", {226, 132, 154, 0} -"rbarr", {226, 164, 141, 0} -"rBarr", {226, 164, 143, 0} -"RBarr", {226, 164, 144, 0} -"rbbrk", {226, 157, 179, 0} -"rbrace", {125, 0} -"rbrack", {93, 0} -"rbrke", {226, 166, 140, 0} -"rbrksld", {226, 166, 142, 0} -"rbrkslu", {226, 166, 144, 0} -"Rcaron", {197, 152, 0} -"rcaron", {197, 153, 0} -"Rcedil", {197, 150, 0} -"rcedil", {197, 151, 0} -"rceil", {226, 140, 137, 0} -"rcub", {125, 0} -"Rcy", {208, 160, 0} -"rcy", {209, 128, 0} -"rdca", {226, 164, 183, 0} -"rdldhar", {226, 165, 169, 0} -"rdquo", {226, 128, 157, 0} -"rdquor", {226, 128, 157, 0} -"rdsh", {226, 134, 179, 0} -"real", {226, 132, 156, 0} -"realine", {226, 132, 155, 0} -"realpart", {226, 132, 156, 0} -"reals", {226, 132, 157, 0} -"Re", {226, 132, 156, 0} -"rect", {226, 150, 173, 0} -"reg", {194, 174, 0} -"REG", {194, 174, 0} -"ReverseElement", {226, 136, 139, 0} -"ReverseEquilibrium", {226, 135, 139, 0} -"ReverseUpEquilibrium", {226, 165, 175, 0} -"rfisht", {226, 165, 189, 0} -"rfloor", {226, 140, 139, 0} -"rfr", {240, 157, 148, 175} -"Rfr", {226, 132, 156, 0} -"rHar", {226, 165, 164, 0} -"rhard", {226, 135, 129, 0} -"rharu", {226, 135, 128, 0} -"rharul", {226, 165, 172, 0} -"Rho", {206, 161, 0} -"rho", {207, 129, 0} -"rhov", {207, 177, 0} -"RightAngleBracket", {226, 159, 169, 0} -"RightArrowBar", {226, 135, 165, 0} -"rightarrow", {226, 134, 146, 0} -"RightArrow", {226, 134, 146, 0} -"Rightarrow", {226, 135, 146, 0} -"RightArrowLeftArrow", {226, 135, 132, 0} -"rightarrowtail", {226, 134, 163, 0} -"RightCeiling", {226, 140, 137, 0} -"RightDoubleBracket", {226, 159, 167, 0} -"RightDownTeeVector", {226, 165, 157, 0} -"RightDownVectorBar", {226, 165, 149, 0} -"RightDownVector", {226, 135, 130, 0} -"RightFloor", {226, 140, 139, 0} -"rightharpoondown", {226, 135, 129, 0} -"rightharpoonup", {226, 135, 128, 0} -"rightleftarrows", {226, 135, 132, 0} -"rightleftharpoons", {226, 135, 140, 0} -"rightrightarrows", {226, 135, 137, 0} -"rightsquigarrow", {226, 134, 157, 0} -"RightTeeArrow", {226, 134, 166, 0} -"RightTee", {226, 138, 162, 0} -"RightTeeVector", {226, 165, 155, 0} -"rightthreetimes", {226, 139, 140, 0} -"RightTriangleBar", {226, 167, 144, 0} -"RightTriangle", {226, 138, 179, 0} -"RightTriangleEqual", {226, 138, 181, 0} -"RightUpDownVector", {226, 165, 143, 0} -"RightUpTeeVector", {226, 165, 156, 0} -"RightUpVectorBar", {226, 165, 148, 0} -"RightUpVector", {226, 134, 190, 0} -"RightVectorBar", {226, 165, 147, 0} -"RightVector", {226, 135, 128, 0} -"ring", {203, 154, 0} -"risingdotseq", {226, 137, 147, 0} -"rlarr", {226, 135, 132, 0} -"rlhar", {226, 135, 140, 0} -"rlm", {226, 128, 143, 0} -"rmoustache", {226, 142, 177, 0} -"rmoust", {226, 142, 177, 0} -"rnmid", {226, 171, 174, 0} -"roang", {226, 159, 173, 0} -"roarr", {226, 135, 190, 0} -"robrk", {226, 159, 167, 0} -"ropar", {226, 166, 134, 0} -"ropf", {240, 157, 149, 163} -"Ropf", {226, 132, 157, 0} -"roplus", {226, 168, 174, 0} -"rotimes", {226, 168, 181, 0} -"RoundImplies", {226, 165, 176, 0} -"rpar", {41, 0} -"rpargt", {226, 166, 148, 0} -"rppolint", {226, 168, 146, 0} -"rrarr", {226, 135, 137, 0} -"Rrightarrow", {226, 135, 155, 0} -"rsaquo", {226, 128, 186, 0} -"rscr", {240, 157, 147, 135} -"Rscr", {226, 132, 155, 0} -"rsh", {226, 134, 177, 0} -"Rsh", {226, 134, 177, 0} -"rsqb", {93, 0} -"rsquo", {226, 128, 153, 0} -"rsquor", {226, 128, 153, 0} -"rthree", {226, 139, 140, 0} -"rtimes", {226, 139, 138, 0} -"rtri", {226, 150, 185, 0} -"rtrie", {226, 138, 181, 0} -"rtrif", {226, 150, 184, 0} -"rtriltri", {226, 167, 142, 0} -"RuleDelayed", {226, 167, 180, 0} -"ruluhar", {226, 165, 168, 0} -"rx", {226, 132, 158, 0} -"Sacute", {197, 154, 0} -"sacute", {197, 155, 0} -"sbquo", {226, 128, 154, 0} -"scap", {226, 170, 184, 0} -"Scaron", {197, 160, 0} -"scaron", {197, 161, 0} -"Sc", {226, 170, 188, 0} -"sc", {226, 137, 187, 0} -"sccue", {226, 137, 189, 0} -"sce", {226, 170, 176, 0} -"scE", {226, 170, 180, 0} -"Scedil", {197, 158, 0} -"scedil", {197, 159, 0} -"Scirc", {197, 156, 0} -"scirc", {197, 157, 0} -"scnap", {226, 170, 186, 0} -"scnE", {226, 170, 182, 0} -"scnsim", {226, 139, 169, 0} -"scpolint", {226, 168, 147, 0} -"scsim", {226, 137, 191, 0} -"Scy", {208, 161, 0} -"scy", {209, 129, 0} -"sdotb", {226, 138, 161, 0} -"sdot", {226, 139, 133, 0} -"sdote", {226, 169, 166, 0} -"searhk", {226, 164, 165, 0} -"searr", {226, 134, 152, 0} -"seArr", {226, 135, 152, 0} -"searrow", {226, 134, 152, 0} -"sect", {194, 167, 0} -"semi", {59, 0} -"seswar", {226, 164, 169, 0} -"setminus", {226, 136, 150, 0} -"setmn", {226, 136, 150, 0} -"sext", {226, 156, 182, 0} -"Sfr", {240, 157, 148, 150} -"sfr", {240, 157, 148, 176} -"sfrown", {226, 140, 162, 0} -"sharp", {226, 153, 175, 0} -"SHCHcy", {208, 169, 0} -"shchcy", {209, 137, 0} -"SHcy", {208, 168, 0} -"shcy", {209, 136, 0} -"ShortDownArrow", {226, 134, 147, 0} -"ShortLeftArrow", {226, 134, 144, 0} -"shortmid", {226, 136, 163, 0} -"shortparallel", {226, 136, 165, 0} -"ShortRightArrow", {226, 134, 146, 0} -"ShortUpArrow", {226, 134, 145, 0} -"shy", {194, 173, 0} -"Sigma", {206, 163, 0} -"sigma", {207, 131, 0} -"sigmaf", {207, 130, 0} -"sigmav", {207, 130, 0} -"sim", {226, 136, 188, 0} -"simdot", {226, 169, 170, 0} -"sime", {226, 137, 131, 0} -"simeq", {226, 137, 131, 0} -"simg", {226, 170, 158, 0} -"simgE", {226, 170, 160, 0} -"siml", {226, 170, 157, 0} -"simlE", {226, 170, 159, 0} -"simne", {226, 137, 134, 0} -"simplus", {226, 168, 164, 0} -"simrarr", {226, 165, 178, 0} -"slarr", {226, 134, 144, 0} -"SmallCircle", {226, 136, 152, 0} -"smallsetminus", {226, 136, 150, 0} -"smashp", {226, 168, 179, 0} -"smeparsl", {226, 167, 164, 0} -"smid", {226, 136, 163, 0} -"smile", {226, 140, 163, 0} -"smt", {226, 170, 170, 0} -"smte", {226, 170, 172, 0} -"smtes", {226, 170, 172, 0} -"SOFTcy", {208, 172, 0} -"softcy", {209, 140, 0} -"solbar", {226, 140, 191, 0} -"solb", {226, 167, 132, 0} -"sol", {47, 0} -"Sopf", {240, 157, 149, 138} -"sopf", {240, 157, 149, 164} -"spades", {226, 153, 160, 0} -"spadesuit", {226, 153, 160, 0} -"spar", {226, 136, 165, 0} -"sqcap", {226, 138, 147, 0} -"sqcaps", {226, 138, 147, 0} -"sqcup", {226, 138, 148, 0} -"sqcups", {226, 138, 148, 0} -"Sqrt", {226, 136, 154, 0} -"sqsub", {226, 138, 143, 0} -"sqsube", {226, 138, 145, 0} -"sqsubset", {226, 138, 143, 0} -"sqsubseteq", {226, 138, 145, 0} -"sqsup", {226, 138, 144, 0} -"sqsupe", {226, 138, 146, 0} -"sqsupset", {226, 138, 144, 0} -"sqsupseteq", {226, 138, 146, 0} -"square", {226, 150, 161, 0} -"Square", {226, 150, 161, 0} -"SquareIntersection", {226, 138, 147, 0} -"SquareSubset", {226, 138, 143, 0} -"SquareSubsetEqual", {226, 138, 145, 0} -"SquareSuperset", {226, 138, 144, 0} -"SquareSupersetEqual", {226, 138, 146, 0} -"SquareUnion", {226, 138, 148, 0} -"squarf", {226, 150, 170, 0} -"squ", {226, 150, 161, 0} -"squf", {226, 150, 170, 0} -"srarr", {226, 134, 146, 0} -"Sscr", {240, 157, 146, 174} -"sscr", {240, 157, 147, 136} -"ssetmn", {226, 136, 150, 0} -"ssmile", {226, 140, 163, 0} -"sstarf", {226, 139, 134, 0} -"Star", {226, 139, 134, 0} -"star", {226, 152, 134, 0} -"starf", {226, 152, 133, 0} -"straightepsilon", {207, 181, 0} -"straightphi", {207, 149, 0} -"strns", {194, 175, 0} -"sub", {226, 138, 130, 0} -"Sub", {226, 139, 144, 0} -"subdot", {226, 170, 189, 0} -"subE", {226, 171, 133, 0} -"sube", {226, 138, 134, 0} -"subedot", {226, 171, 131, 0} -"submult", {226, 171, 129, 0} -"subnE", {226, 171, 139, 0} -"subne", {226, 138, 138, 0} -"subplus", {226, 170, 191, 0} -"subrarr", {226, 165, 185, 0} -"subset", {226, 138, 130, 0} -"Subset", {226, 139, 144, 0} -"subseteq", {226, 138, 134, 0} -"subseteqq", {226, 171, 133, 0} -"SubsetEqual", {226, 138, 134, 0} -"subsetneq", {226, 138, 138, 0} -"subsetneqq", {226, 171, 139, 0} -"subsim", {226, 171, 135, 0} -"subsub", {226, 171, 149, 0} -"subsup", {226, 171, 147, 0} -"succapprox", {226, 170, 184, 0} -"succ", {226, 137, 187, 0} -"succcurlyeq", {226, 137, 189, 0} -"Succeeds", {226, 137, 187, 0} -"SucceedsEqual", {226, 170, 176, 0} -"SucceedsSlantEqual", {226, 137, 189, 0} -"SucceedsTilde", {226, 137, 191, 0} -"succeq", {226, 170, 176, 0} -"succnapprox", {226, 170, 186, 0} -"succneqq", {226, 170, 182, 0} -"succnsim", {226, 139, 169, 0} -"succsim", {226, 137, 191, 0} -"SuchThat", {226, 136, 139, 0} -"sum", {226, 136, 145, 0} -"Sum", {226, 136, 145, 0} -"sung", {226, 153, 170, 0} -"sup1", {194, 185, 0} -"sup2", {194, 178, 0} -"sup3", {194, 179, 0} -"sup", {226, 138, 131, 0} -"Sup", {226, 139, 145, 0} -"supdot", {226, 170, 190, 0} -"supdsub", {226, 171, 152, 0} -"supE", {226, 171, 134, 0} -"supe", {226, 138, 135, 0} -"supedot", {226, 171, 132, 0} -"Superset", {226, 138, 131, 0} -"SupersetEqual", {226, 138, 135, 0} -"suphsol", {226, 159, 137, 0} -"suphsub", {226, 171, 151, 0} -"suplarr", {226, 165, 187, 0} -"supmult", {226, 171, 130, 0} -"supnE", {226, 171, 140, 0} -"supne", {226, 138, 139, 0} -"supplus", {226, 171, 128, 0} -"supset", {226, 138, 131, 0} -"Supset", {226, 139, 145, 0} -"supseteq", {226, 138, 135, 0} -"supseteqq", {226, 171, 134, 0} -"supsetneq", {226, 138, 139, 0} -"supsetneqq", {226, 171, 140, 0} -"supsim", {226, 171, 136, 0} -"supsub", {226, 171, 148, 0} -"supsup", {226, 171, 150, 0} -"swarhk", {226, 164, 166, 0} -"swarr", {226, 134, 153, 0} -"swArr", {226, 135, 153, 0} -"swarrow", {226, 134, 153, 0} -"swnwar", {226, 164, 170, 0} -"szlig", {195, 159, 0} -"Tab", {9, 0} -"target", {226, 140, 150, 0} -"Tau", {206, 164, 0} -"tau", {207, 132, 0} -"tbrk", {226, 142, 180, 0} -"Tcaron", {197, 164, 0} -"tcaron", {197, 165, 0} -"Tcedil", {197, 162, 0} -"tcedil", {197, 163, 0} -"Tcy", {208, 162, 0} -"tcy", {209, 130, 0} -"tdot", {226, 131, 155, 0} -"telrec", {226, 140, 149, 0} -"Tfr", {240, 157, 148, 151} -"tfr", {240, 157, 148, 177} -"there4", {226, 136, 180, 0} -"therefore", {226, 136, 180, 0} -"Therefore", {226, 136, 180, 0} -"Theta", {206, 152, 0} -"theta", {206, 184, 0} -"thetasym", {207, 145, 0} -"thetav", {207, 145, 0} -"thickapprox", {226, 137, 136, 0} -"thicksim", {226, 136, 188, 0} -"ThickSpace", {226, 129, 159, 0} -"ThinSpace", {226, 128, 137, 0} -"thinsp", {226, 128, 137, 0} -"thkap", {226, 137, 136, 0} -"thksim", {226, 136, 188, 0} -"THORN", {195, 158, 0} -"thorn", {195, 190, 0} -"tilde", {203, 156, 0} -"Tilde", {226, 136, 188, 0} -"TildeEqual", {226, 137, 131, 0} -"TildeFullEqual", {226, 137, 133, 0} -"TildeTilde", {226, 137, 136, 0} -"timesbar", {226, 168, 177, 0} -"timesb", {226, 138, 160, 0} -"times", {195, 151, 0} -"timesd", {226, 168, 176, 0} -"tint", {226, 136, 173, 0} -"toea", {226, 164, 168, 0} -"topbot", {226, 140, 182, 0} -"topcir", {226, 171, 177, 0} -"top", {226, 138, 164, 0} -"Topf", {240, 157, 149, 139} -"topf", {240, 157, 149, 165} -"topfork", {226, 171, 154, 0} -"tosa", {226, 164, 169, 0} -"tprime", {226, 128, 180, 0} -"trade", {226, 132, 162, 0} -"TRADE", {226, 132, 162, 0} -"triangle", {226, 150, 181, 0} -"triangledown", {226, 150, 191, 0} -"triangleleft", {226, 151, 131, 0} -"trianglelefteq", {226, 138, 180, 0} -"triangleq", {226, 137, 156, 0} -"triangleright", {226, 150, 185, 0} -"trianglerighteq", {226, 138, 181, 0} -"tridot", {226, 151, 172, 0} -"trie", {226, 137, 156, 0} -"triminus", {226, 168, 186, 0} -"TripleDot", {226, 131, 155, 0} -"triplus", {226, 168, 185, 0} -"trisb", {226, 167, 141, 0} -"tritime", {226, 168, 187, 0} -"trpezium", {226, 143, 162, 0} -"Tscr", {240, 157, 146, 175} -"tscr", {240, 157, 147, 137} -"TScy", {208, 166, 0} -"tscy", {209, 134, 0} -"TSHcy", {208, 139, 0} -"tshcy", {209, 155, 0} -"Tstrok", {197, 166, 0} -"tstrok", {197, 167, 0} -"twixt", {226, 137, 172, 0} -"twoheadleftarrow", {226, 134, 158, 0} -"twoheadrightarrow", {226, 134, 160, 0} -"Uacute", {195, 154, 0} -"uacute", {195, 186, 0} -"uarr", {226, 134, 145, 0} -"Uarr", {226, 134, 159, 0} -"uArr", {226, 135, 145, 0} -"Uarrocir", {226, 165, 137, 0} -"Ubrcy", {208, 142, 0} -"ubrcy", {209, 158, 0} -"Ubreve", {197, 172, 0} -"ubreve", {197, 173, 0} -"Ucirc", {195, 155, 0} -"ucirc", {195, 187, 0} -"Ucy", {208, 163, 0} -"ucy", {209, 131, 0} -"udarr", {226, 135, 133, 0} -"Udblac", {197, 176, 0} -"udblac", {197, 177, 0} -"udhar", {226, 165, 174, 0} -"ufisht", {226, 165, 190, 0} -"Ufr", {240, 157, 148, 152} -"ufr", {240, 157, 148, 178} -"Ugrave", {195, 153, 0} -"ugrave", {195, 185, 0} -"uHar", {226, 165, 163, 0} -"uharl", {226, 134, 191, 0} -"uharr", {226, 134, 190, 0} -"uhblk", {226, 150, 128, 0} -"ulcorn", {226, 140, 156, 0} -"ulcorner", {226, 140, 156, 0} -"ulcrop", {226, 140, 143, 0} -"ultri", {226, 151, 184, 0} -"Umacr", {197, 170, 0} -"umacr", {197, 171, 0} -"uml", {194, 168, 0} -"UnderBar", {95, 0} -"UnderBrace", {226, 143, 159, 0} -"UnderBracket", {226, 142, 181, 0} -"UnderParenthesis", {226, 143, 157, 0} -"Union", {226, 139, 131, 0} -"UnionPlus", {226, 138, 142, 0} -"Uogon", {197, 178, 0} -"uogon", {197, 179, 0} -"Uopf", {240, 157, 149, 140} -"uopf", {240, 157, 149, 166} -"UpArrowBar", {226, 164, 146, 0} -"uparrow", {226, 134, 145, 0} -"UpArrow", {226, 134, 145, 0} -"Uparrow", {226, 135, 145, 0} -"UpArrowDownArrow", {226, 135, 133, 0} -"updownarrow", {226, 134, 149, 0} -"UpDownArrow", {226, 134, 149, 0} -"Updownarrow", {226, 135, 149, 0} -"UpEquilibrium", {226, 165, 174, 0} -"upharpoonleft", {226, 134, 191, 0} -"upharpoonright", {226, 134, 190, 0} -"uplus", {226, 138, 142, 0} -"UpperLeftArrow", {226, 134, 150, 0} -"UpperRightArrow", {226, 134, 151, 0} -"upsi", {207, 133, 0} -"Upsi", {207, 146, 0} -"upsih", {207, 146, 0} -"Upsilon", {206, 165, 0} -"upsilon", {207, 133, 0} -"UpTeeArrow", {226, 134, 165, 0} -"UpTee", {226, 138, 165, 0} -"upuparrows", {226, 135, 136, 0} -"urcorn", {226, 140, 157, 0} -"urcorner", {226, 140, 157, 0} -"urcrop", {226, 140, 142, 0} -"Uring", {197, 174, 0} -"uring", {197, 175, 0} -"urtri", {226, 151, 185, 0} -"Uscr", {240, 157, 146, 176} -"uscr", {240, 157, 147, 138} -"utdot", {226, 139, 176, 0} -"Utilde", {197, 168, 0} -"utilde", {197, 169, 0} -"utri", {226, 150, 181, 0} -"utrif", {226, 150, 180, 0} -"uuarr", {226, 135, 136, 0} -"Uuml", {195, 156, 0} -"uuml", {195, 188, 0} -"uwangle", {226, 166, 167, 0} -"vangrt", {226, 166, 156, 0} -"varepsilon", {207, 181, 0} -"varkappa", {207, 176, 0} -"varnothing", {226, 136, 133, 0} -"varphi", {207, 149, 0} -"varpi", {207, 150, 0} -"varpropto", {226, 136, 157, 0} -"varr", {226, 134, 149, 0} -"vArr", {226, 135, 149, 0} -"varrho", {207, 177, 0} -"varsigma", {207, 130, 0} -"varsubsetneq", {226, 138, 138, 0} -"varsubsetneqq", {226, 171, 139, 0} -"varsupsetneq", {226, 138, 139, 0} -"varsupsetneqq", {226, 171, 140, 0} -"vartheta", {207, 145, 0} -"vartriangleleft", {226, 138, 178, 0} -"vartriangleright", {226, 138, 179, 0} -"vBar", {226, 171, 168, 0} -"Vbar", {226, 171, 171, 0} -"vBarv", {226, 171, 169, 0} -"Vcy", {208, 146, 0} -"vcy", {208, 178, 0} -"vdash", {226, 138, 162, 0} -"vDash", {226, 138, 168, 0} -"Vdash", {226, 138, 169, 0} -"VDash", {226, 138, 171, 0} -"Vdashl", {226, 171, 166, 0} -"veebar", {226, 138, 187, 0} -"vee", {226, 136, 168, 0} -"Vee", {226, 139, 129, 0} -"veeeq", {226, 137, 154, 0} -"vellip", {226, 139, 174, 0} -"verbar", {124, 0} -"Verbar", {226, 128, 150, 0} -"vert", {124, 0} -"Vert", {226, 128, 150, 0} -"VerticalBar", {226, 136, 163, 0} -"VerticalLine", {124, 0} -"VerticalSeparator", {226, 157, 152, 0} -"VerticalTilde", {226, 137, 128, 0} -"VeryThinSpace", {226, 128, 138, 0} -"Vfr", {240, 157, 148, 153} -"vfr", {240, 157, 148, 179} -"vltri", {226, 138, 178, 0} -"vnsub", {226, 138, 130, 0} -"vnsup", {226, 138, 131, 0} -"Vopf", {240, 157, 149, 141} -"vopf", {240, 157, 149, 167} -"vprop", {226, 136, 157, 0} -"vrtri", {226, 138, 179, 0} -"Vscr", {240, 157, 146, 177} -"vscr", {240, 157, 147, 139} -"vsubnE", {226, 171, 139, 0} -"vsubne", {226, 138, 138, 0} -"vsupnE", {226, 171, 140, 0} -"vsupne", {226, 138, 139, 0} -"Vvdash", {226, 138, 170, 0} -"vzigzag", {226, 166, 154, 0} -"Wcirc", {197, 180, 0} -"wcirc", {197, 181, 0} -"wedbar", {226, 169, 159, 0} -"wedge", {226, 136, 167, 0} -"Wedge", {226, 139, 128, 0} -"wedgeq", {226, 137, 153, 0} -"weierp", {226, 132, 152, 0} -"Wfr", {240, 157, 148, 154} -"wfr", {240, 157, 148, 180} -"Wopf", {240, 157, 149, 142} -"wopf", {240, 157, 149, 168} -"wp", {226, 132, 152, 0} -"wr", {226, 137, 128, 0} -"wreath", {226, 137, 128, 0} -"Wscr", {240, 157, 146, 178} -"wscr", {240, 157, 147, 140} -"xcap", {226, 139, 130, 0} -"xcirc", {226, 151, 175, 0} -"xcup", {226, 139, 131, 0} -"xdtri", {226, 150, 189, 0} -"Xfr", {240, 157, 148, 155} -"xfr", {240, 157, 148, 181} -"xharr", {226, 159, 183, 0} -"xhArr", {226, 159, 186, 0} -"Xi", {206, 158, 0} -"xi", {206, 190, 0} -"xlarr", {226, 159, 181, 0} -"xlArr", {226, 159, 184, 0} -"xmap", {226, 159, 188, 0} -"xnis", {226, 139, 187, 0} -"xodot", {226, 168, 128, 0} -"Xopf", {240, 157, 149, 143} -"xopf", {240, 157, 149, 169} -"xoplus", {226, 168, 129, 0} -"xotime", {226, 168, 130, 0} -"xrarr", {226, 159, 182, 0} -"xrArr", {226, 159, 185, 0} -"Xscr", {240, 157, 146, 179} -"xscr", {240, 157, 147, 141} -"xsqcup", {226, 168, 134, 0} -"xuplus", {226, 168, 132, 0} -"xutri", {226, 150, 179, 0} -"xvee", {226, 139, 129, 0} -"xwedge", {226, 139, 128, 0} -"Yacute", {195, 157, 0} -"yacute", {195, 189, 0} -"YAcy", {208, 175, 0} -"yacy", {209, 143, 0} -"Ycirc", {197, 182, 0} -"ycirc", {197, 183, 0} -"Ycy", {208, 171, 0} -"ycy", {209, 139, 0} -"yen", {194, 165, 0} -"Yfr", {240, 157, 148, 156} -"yfr", {240, 157, 148, 182} -"YIcy", {208, 135, 0} -"yicy", {209, 151, 0} -"Yopf", {240, 157, 149, 144} -"yopf", {240, 157, 149, 170} -"Yscr", {240, 157, 146, 180} -"yscr", {240, 157, 147, 142} -"YUcy", {208, 174, 0} -"yucy", {209, 142, 0} -"yuml", {195, 191, 0} -"Yuml", {197, 184, 0} -"Zacute", {197, 185, 0} -"zacute", {197, 186, 0} -"Zcaron", {197, 189, 0} -"zcaron", {197, 190, 0} -"Zcy", {208, 151, 0} -"zcy", {208, 183, 0} -"Zdot", {197, 187, 0} -"zdot", {197, 188, 0} -"zeetrf", {226, 132, 168, 0} -"ZeroWidthSpace", {226, 128, 139, 0} -"Zeta", {206, 150, 0} -"zeta", {206, 182, 0} -"zfr", {240, 157, 148, 183} -"Zfr", {226, 132, 168, 0} -"ZHcy", {208, 150, 0} -"zhcy", {208, 182, 0} -"zigrarr", {226, 135, 157, 0} -"zopf", {240, 157, 149, 171} -"Zopf", {226, 132, 164, 0} -"Zscr", {240, 157, 146, 181} -"zscr", {240, 157, 147, 143} -"zwj", {226, 128, 141, 0} -"zwnj", {226, 128, 140, 0} diff --git a/html_unescape.h b/html_unescape.h deleted file mode 100644 index 1eb318b..0000000 --- a/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/inlines.c b/inlines.c index 7ea308d..3275ddd 100644 --- a/inlines.c +++ b/inlines.c @@ -13,7 +13,6 @@ #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"; @@ -22,7 +21,6 @@ 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) @@ -33,210 +31,189 @@ static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99"; #define make_strong() make_simple(CMARK_NODE_STRONG) typedef struct delimiter { - struct delimiter *previous; - struct delimiter *next; - cmark_node *inl_text; - bufsize_t position; - unsigned char delim_char; - bool can_open; - bool can_close; - bool active; + struct delimiter *previous; + struct delimiter *next; + cmark_node *inl_text; + bufsize_t position; + unsigned char delim_char; + bool can_open; + bool can_close; + bool active; } delimiter; typedef struct { - cmark_chunk input; - bufsize_t pos; - cmark_reference_map *refmap; - delimiter *last_delim; + cmark_chunk input; + bufsize_t pos; + cmark_reference_map *refmap; + delimiter *last_delim; } subject; -static inline bool -S_is_line_end_char(char c) -{ - return (c == '\n' || c == '\r'); +static inline bool S_is_line_end_char(char c) { + return (c == '\n' || c == '\r'); } -static delimiter* -S_insert_emph(subject *subj, delimiter *opener, delimiter *closer); +static delimiter *S_insert_emph(subject *subj, delimiter *opener, + delimiter *closer); -static int parse_inline(subject* subj, cmark_node * parent, int options); +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 bufsize_t subject_find_special_char(subject *subj, int options); -static cmark_chunk cmark_clean_autolink(cmark_chunk *url, int is_email) -{ - cmark_strbuf buf = GH_BUF_INIT; +// 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; +} - cmark_chunk_trim(url); +// 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; +} - if (url->len == 0) { - cmark_chunk result = CMARK_CHUNK_EMPTY; - return result; - } +// Like make_str, but parses entities. +static cmark_node *make_str_with_entities(cmark_chunk *content) { + cmark_strbuf unescaped = GH_BUF_INIT; + + if (houdini_unescape_html(&unescaped, content->data, content->len)) { + return make_str(cmark_chunk_buf_detach(&unescaped)); + } else { + return make_str(*content); + } +} - if (is_email) - cmark_strbuf_puts(&buf, "mailto:"); +// Duplicate a chunk by creating a copy of the buffer not by reusing the +// buffer like cmark_chunk_dup does. +static cmark_chunk chunk_clone(cmark_chunk *src) { + cmark_chunk c; + bufsize_t len = src->len; - houdini_unescape_html_f(&buf, url->data, url->len); - return cmark_chunk_buf_detach(&buf); -} + c.len = len; + c.data = (unsigned char *)malloc(len + 1); + c.alloc = 1; + memcpy(c.data, src->data, len); + c.data[len] = '\0'; -static inline cmark_node *make_link(cmark_node *label, cmark_chunk *url, cmark_chunk *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; + return c; } -static inline cmark_node* make_autolink(cmark_node* label, cmark_chunk url, int is_email) -{ - cmark_chunk clean_url = cmark_clean_autolink(&url, is_email); - cmark_chunk title = CMARK_CHUNK_EMPTY; - return make_link(label, &clean_url, &title); -} +static cmark_chunk cmark_clean_autolink(cmark_chunk *url, int is_email) { + cmark_strbuf buf = GH_BUF_INIT; -// 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; -} + cmark_chunk_trim(url); -// 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; -} + if (url->len == 0) { + cmark_chunk result = CMARK_CHUNK_EMPTY; + return result; + } -// Duplicate a chunk by creating a copy of the buffer not by reusing the -// buffer like cmark_chunk_dup does. -static cmark_chunk chunk_clone(cmark_chunk *src) -{ - cmark_chunk c; - bufsize_t len = src->len; + if (is_email) + cmark_strbuf_puts(&buf, "mailto:"); - c.len = len; - c.data = (unsigned char *)malloc(len + 1); - c.alloc = 1; - memcpy(c.data, src->data, len); - c.data[len] = '\0'; + houdini_unescape_html_f(&buf, url->data, url->len); + return cmark_chunk_buf_detach(&buf); +} - return c; +static inline cmark_node *make_autolink(cmark_chunk url, int is_email) { + cmark_node *link = make_simple(CMARK_NODE_LINK); + link->as.link.url = cmark_clean_autolink(&url, is_email); + link->as.link.title = cmark_chunk_literal(""); + cmark_node_append_child(link, make_str_with_entities(&url)); + return link; } 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_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; } -static inline int isbacktick(int c) -{ - return (c == '`'); -} +static inline int isbacktick(int c) { return (c == '`'); } -static inline unsigned char peek_char(subject *subj) -{ - // NULL bytes should have been stripped out by now. If they're - // present, it's a programming error: - assert(!(subj->pos < subj->input.len && subj->input.data[subj->pos] == 0)); - return (subj->pos < subj->input.len) ? subj->input.data[subj->pos] : 0; +static inline unsigned char peek_char(subject *subj) { + // NULL bytes should have been stripped out by now. If they're + // present, it's a programming error: + assert(!(subj->pos < subj->input.len && subj->input.data[subj->pos] == 0)); + return (subj->pos < subj->input.len) ? subj->input.data[subj->pos] : 0; } -static inline unsigned char peek_at(subject *subj, bufsize_t pos) -{ - return subj->input.data[pos]; +static inline unsigned char peek_at(subject *subj, bufsize_t 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); +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 -static inline bool -skip_spaces(subject *subj) -{ - bool skipped = false; - while (peek_char(subj) == ' ' || peek_char(subj) == '\t') { - advance(subj); - skipped = true; - } - return skipped; +static inline bool skip_spaces(subject *subj) { + bool skipped = false; + while (peek_char(subj) == ' ' || peek_char(subj) == '\t') { + advance(subj); + skipped = true; + } + return skipped; } -static inline bool -skip_line_end(subject *subj) -{ - bool seen_line_end_char = false; - if (peek_char(subj) == '\r') { - advance(subj); - seen_line_end_char = true; - } - if (peek_char(subj) == '\n') { - advance(subj); - seen_line_end_char = true; - } - return seen_line_end_char || is_eof(subj); +static inline bool skip_line_end(subject *subj) { + bool seen_line_end_char = false; + if (peek_char(subj) == '\r') { + advance(subj); + seen_line_end_char = true; + } + if (peek_char(subj) == '\n') { + advance(subj); + seen_line_end_char = true; + } + return seen_line_end_char || is_eof(subj); } // Take characters while a predicate holds, and return a string. -static inline cmark_chunk take_while(subject* subj, int (*f)(int)) -{ - unsigned char c; - bufsize_t startpos = subj->pos; - bufsize_t len = 0; +static inline cmark_chunk take_while(subject *subj, int (*f)(int)) { + unsigned char c; + bufsize_t startpos = subj->pos; + bufsize_t len = 0; - while ((c = peek_char(subj)) && (*f)(c)) { - advance(subj); - len++; - } + while ((c = peek_char(subj)) && (*f)(c)) { + advance(subj); + len++; + } - return cmark_chunk_dup(&subj->input, startpos, len); + return cmark_chunk_dup(&subj->input, startpos, len); } // Try to process a backtick code span that began with a @@ -244,999 +221,949 @@ static inline cmark_chunk take_while(subject* subj, int (*f)(int)) // parsed). Return 0 if you don't find matching closing // backticks, otherwise return the position in the subject // after the closing backticks. -static bufsize_t scan_to_closing_backticks(subject* subj, bufsize_t 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 - } - bufsize_t numticks = 0; - while (peek_char(subj) == '`') { - advance(subj); - numticks++; - } - if (numticks != openticklength) { - return(scan_to_closing_backticks(subj, openticklength)); - } - return (subj->pos); +static bufsize_t scan_to_closing_backticks(subject *subj, + bufsize_t 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 + } + bufsize_t 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); - bufsize_t startpos = subj->pos; - bufsize_t 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)); - } +static cmark_node *handle_backticks(subject *subj) { + cmark_chunk openticks = take_while(subj, isbacktick); + bufsize_t startpos = subj->pos; + bufsize_t 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; - bufsize_t 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 || utf8proc_is_punctuation(before_char)); - *can_close = right_flanking && - (!left_flanking || utf8proc_is_punctuation(after_char)); - } 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 int scan_delims(subject *subj, unsigned char c, bool *can_open, + bool *can_close) { + int numdelims = 0; + bufsize_t 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 = cmark_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 = cmark_utf8proc_iterate(subj->input.data + subj->pos, + subj->input.len - subj->pos, &after_char); + if (len == -1) { + after_char = 10; + } + left_flanking = numdelims > 0 && !cmark_utf8proc_is_space(after_char) && + !(cmark_utf8proc_is_punctuation(after_char) && + !cmark_utf8proc_is_space(before_char) && + !cmark_utf8proc_is_punctuation(before_char)); + right_flanking = + numdelims > 0 && !cmark_utf8proc_is_space(before_char) && + !(cmark_utf8proc_is_punctuation(before_char) && + !cmark_utf8proc_is_space(after_char) && !cmark_utf8proc_is_punctuation(after_char)); + if (c == '_') { + *can_open = left_flanking && + (!right_flanking || cmark_utf8proc_is_punctuation(before_char)); + *can_close = right_flanking && + (!left_flanking || cmark_utf8proc_is_punctuation(after_char)); + } 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 stack pos %p, text pos %d: %d %d %d next(%p) prev(%p)\n", - (void*)delim, delim->position, delim->delim_char, - delim->can_open, delim->can_close, - (void*)delim->next, (void*)delim->previous); - delim = delim->previous; - } + delimiter *delim; + delim = subj->last_delim; + while (delim != NULL) { + printf("Item at stack pos %p, text pos %d: %d %d %d next(%p) +prev(%p)\n", + (void*)delim, delim->position, delim->delim_char, + delim->can_open, delim->can_close, + (void*)delim->next, (void*)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 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; + 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) -{ - bufsize_t 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; +static cmark_node *handle_delim(subject *subj, unsigned char c, bool smart) { + bufsize_t 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) -{ - int startpos = subj->pos; - - advance(subj); - - if (!smart || peek_char(subj) != '-') { - return make_str(cmark_chunk_literal("-")); - } - - while (smart && peek_char(subj) == '-') { - advance(subj); - } - - int numhyphens = subj->pos - startpos; - int en_count = 0; - int em_count = 0; - int i; - cmark_strbuf buf = GH_BUF_INIT; - - if (numhyphens % 3 == 0) { // if divisible by 3, use all em dashes - em_count = numhyphens / 3; - } else if (numhyphens % 2 == 0) { // if divisible by 2, use all en dashes - en_count = numhyphens / 2; - } else if (numhyphens % 3 == 2) { // use one en dash at end - en_count = 1; - em_count = (numhyphens - 2) / 3; - } else { // use two en dashes at the end - en_count = 2; - em_count = (numhyphens - 4) / 3; - } - - for (i = em_count; i > 0; i--) { - cmark_strbuf_puts(&buf, EMDASH); - } - - for (i = en_count; i > 0; i--) { - cmark_strbuf_puts(&buf, ENDASH); - } - - return make_str(cmark_chunk_buf_detach(&buf)); +static cmark_node *handle_hyphen(subject *subj, bool smart) { + int startpos = subj->pos; + + advance(subj); + + if (!smart || peek_char(subj) != '-') { + return make_str(cmark_chunk_literal("-")); + } + + while (smart && peek_char(subj) == '-') { + advance(subj); + } + + int numhyphens = subj->pos - startpos; + int en_count = 0; + int em_count = 0; + int i; + cmark_strbuf buf = GH_BUF_INIT; + + if (numhyphens % 3 == 0) { // if divisible by 3, use all em dashes + em_count = numhyphens / 3; + } else if (numhyphens % 2 == 0) { // if divisible by 2, use all en dashes + en_count = numhyphens / 2; + } else if (numhyphens % 3 == 2) { // use one en dash at end + en_count = 1; + em_count = (numhyphens - 2) / 3; + } else { // use two en dashes at the end + en_count = 2; + em_count = (numhyphens - 4) / 3; + } + + for (i = em_count; i > 0; i--) { + cmark_strbuf_puts(&buf, EMDASH); + } + + for (i = en_count; i > 0; i--) { + cmark_strbuf_puts(&buf, ENDASH); + } + + return make_str(cmark_chunk_buf_detach(&buf)); } // 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 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 *stack_bottom) -{ - delimiter *closer = subj->last_delim; - delimiter *opener; - delimiter *old_closer; - bool opener_found; - delimiter *openers_bottom[128]; - - // initialize openers_bottom: - openers_bottom['*'] = stack_bottom; - openers_bottom['_'] = stack_bottom; - openers_bottom['\''] = stack_bottom; - openers_bottom['"'] = stack_bottom; - - // move back to first relevant delim. - while (closer != NULL && closer->previous != stack_bottom) { - 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; - opener_found = false; - while (opener != NULL && opener != stack_bottom && - opener != openers_bottom[closer->delim_char]) { - if (opener->delim_char == closer->delim_char && - opener->can_open) { - opener_found = true; - break; - } - opener = opener->previous; - } - old_closer = closer; - if (closer->delim_char == '*' || closer->delim_char == '_') { - if (opener_found) { - 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_found) { - 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_found) { - cmark_chunk_free(&opener->inl_text->as.literal); - opener->inl_text->as.literal = - cmark_chunk_literal(LEFTDOUBLEQUOTE); - } - closer = closer->next; - } - if (!opener_found) { - // set lower bound for future searches for openers: - openers_bottom[old_closer->delim_char] = old_closer->previous; - if (!old_closer->can_open) { - // we can remove a closer that can't be an - // opener, once we've seen there's no - // matching opener: - remove_delimiter(subj, old_closer); - } - } - } else { - closer = closer->next; - } - } - // free all delimiters in list until stack_bottom: - while (subj->last_delim != stack_bottom) { - remove_delimiter(subj, subj->last_delim); - } +static void process_emphasis(subject *subj, delimiter *stack_bottom) { + delimiter *closer = subj->last_delim; + delimiter *opener; + delimiter *old_closer; + bool opener_found; + delimiter *openers_bottom[128]; + + // initialize openers_bottom: + openers_bottom['*'] = stack_bottom; + openers_bottom['_'] = stack_bottom; + openers_bottom['\''] = stack_bottom; + openers_bottom['"'] = stack_bottom; + + // move back to first relevant delim. + while (closer != NULL && closer->previous != stack_bottom) { + 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; + opener_found = false; + while (opener != NULL && opener != stack_bottom && + opener != openers_bottom[closer->delim_char]) { + if (opener->delim_char == closer->delim_char && opener->can_open) { + opener_found = true; + break; + } + opener = opener->previous; + } + old_closer = closer; + if (closer->delim_char == '*' || closer->delim_char == '_') { + if (opener_found) { + 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_found) { + 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_found) { + cmark_chunk_free(&opener->inl_text->as.literal); + opener->inl_text->as.literal = cmark_chunk_literal(LEFTDOUBLEQUOTE); + } + closer = closer->next; + } + if (!opener_found) { + // set lower bound for future searches for openers: + openers_bottom[old_closer->delim_char] = old_closer->previous; + if (!old_closer->can_open) { + // we can remove a closer that can't be an + // opener, once we've seen there's no + // matching opener: + remove_delimiter(subj, old_closer); + } + } + } else { + closer = closer->next; + } + } + // free all delimiters in list until stack_bottom: + while (subj->last_delim != stack_bottom) { + remove_delimiter(subj, subj->last_delim); + } } -static delimiter* -S_insert_emph(subject *subj, delimiter *opener, delimiter *closer) -{ - delimiter *delim, *tmp_delim; - bufsize_t use_delims; - cmark_node *opener_inl = opener->inl_text; - cmark_node *closer_inl = closer->inl_text; - bufsize_t opener_num_chars = opener_inl->as.literal.len; - bufsize_t 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; +static delimiter *S_insert_emph(subject *subj, delimiter *opener, + delimiter *closer) { + delimiter *delim, *tmp_delim; + bufsize_t use_delims; + cmark_node *opener_inl = opener->inl_text; + cmark_node *closer_inl = closer->inl_text; + bufsize_t opener_num_chars = opener_inl->as.literal.len; + bufsize_t 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 ? CMARK_NODE_EMPH : CMARK_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 (!is_eof(subj) && skip_line_end(subj)) { - return make_linebreak(); - } else { - return make_str(cmark_chunk_literal("\\")); - } +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 (!is_eof(subj) && skip_line_end(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; - bufsize_t len; - - advance(subj); +static cmark_node *handle_entity(subject *subj) { + cmark_strbuf ent = GH_BUF_INIT; + bufsize_t len; - len = houdini_unescape_ent(&ent, - subj->input.data + subj->pos, - subj->input.len - subj->pos - ); + advance(subj); - if (len == 0) - return make_str(cmark_chunk_literal("&")); - - subj->pos += len; - return make_str(cmark_chunk_buf_detach(&ent)); -} + len = houdini_unescape_ent(&ent, subj->input.data + subj->pos, + subj->input.len - subj->pos); -// 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 (len == 0) + return make_str(cmark_chunk_literal("&")); - if (houdini_unescape_html(&unescaped, content->data, content->len)) { - return make_str(cmark_chunk_buf_detach(&unescaped)); - } else { - return make_str(*content); - } + subj->pos += len; + return make_str(cmark_chunk_buf_detach(&ent)); } // Clean a URL: remove surrounding whitespace and surrounding <>, // and remove \ that escape punctuation. -cmark_chunk cmark_clean_url(cmark_chunk *url) -{ - cmark_strbuf buf = GH_BUF_INIT; +cmark_chunk cmark_clean_url(cmark_chunk *url) { + cmark_strbuf buf = GH_BUF_INIT; - cmark_chunk_trim(url); + cmark_chunk_trim(url); - if (url->len == 0) { - cmark_chunk result = CMARK_CHUNK_EMPTY; - return result; - } + if (url->len == 0) { + cmark_chunk result = CMARK_CHUNK_EMPTY; + return result; + } - 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); - } + 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_chunk_buf_detach(&buf); + cmark_strbuf_unescape(&buf); + return cmark_chunk_buf_detach(&buf); } -cmark_chunk cmark_clean_title(cmark_chunk *title) -{ - cmark_strbuf buf = GH_BUF_INIT; - unsigned char first, last; - - if (title->len == 0) { - cmark_chunk result = CMARK_CHUNK_EMPTY; - return result; - } - - 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_chunk_buf_detach(&buf); +cmark_chunk cmark_clean_title(cmark_chunk *title) { + cmark_strbuf buf = GH_BUF_INIT; + unsigned char first, last; + + if (title->len == 0) { + cmark_chunk result = CMARK_CHUNK_EMPTY; + return result; + } + + 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_chunk_buf_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) -{ - bufsize_t 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("<")); +static cmark_node *handle_pointy_brace(subject *subj) { + bufsize_t 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(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(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) -{ - bufsize_t 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)); - cmark_chunk_trim(raw_label); - advance(subj); // advance past ] - return 1; - } +static int link_label(subject *subj, cmark_chunk *raw_label) { + bufsize_t 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)); + cmark_chunk_trim(raw_label); + advance(subj); // advance past ] + return 1; + } noMatch: - subj->pos = startpos; // rewind - return 0; - + 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) -{ - bufsize_t initial_pos; - bufsize_t starturl, endurl, starttitle, endtitle, endall; - bufsize_t n; - bufsize_t sps; - cmark_reference *ref; - bool is_image = false; - cmark_chunk url_chunk, title_chunk; - cmark_chunk 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 = chunk_clone(&ref->url); - title = chunk_clone(&ref->title); - goto match; - } else { - goto noMatch; - } +static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) { + bufsize_t initial_pos; + bufsize_t starturl, endurl, starttitle, endtitle, endall; + bufsize_t n; + bufsize_t sps; + cmark_reference *ref; + bool is_image = false; + cmark_chunk url_chunk, title_chunk; + cmark_chunk 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 = chunk_clone(&ref->url); + title = chunk_clone(&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("]")); + // 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); - 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; - - // 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.) - remove_delimiter(subj, opener); - 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; + inl = opener->inl_text; + inl->type = is_image ? CMARK_NODE_IMAGE : CMARK_NODE_LINK; + cmark_chunk_free(&inl->as.literal); + inl->first_child = link_text; + process_emphasis(subj, opener); + 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; + + // 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.) + remove_delimiter(subj, opener); + 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) -{ - bufsize_t nlpos = subj->pos; - // skip over newline - advance(subj); - // skip spaces at beginning of line - skip_spaces(subj); - if (nlpos > 1 && - peek_at(subj, nlpos - 1) == ' ' && - peek_at(subj, nlpos - 2) == ' ') { - return make_linebreak(); - } else { - return make_softbreak(); - } +// Assumes the subject has a cr or newline at the current position. +static cmark_node *handle_newline(subject *subj) { + bufsize_t nlpos = subj->pos; + // skip over cr, crlf, or lf: + if (peek_at(subj, subj->pos) == '\r') { + advance(subj); + } + if (peek_at(subj, subj->pos) == '\n') { + advance(subj); + } + // skip spaces at beginning of line + skip_spaces(subj); + if (nlpos > 1 && peek_at(subj, nlpos - 1) == ' ' && + peek_at(subj, nlpos - 2) == ' ') { + return make_linebreak(); + } else { + return make_softbreak(); + } } -static bufsize_t subject_find_special_char(subject *subj, int options) -{ - // "\r\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; +static bufsize_t subject_find_special_char(subject *subj, int options) { + // "\r\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; - bufsize_t endpos; - c = peek_char(subj); - if (c == 0) { - return 0; - } - switch(c) { - case '\r': - 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 (S_is_line_end_char(peek_char(subj))) { - cmark_chunk_rtrim(&contents); - } - - new_inl = make_str(contents); - } - if (new_inl != NULL) { - cmark_node_append_child(parent, new_inl); - } - - return 1; +static int parse_inline(subject *subj, cmark_node *parent, int options) { + cmark_node *new_inl = NULL; + cmark_chunk contents; + unsigned char c; + bufsize_t endpos; + c = peek_char(subj); + if (c == 0) { + return 0; + } + switch (c) { + case '\r': + 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) != 0); + break; + case '-': + new_inl = handle_hyphen(subj, (options & CMARK_OPT_SMART) != 0); + break; + case '.': + new_inl = handle_period(subj, (options & CMARK_OPT_SMART) != 0); + 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 (S_is_line_end_char(peek_char(subj))) { + 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); - cmark_chunk_rtrim(&subj.input); +extern void cmark_parse_inlines(cmark_node *parent, cmark_reference_map *refmap, + int options) { + subject subj; + subject_from_buf(&subj, &parent->string_content, refmap); + cmark_chunk_rtrim(&subj.input); - while (!is_eof(&subj) && parse_inline(&subj, parent, options)) ; + while (!is_eof(&subj) && parse_inline(&subj, parent, options)) + ; - process_emphasis(&subj, NULL); + process_emphasis(&subj, NULL); } // Parse zero or more space characters, including at most one newline. -static void spnl(subject* subj) -{ - skip_spaces(subj); - if (skip_line_end(subj)) { - skip_spaces(subj); - } +static void spnl(subject *subj) { + skip_spaces(subj); + if (skip_line_end(subj)) { + skip_spaces(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. -bufsize_t cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap) -{ - subject subj; - - cmark_chunk lab; - cmark_chunk url; - cmark_chunk title; - - bufsize_t matchlen = 0; - bufsize_t beforetitle; - - subject_from_buf(&subj, input, NULL); - - // parse label: - if (!link_label(&subj, &lab) || lab.len == 0) - 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: - skip_spaces(&subj); - if (!skip_line_end(&subj)) { - if (matchlen) { // try rewinding before title - subj.pos = beforetitle; - skip_spaces(&subj); - if (!skip_line_end(&subj)) { - return 0; - } - } else { - return 0; - } - } - // insert reference into refmap - cmark_reference_create(refmap, &lab, &url, &title); - return subj.pos; +bufsize_t cmark_parse_reference_inline(cmark_strbuf *input, + cmark_reference_map *refmap) { + subject subj; + + cmark_chunk lab; + cmark_chunk url; + cmark_chunk title; + + bufsize_t matchlen = 0; + bufsize_t beforetitle; + + subject_from_buf(&subj, input, NULL); + + // parse label: + if (!link_label(&subj, &lab) || lab.len == 0) + 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: + skip_spaces(&subj); + if (!skip_line_end(&subj)) { + if (matchlen) { // try rewinding before title + subj.pos = beforetitle; + skip_spaces(&subj); + if (!skip_line_end(&subj)) { + return 0; + } + } else { + return 0; + } + } + // insert reference into refmap + cmark_reference_create(refmap, &lab, &url, &title); + return subj.pos; } diff --git a/inlines.h b/inlines.h index f8847fc..7e7ee45 100644 --- a/inlines.h +++ b/inlines.h @@ -8,9 +8,11 @@ extern "C" { cmark_chunk cmark_clean_url(cmark_chunk *url); cmark_chunk cmark_clean_title(cmark_chunk *title); -void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap, int options); +void cmark_parse_inlines(cmark_node *parent, cmark_reference_map *refmap, + int options); -bufsize_t cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap); +bufsize_t cmark_parse_reference_inline(cmark_strbuf *input, + cmark_reference_map *refmap); #ifdef __cplusplus } diff --git a/iterator.c b/iterator.c index f18e3bf..19dfff8 100644 --- a/iterator.c +++ b/iterator.c @@ -7,142 +7,112 @@ #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; + (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); -} +void cmark_iter_free(cmark_iter *iter) { free(iter); } -static bool -S_is_leaf(cmark_node *node) -{ - return (1 << node->type) & S_leaf_mask; +static bool S_is_leaf(cmark_node *node) { + return ((1 << node->type) & S_leaf_mask) != 0; } -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; +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); +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_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_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_put(&buf, cur->as.literal.data, cur->as.literal.len); - tmp = cur->next; - while (tmp && tmp->type == CMARK_NODE_TEXT) { - cmark_iter_next(iter); // advance pointer - cmark_strbuf_put(&buf, tmp->as.literal.data, tmp->as.literal.len); - next = tmp->next; - cmark_node_free(tmp); - tmp = next; - } - cmark_chunk_free(&cur->as.literal); - cur->as.literal = cmark_chunk_buf_detach(&buf); - } - } - - cmark_strbuf_free(&buf); - cmark_iter_free(iter); +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_put(&buf, cur->as.literal.data, cur->as.literal.len); + tmp = cur->next; + while (tmp && tmp->type == CMARK_NODE_TEXT) { + cmark_iter_next(iter); // advance pointer + cmark_strbuf_put(&buf, tmp->as.literal.data, tmp->as.literal.len); + next = tmp->next; + cmark_node_free(tmp); + tmp = next; + } + cmark_chunk_free(&cur->as.literal); + cur->as.literal = cmark_chunk_buf_detach(&buf); + } + } + + cmark_strbuf_free(&buf); + cmark_iter_free(iter); } diff --git a/iterator.h b/iterator.h index 027b10b..9c6bca6 100644 --- a/iterator.h +++ b/iterator.h @@ -8,14 +8,14 @@ extern "C" { #include "cmark.h" typedef struct { - cmark_event_type ev_type; - cmark_node *node; + 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; + cmark_node *root; + cmark_iter_state cur; + cmark_iter_state next; }; #ifdef __cplusplus diff --git a/latex.c b/latex.c index 782b0c0..146062e 100644 --- a/latex.c +++ b/latex.c @@ -18,413 +18,391 @@ #define CR() renderer->cr(renderer) #define BLANKLINE() renderer->blankline(renderer) -static inline void outc(cmark_renderer *renderer, - cmark_escaping escape, - int32_t c, - unsigned char nextc) -{ - if (escape == LITERAL) { - cmark_render_code_point(renderer, c); - return; - } - - switch(c) { - case 123: // '{' - case 125: // '}' - case 35: // '#' - case 37: // '%' - case 38: // '&' - cmark_render_ascii(renderer, "\\"); - cmark_render_code_point(renderer, c); - break; - case 36: // '$' - case 95: // '_' - if (escape == NORMAL) { - cmark_render_ascii(renderer, "\\"); - } - cmark_render_code_point(renderer, c); - break; - case 45 : // '-' - if (nextc == 45) { // prevent ligature - cmark_render_ascii(renderer, "\\-"); - } else { - cmark_render_ascii(renderer, "-"); - } - break; - case 126: // '~' - if (escape == NORMAL) { - cmark_render_ascii(renderer, "\\textasciitilde{}"); - } else { - cmark_render_code_point(renderer, c); - } - break; - case 94: // '^' - cmark_render_ascii(renderer, "\\^{}"); - break; - case 92: // '\\' - if (escape == URL) { - // / acts as path sep even on windows: - cmark_render_ascii(renderer, "/"); - } else { - cmark_render_ascii(renderer, "\\textbackslash{}"); - } - break; - case 124: // '|' - cmark_render_ascii(renderer, "\\textbar{}"); - break; - case 60: // '<' - cmark_render_ascii(renderer, "\\textless{}"); - break; - case 62: // '>' - cmark_render_ascii(renderer, "\\textgreater{}"); - break; - case 91: // '[' - case 93: // ']' - cmark_render_ascii(renderer, "{"); - cmark_render_code_point(renderer, c); - cmark_render_ascii(renderer, "}"); - break; - case 34: // '"' - cmark_render_ascii(renderer, "\\textquotedbl{}"); - // requires \usepackage[T1]{fontenc} - break; - case 39: // '\'' - cmark_render_ascii(renderer, "\\textquotesingle{}"); - // requires \usepackage{textcomp} - break; - case 160: // nbsp - cmark_render_ascii(renderer, "~"); - break; - case 8230: // hellip - cmark_render_ascii(renderer, "\\ldots{}"); - break; - case 8216: // lsquo - if (escape == NORMAL) { - cmark_render_ascii(renderer, "`"); - } else { - cmark_render_code_point(renderer, c); - } - break; - case 8217: // rsquo - if (escape == NORMAL) { - cmark_render_ascii(renderer, "\'"); - } else { - cmark_render_code_point(renderer, c); - } - break; - case 8220: // ldquo - if (escape == NORMAL) { - cmark_render_ascii(renderer, "``"); - } else { - cmark_render_code_point(renderer, c); - } - break; - case 8221: // rdquo - if (escape == NORMAL) { - cmark_render_ascii(renderer, "''"); - } else { - cmark_render_code_point(renderer, c); - } - break; - case 8212: // emdash - if (escape == NORMAL) { - cmark_render_ascii(renderer, "---"); - } else { - cmark_render_code_point(renderer, c); - } - break; - case 8211: // endash - if (escape == NORMAL) { - cmark_render_ascii(renderer, "--"); - } else { - cmark_render_code_point(renderer, c); - } - break; - default: - cmark_render_code_point(renderer, c); - } +static inline void outc(cmark_renderer *renderer, cmark_escaping escape, + int32_t c, unsigned char nextc) { + if (escape == LITERAL) { + cmark_render_code_point(renderer, c); + return; + } + + switch (c) { + case 123: // '{' + case 125: // '}' + case 35: // '#' + case 37: // '%' + case 38: // '&' + cmark_render_ascii(renderer, "\\"); + cmark_render_code_point(renderer, c); + break; + case 36: // '$' + case 95: // '_' + if (escape == NORMAL) { + cmark_render_ascii(renderer, "\\"); + } + cmark_render_code_point(renderer, c); + break; + case 45: // '-' + if (nextc == 45) { // prevent ligature + cmark_render_ascii(renderer, "\\-"); + } else { + cmark_render_ascii(renderer, "-"); + } + break; + case 126: // '~' + if (escape == NORMAL) { + cmark_render_ascii(renderer, "\\textasciitilde{}"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 94: // '^' + cmark_render_ascii(renderer, "\\^{}"); + break; + case 92: // '\\' + if (escape == URL) { + // / acts as path sep even on windows: + cmark_render_ascii(renderer, "/"); + } else { + cmark_render_ascii(renderer, "\\textbackslash{}"); + } + break; + case 124: // '|' + cmark_render_ascii(renderer, "\\textbar{}"); + break; + case 60: // '<' + cmark_render_ascii(renderer, "\\textless{}"); + break; + case 62: // '>' + cmark_render_ascii(renderer, "\\textgreater{}"); + break; + case 91: // '[' + case 93: // ']' + cmark_render_ascii(renderer, "{"); + cmark_render_code_point(renderer, c); + cmark_render_ascii(renderer, "}"); + break; + case 34: // '"' + cmark_render_ascii(renderer, "\\textquotedbl{}"); + // requires \usepackage[T1]{fontenc} + break; + case 39: // '\'' + cmark_render_ascii(renderer, "\\textquotesingle{}"); + // requires \usepackage{textcomp} + break; + case 160: // nbsp + cmark_render_ascii(renderer, "~"); + break; + case 8230: // hellip + cmark_render_ascii(renderer, "\\ldots{}"); + break; + case 8216: // lsquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "`"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8217: // rsquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "\'"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8220: // ldquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "``"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8221: // rdquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "''"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8212: // emdash + if (escape == NORMAL) { + cmark_render_ascii(renderer, "---"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8211: // endash + if (escape == NORMAL) { + cmark_render_ascii(renderer, "--"); + } else { + cmark_render_code_point(renderer, c); + } + break; + default: + cmark_render_code_point(renderer, c); + } } -typedef enum { - NO_LINK, - URL_AUTOLINK, - EMAIL_AUTOLINK, - NORMAL_LINK -} link_type; - -static link_type -get_link_type(cmark_node *node) -{ - size_t title_len, url_len; - cmark_node *link_text; - char *realurl; - int realurllen; - bool isemail = false; - - if (node->type != CMARK_NODE_LINK) { - return NO_LINK; - } - - const char* url = cmark_node_get_url(node); - cmark_chunk url_chunk = cmark_chunk_literal(url); - - url_len = safe_strlen(url); - if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) { - return NO_LINK; - } - - const char* title = cmark_node_get_title(node); - title_len = safe_strlen(title); - // if it has a title, we can't treat it as an autolink: - if (title_len > 0) { - return NORMAL_LINK; - } - - link_text = node->first_child; - cmark_consolidate_text_nodes(link_text); - realurl = (char*)url; - realurllen = url_len; - if (strncmp(realurl, "mailto:", 7) == 0) { - realurl += 7; - realurllen -= 7; - isemail = true; - } - if (realurllen == link_text->as.literal.len && - strncmp(realurl, - (char*)link_text->as.literal.data, - link_text->as.literal.len) == 0) { - if (isemail) { - return EMAIL_AUTOLINK; - } else { - return URL_AUTOLINK; - } - } else { - return NORMAL_LINK; - } +typedef enum { NO_LINK, URL_AUTOLINK, EMAIL_AUTOLINK, NORMAL_LINK } link_type; + +static link_type get_link_type(cmark_node *node) { + size_t title_len, url_len; + cmark_node *link_text; + char *realurl; + int realurllen; + bool isemail = false; + + if (node->type != CMARK_NODE_LINK) { + return NO_LINK; + } + + const char *url = cmark_node_get_url(node); + cmark_chunk url_chunk = cmark_chunk_literal(url); + + url_len = safe_strlen(url); + if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) { + return NO_LINK; + } + + const char *title = cmark_node_get_title(node); + title_len = safe_strlen(title); + // if it has a title, we can't treat it as an autolink: + if (title_len > 0) { + return NORMAL_LINK; + } + + link_text = node->first_child; + cmark_consolidate_text_nodes(link_text); + realurl = (char *)url; + realurllen = url_len; + if (strncmp(realurl, "mailto:", 7) == 0) { + realurl += 7; + realurllen -= 7; + isemail = true; + } + if (realurllen == link_text->as.literal.len && + strncmp(realurl, (char *)link_text->as.literal.data, + link_text->as.literal.len) == 0) { + if (isemail) { + return EMAIL_AUTOLINK; + } else { + return URL_AUTOLINK; + } + } else { + return NORMAL_LINK; + } } -static int -S_get_enumlevel(cmark_node *node) -{ - int enumlevel = 0; - cmark_node *tmp = node; - while (tmp) { - if (tmp->type == CMARK_NODE_LIST && - cmark_node_get_list_type(node) == CMARK_ORDERED_LIST) { - enumlevel++; - } - tmp = tmp->parent; - } - return enumlevel; +static int S_get_enumlevel(cmark_node *node) { + int enumlevel = 0; + cmark_node *tmp = node; + while (tmp) { + if (tmp->type == CMARK_NODE_LIST && + cmark_node_get_list_type(node) == CMARK_ORDERED_LIST) { + enumlevel++; + } + tmp = tmp->parent; + } + return enumlevel; } -static int -S_render_node(cmark_renderer *renderer, - cmark_node *node, - cmark_event_type ev_type, - int options) -{ - int list_number; - char list_number_string[20]; - bool entering = (ev_type == CMARK_EVENT_ENTER); - cmark_list_type list_type; - const char* roman_numerals[] = { "", "i", "ii", "iii", "iv", "v", - "vi", "vii", "viii", "ix", "x" - }; - - // avoid warning about unused parameter: - (void)(options); - - switch (node->type) { - case CMARK_NODE_DOCUMENT: - break; - - case CMARK_NODE_BLOCK_QUOTE: - if (entering) { - LIT("\\begin{quote}"); - CR(); - } else { - LIT("\\end{quote}"); - BLANKLINE(); - } - break; - - case CMARK_NODE_LIST: - list_type = cmark_node_get_list_type(node); - if (entering) { - LIT("\\begin{"); - LIT(list_type == CMARK_ORDERED_LIST ? - "enumerate" : "itemize"); - LIT("}"); - CR(); - list_number = cmark_node_get_list_start(node); - if (list_number > 1) { - sprintf(list_number_string, - "%d", list_number); - LIT("\\setcounter{enum"); - LIT((char *)roman_numerals[S_get_enumlevel(node)]); - LIT("}{"); - OUT(list_number_string, false, NORMAL); - LIT("}"); - CR(); - } - } else { - LIT("\\end{"); - LIT(list_type == CMARK_ORDERED_LIST ? - "enumerate" : "itemize"); - LIT("}"); - BLANKLINE(); - } - break; - - case CMARK_NODE_ITEM: - if (entering) { - LIT("\\item "); - } else { - CR(); - } - break; - - case CMARK_NODE_HEADER: - if (entering) { - switch (cmark_node_get_header_level(node)) { - case 1: - LIT("\\section"); - break; - case 2: - LIT("\\subsection"); - break; - case 3: - LIT("\\subsubsection"); - break; - case 4: - LIT("\\paragraph"); - break; - case 5: - LIT("\\subparagraph"); - break; - } - LIT("{"); - } else { - LIT("}"); - BLANKLINE(); - } - break; - - case CMARK_NODE_CODE_BLOCK: - CR(); - LIT("\\begin{verbatim}"); - CR(); - OUT(cmark_node_get_literal(node), false, LITERAL); - CR(); - LIT("\\end{verbatim}"); - BLANKLINE(); - break; - - case CMARK_NODE_HTML: - break; - - case CMARK_NODE_HRULE: - BLANKLINE(); - LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}"); - BLANKLINE(); - break; - - case CMARK_NODE_PARAGRAPH: - if (!entering) { - BLANKLINE(); - } - break; - - case CMARK_NODE_TEXT: - OUT(cmark_node_get_literal(node), true, NORMAL); - break; - - case CMARK_NODE_LINEBREAK: - LIT("\\\\"); - CR(); - break; - - case CMARK_NODE_SOFTBREAK: - if (renderer->width == 0) { - CR(); - } else { - OUT(" ", true, NORMAL); - } - break; - - case CMARK_NODE_CODE: - LIT("\\texttt{"); - OUT(cmark_node_get_literal(node), false, NORMAL); - LIT("}"); - break; - - case CMARK_NODE_INLINE_HTML: - break; - - case CMARK_NODE_STRONG: - if (entering) { - LIT("\\textbf{"); - } else { - LIT("}"); - } - break; - - case CMARK_NODE_EMPH: - if (entering) { - LIT("\\emph{"); - } else { - LIT("}"); - } - break; - - case CMARK_NODE_LINK: - if (entering) { - const char* url = cmark_node_get_url(node); - // requires \usepackage{hyperref} - switch(get_link_type(node)) { - case URL_AUTOLINK: - LIT("\\url{"); - OUT(url, false, URL); - break; - case EMAIL_AUTOLINK: - LIT("\\href{"); - OUT(url, false, URL); - LIT("}\\nolinkurl{"); - break; - case NORMAL_LINK: - LIT("\\href{"); - OUT(url, false, URL); - LIT("}{"); - break; - case NO_LINK: - LIT("{"); // error? - } - } else { - LIT("}"); - } - - break; - - case CMARK_NODE_IMAGE: - if (entering) { - LIT("\\protect\\includegraphics{"); - // requires \include{graphicx} - OUT(cmark_node_get_url(node), false, URL); - LIT("}"); - return 0; - } - break; - - default: - assert(false); - break; - } - - return 1; +static int S_render_node(cmark_renderer *renderer, cmark_node *node, + cmark_event_type ev_type, int options) { + int list_number; + char list_number_string[20]; + bool entering = (ev_type == CMARK_EVENT_ENTER); + cmark_list_type list_type; + const char *roman_numerals[] = {"", "i", "ii", "iii", "iv", "v", + "vi", "vii", "viii", "ix", "x"}; + + // avoid warning about unused parameter: + (void)(options); + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + LIT("\\begin{quote}"); + CR(); + } else { + LIT("\\end{quote}"); + BLANKLINE(); + } + break; + + case CMARK_NODE_LIST: + list_type = cmark_node_get_list_type(node); + if (entering) { + LIT("\\begin{"); + LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize"); + LIT("}"); + CR(); + list_number = cmark_node_get_list_start(node); + if (list_number > 1) { + sprintf(list_number_string, "%d", list_number); + LIT("\\setcounter{enum"); + LIT((char *)roman_numerals[S_get_enumlevel(node)]); + LIT("}{"); + OUT(list_number_string, false, NORMAL); + LIT("}"); + CR(); + } + } else { + LIT("\\end{"); + LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize"); + LIT("}"); + BLANKLINE(); + } + break; + + case CMARK_NODE_ITEM: + if (entering) { + LIT("\\item "); + } else { + CR(); + } + break; + + case CMARK_NODE_HEADER: + if (entering) { + switch (cmark_node_get_header_level(node)) { + case 1: + LIT("\\section"); + break; + case 2: + LIT("\\subsection"); + break; + case 3: + LIT("\\subsubsection"); + break; + case 4: + LIT("\\paragraph"); + break; + case 5: + LIT("\\subparagraph"); + break; + } + LIT("{"); + } else { + LIT("}"); + BLANKLINE(); + } + break; + + case CMARK_NODE_CODE_BLOCK: + CR(); + LIT("\\begin{verbatim}"); + CR(); + OUT(cmark_node_get_literal(node), false, LITERAL); + CR(); + LIT("\\end{verbatim}"); + BLANKLINE(); + break; + + case CMARK_NODE_HTML: + break; + + case CMARK_NODE_HRULE: + BLANKLINE(); + LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}"); + BLANKLINE(); + break; + + case CMARK_NODE_PARAGRAPH: + if (!entering) { + BLANKLINE(); + } + break; + + case CMARK_NODE_TEXT: + OUT(cmark_node_get_literal(node), true, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + LIT("\\\\"); + CR(); + break; + + case CMARK_NODE_SOFTBREAK: + if (renderer->width == 0) { + CR(); + } else { + OUT(" ", true, NORMAL); + } + break; + + case CMARK_NODE_CODE: + LIT("\\texttt{"); + OUT(cmark_node_get_literal(node), false, NORMAL); + LIT("}"); + break; + + case CMARK_NODE_INLINE_HTML: + break; + + case CMARK_NODE_STRONG: + if (entering) { + LIT("\\textbf{"); + } else { + LIT("}"); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + LIT("\\emph{"); + } else { + LIT("}"); + } + break; + + case CMARK_NODE_LINK: + if (entering) { + const char *url = cmark_node_get_url(node); + // requires \usepackage{hyperref} + switch (get_link_type(node)) { + case URL_AUTOLINK: + LIT("\\url{"); + OUT(url, false, URL); + break; + case EMAIL_AUTOLINK: + LIT("\\href{"); + OUT(url, false, URL); + LIT("}\\nolinkurl{"); + break; + case NORMAL_LINK: + LIT("\\href{"); + OUT(url, false, URL); + LIT("}{"); + break; + case NO_LINK: + LIT("{"); // error? + } + } else { + LIT("}"); + } + + break; + + case CMARK_NODE_IMAGE: + if (entering) { + LIT("\\protect\\includegraphics{"); + // requires \include{graphicx} + OUT(cmark_node_get_url(node), false, URL); + LIT("}"); + return 0; + } + break; + + default: + assert(false); + break; + } + + return 1; } -char *cmark_render_latex(cmark_node *root, int options, int width) -{ - return cmark_render(root, options, width, outc, S_render_node); +char *cmark_render_latex(cmark_node *root, int options, int width) { + return cmark_render(root, options, width, outc, S_render_node); } diff --git a/man.c b/man.c index 6ff33f5..8e3913e 100644 --- a/man.c +++ b/man.c @@ -16,234 +16,220 @@ #define BLANKLINE() renderer->blankline(renderer) // Functions to convert cmark_nodes to groff man strings. -static -void S_outc(cmark_renderer *renderer, - cmark_escaping escape, - int32_t c, - unsigned char nextc) -{ - (void)(nextc); - - if (escape == LITERAL) { - cmark_render_code_point(renderer, c); - return; - } - - switch(c) { - case 46: - if (renderer->begin_line) { - cmark_render_ascii(renderer, "\\&."); - } else { - cmark_render_code_point(renderer, c); - } - break; - case 39: - if (renderer->begin_line) { - cmark_render_ascii(renderer, "\\&'"); - } else { - cmark_render_code_point(renderer, c); - } - break; - case 45: - cmark_render_ascii(renderer, "\\-"); - break; - case 92: - cmark_render_ascii(renderer, "\\e"); - break; - case 8216: // left single quote - cmark_render_ascii(renderer, "\\[oq]"); - break; - case 8217: // right single quote - cmark_render_ascii(renderer, "\\[cq]"); - break; - case 8220: // left double quote - cmark_render_ascii(renderer, "\\[lq]"); - break; - case 8221: // right double quote - cmark_render_ascii(renderer, "\\[rq]"); - break; - case 8212: // em dash - cmark_render_ascii(renderer, "\\[em]"); - break; - case 8211: // en dash - cmark_render_ascii(renderer, "\\[en]"); - break; - default: - cmark_render_code_point(renderer, c); - } +static void S_outc(cmark_renderer *renderer, cmark_escaping escape, int32_t c, + unsigned char nextc) { + (void)(nextc); + + if (escape == LITERAL) { + cmark_render_code_point(renderer, c); + return; + } + + switch (c) { + case 46: + if (renderer->begin_line) { + cmark_render_ascii(renderer, "\\&."); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 39: + if (renderer->begin_line) { + cmark_render_ascii(renderer, "\\&'"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 45: + cmark_render_ascii(renderer, "\\-"); + break; + case 92: + cmark_render_ascii(renderer, "\\e"); + break; + case 8216: // left single quote + cmark_render_ascii(renderer, "\\[oq]"); + break; + case 8217: // right single quote + cmark_render_ascii(renderer, "\\[cq]"); + break; + case 8220: // left double quote + cmark_render_ascii(renderer, "\\[lq]"); + break; + case 8221: // right double quote + cmark_render_ascii(renderer, "\\[rq]"); + break; + case 8212: // em dash + cmark_render_ascii(renderer, "\\[em]"); + break; + case 8211: // en dash + cmark_render_ascii(renderer, "\\[en]"); + break; + default: + cmark_render_code_point(renderer, c); + } } -static int -S_render_node(cmark_renderer *renderer, - cmark_node *node, - cmark_event_type ev_type, - int options) -{ - cmark_node *tmp; - int list_number; - bool entering = (ev_type == CMARK_EVENT_ENTER); - - // avoid unused parameter error: - (void)(options); - - switch (node->type) { - case CMARK_NODE_DOCUMENT: - break; - - case CMARK_NODE_BLOCK_QUOTE: - if (entering) { - CR(); - LIT(".RS"); - CR(); - } else { - CR(); - LIT(".RE"); - CR(); - } - break; - - case CMARK_NODE_LIST: - break; - - case CMARK_NODE_ITEM: - if (entering) { - CR(); - LIT(".IP "); - if (cmark_node_get_list_type(node->parent) == - CMARK_BULLET_LIST) { - LIT("\\[bu] 2"); - } else { - list_number = cmark_node_get_list_start(node->parent); - tmp = node; - while (tmp->prev) { - tmp = tmp->prev; - list_number += 1; - } - char list_number_s[20]; - sprintf(list_number_s, "\"%d.\" 4", list_number); - LIT(list_number_s); - } - CR(); - } else { - CR(); - } - break; - - case CMARK_NODE_HEADER: - if (entering) { - CR(); - LIT(cmark_node_get_header_level(node) == 1 ? - ".SH" : ".SS"); - CR(); - } else { - CR(); - } - break; - - case CMARK_NODE_CODE_BLOCK: - CR(); - LIT(".IP\n.nf\n\\f[C]\n"); - OUT(cmark_node_get_literal(node), - false, - NORMAL); - CR(); - LIT("\\f[]\n.fi"); - CR(); - break; - - case CMARK_NODE_HTML: - break; - - case CMARK_NODE_HRULE: - CR(); - LIT(".PP\n * * * * *"); - CR(); - 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(); - LIT(".PP"); - CR(); - } - } else { - CR(); - } - break; - - case CMARK_NODE_TEXT: - OUT(cmark_node_get_literal(node), true, NORMAL); - break; - - case CMARK_NODE_LINEBREAK: - LIT(".PD 0\n.P\n.PD"); - CR(); - break; - - case CMARK_NODE_SOFTBREAK: - if (renderer->width == 0) { - CR(); - } else { - OUT(" ", true, LITERAL); - } - break; - - case CMARK_NODE_CODE: - LIT("\\f[C]"); - OUT(cmark_node_get_literal(node), true, NORMAL); - LIT("\\f[]"); - break; - - case CMARK_NODE_INLINE_HTML: - break; - - case CMARK_NODE_STRONG: - if (entering) { - LIT("\\f[B]"); - } else { - LIT("\\f[]"); - } - break; - - case CMARK_NODE_EMPH: - if (entering) { - LIT("\\f[I]"); - } else { - LIT("\\f[]"); - } - break; - - case CMARK_NODE_LINK: - if (!entering) { - LIT(" ("); - OUT(cmark_node_get_url(node), true, URL); - LIT(")"); - } - break; - - case CMARK_NODE_IMAGE: - if (entering) { - LIT("[IMAGE: "); - } else { - LIT("]"); - } - break; - - default: - assert(false); - break; - } - - return 1; +static int S_render_node(cmark_renderer *renderer, cmark_node *node, + cmark_event_type ev_type, int options) { + cmark_node *tmp; + int list_number; + bool entering = (ev_type == CMARK_EVENT_ENTER); + + // avoid unused parameter error: + (void)(options); + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + CR(); + LIT(".RS"); + CR(); + } else { + CR(); + LIT(".RE"); + CR(); + } + break; + + case CMARK_NODE_LIST: + break; + + case CMARK_NODE_ITEM: + if (entering) { + CR(); + LIT(".IP "); + if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { + LIT("\\[bu] 2"); + } else { + list_number = cmark_node_get_list_start(node->parent); + tmp = node; + while (tmp->prev) { + tmp = tmp->prev; + list_number += 1; + } + char list_number_s[20]; + sprintf(list_number_s, "\"%d.\" 4", list_number); + LIT(list_number_s); + } + CR(); + } else { + CR(); + } + break; + + case CMARK_NODE_HEADER: + if (entering) { + CR(); + LIT(cmark_node_get_header_level(node) == 1 ? ".SH" : ".SS"); + CR(); + } else { + CR(); + } + break; + + case CMARK_NODE_CODE_BLOCK: + CR(); + LIT(".IP\n.nf\n\\f[C]\n"); + OUT(cmark_node_get_literal(node), false, NORMAL); + CR(); + LIT("\\f[]\n.fi"); + CR(); + break; + + case CMARK_NODE_HTML: + break; + + case CMARK_NODE_HRULE: + CR(); + LIT(".PP\n * * * * *"); + CR(); + 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(); + LIT(".PP"); + CR(); + } + } else { + CR(); + } + break; + + case CMARK_NODE_TEXT: + OUT(cmark_node_get_literal(node), true, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + LIT(".PD 0\n.P\n.PD"); + CR(); + break; + + case CMARK_NODE_SOFTBREAK: + if (renderer->width == 0) { + CR(); + } else { + OUT(" ", true, LITERAL); + } + break; + + case CMARK_NODE_CODE: + LIT("\\f[C]"); + OUT(cmark_node_get_literal(node), true, NORMAL); + LIT("\\f[]"); + break; + + case CMARK_NODE_INLINE_HTML: + break; + + case CMARK_NODE_STRONG: + if (entering) { + LIT("\\f[B]"); + } else { + LIT("\\f[]"); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + LIT("\\f[I]"); + } else { + LIT("\\f[]"); + } + break; + + case CMARK_NODE_LINK: + if (!entering) { + LIT(" ("); + OUT(cmark_node_get_url(node), true, URL); + LIT(")"); + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + LIT("[IMAGE: "); + } else { + LIT("]"); + } + break; + + default: + assert(false); + break; + } + + return 1; } -char *cmark_render_man(cmark_node *root, int options, int width) -{ - return cmark_render(root, options, width, S_outc, S_render_node); +char *cmark_render_man(cmark_node *root, int options, int width) { + return cmark_render(root, options, width, S_outc, S_render_node); } diff --git a/node.c b/node.c index 7b1bb10..46d234a 100644 --- a/node.c +++ b/node.c @@ -4,855 +4,762 @@ #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; +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: - cmark_chunk_free(&e->as.link.url); - cmark_chunk_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; -} - -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 cmark_chunk_to_cstr(&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: - cmark_chunk_set_cstr(&node->as.link.url, 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 cmark_chunk_to_cstr(&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: - cmark_chunk_set_cstr(&node->as.link.title, 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; +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: + cmark_chunk_free(&e->as.link.url); + cmark_chunk_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; +} + +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 == 1; + 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 cmark_chunk_to_cstr(&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: + cmark_chunk_set_cstr(&node->as.link.url, 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 cmark_chunk_to_cstr(&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: + cmark_chunk_set_cstr(&node->as.link.title, 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; - } +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; + if (node->prev) { + node->prev->next = node->next; + } + if (node->next) { + node->next->prev = node->prev; + } -} - -int -cmark_node_insert_before(cmark_node *node, cmark_node *sibling) -{ - if (node == NULL || sibling == NULL) { - return 0; - } + // 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; + } + } +} - if (!node->parent || !S_can_contain(node->parent, sibling)) { - return 0; - } - - S_node_unlink(sibling); +void cmark_node_unlink(cmark_node *node) { + S_node_unlink(node); - 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; + 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; + // 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; + +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; + for (;;) { + 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/node.h b/node.h index b579408..48d12df 100644 --- a/node.h +++ b/node.h @@ -13,68 +13,67 @@ extern "C" { #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_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_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; + int level; + bool setext; } cmark_header; typedef struct { - cmark_chunk url; - cmark_chunk title; + cmark_chunk url; + cmark_chunk 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; - int html_block_type; - } as; + 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; + int html_block_type; + } as; }; -CMARK_EXPORT int -cmark_node_check(cmark_node *node, FILE *out); +CMARK_EXPORT int cmark_node_check(cmark_node *node, FILE *out); #ifdef __cplusplus } diff --git a/parser.h b/parser.h index 01a7aeb..f359e10 100644 --- a/parser.h +++ b/parser.h @@ -12,20 +12,20 @@ extern "C" { #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; - bufsize_t offset; - bufsize_t column; - bufsize_t first_nonspace; - bufsize_t first_nonspace_column; - int indent; - bool blank; - cmark_strbuf *curline; - bufsize_t last_line_length; - cmark_strbuf *linebuf; - int options; + struct cmark_reference_map *refmap; + struct cmark_node *root; + struct cmark_node *current; + int line_number; + bufsize_t offset; + bufsize_t column; + bufsize_t first_nonspace; + bufsize_t first_nonspace_column; + int indent; + bool blank; + cmark_strbuf *curline; + bufsize_t last_line_length; + cmark_strbuf *linebuf; + int options; }; #ifdef __cplusplus diff --git a/references.c b/references.c index 1d3d56d..6cb2b20 100644 --- a/references.c +++ b/references.c @@ -5,150 +5,140 @@ #include "inlines.h" #include "chunk.h" -static unsigned int -refhash(const unsigned char *link_ref) -{ - unsigned int hash = 0; +static unsigned int refhash(const unsigned char *link_ref) { + unsigned int hash = 0; - while (*link_ref) - hash = (*link_ref++) + (hash << 6) + (hash << 16) - hash; + while (*link_ref) + hash = (*link_ref++) + (hash << 6) + (hash << 16) - hash; - return hash; + return hash; } -static void reference_free(cmark_reference *ref) -{ - if(ref != NULL) { - free(ref->label); - cmark_chunk_free(&ref->url); - cmark_chunk_free(&ref->title); - free(ref); - } +static void reference_free(cmark_reference *ref) { + if (ref != NULL) { + free(ref->label); + cmark_chunk_free(&ref->url); + cmark_chunk_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; +static unsigned char *normalize_reference(cmark_chunk *ref) { + cmark_strbuf normalized = GH_BUF_INIT; + unsigned char *result; - if(ref == NULL) - return NULL; + if (ref == NULL) + return NULL; - if (ref->len == 0) - 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); + cmark_utf8proc_case_fold(&normalized, ref->data, ref->len); + cmark_strbuf_trim(&normalized); + cmark_strbuf_normalize_whitespace(&normalized); - result = cmark_strbuf_detach(&normalized); - assert(result); + result = cmark_strbuf_detach(&normalized); + assert(result); - if (result[0] == '\0') { - free(result); - return NULL; - } + if (result[0] == '\0') { + free(result); + return NULL; + } - return result; + return result; } -static void add_reference(cmark_reference_map *map, cmark_reference* ref) -{ - cmark_reference *t = ref->next = map->table[ref->hash % REFMAP_SIZE]; +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; - } + while (t) { + if (t->hash == ref->hash && !strcmp((char *)t->label, (char *)ref->label)) { + reference_free(ref); + return; + } - t = t->next; - } + t = t->next; + } - map->table[ref->hash % REFMAP_SIZE] = ref; + 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); - } +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; +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; +void cmark_reference_map_free(cmark_reference_map *map) { + unsigned int i; - if(map == NULL) - return; + if (map == NULL) + return; - for (i = 0; i < REFMAP_SIZE; ++i) { - cmark_reference *ref = map->table[i]; - cmark_reference *next; + 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; - } - } + while (ref) { + next = ref->next; + reference_free(ref); + ref = next; + } + } - free(map); + free(map); } -cmark_reference_map *cmark_reference_map_new(void) -{ - return (cmark_reference_map *)calloc(1, sizeof(cmark_reference_map)); +cmark_reference_map *cmark_reference_map_new(void) { + return (cmark_reference_map *)calloc(1, sizeof(cmark_reference_map)); } diff --git a/references.h b/references.h index a360cd5..310ff9f 100644 --- a/references.h +++ b/references.h @@ -10,25 +10,27 @@ extern "C" { #define REFMAP_SIZE 16 struct cmark_reference { - struct cmark_reference *next; - unsigned char *label; - cmark_chunk url; - cmark_chunk title; - unsigned int hash; + struct cmark_reference *next; + unsigned char *label; + cmark_chunk url; + cmark_chunk title; + unsigned int hash; }; typedef struct cmark_reference cmark_reference; struct cmark_reference_map { - cmark_reference *table[REFMAP_SIZE]; + 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); +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 } diff --git a/render.c b/render.c index 2f1faac..f1ec672 100644 --- a/render.c +++ b/render.c @@ -5,182 +5,159 @@ #include "utf8.h" #include "render.h" -static inline -void S_cr(cmark_renderer *renderer) -{ - if (renderer->need_cr < 1) { - renderer->need_cr = 1; - } +static inline void S_cr(cmark_renderer *renderer) { + if (renderer->need_cr < 1) { + renderer->need_cr = 1; + } } -static inline -void S_blankline(cmark_renderer *renderer) -{ - if (renderer->need_cr < 2) { - renderer->need_cr = 2; - } +static inline void S_blankline(cmark_renderer *renderer) { + if (renderer->need_cr < 2) { + renderer->need_cr = 2; + } } -static -void S_out(cmark_renderer *renderer, - const char *source, - bool wrap, - cmark_escaping escape) -{ - int length = cmark_strbuf_safe_strlen(source); - unsigned char nextc; - int32_t c; - int i = 0; - int len; - cmark_chunk remainder = cmark_chunk_literal(""); - int k = renderer->buffer->size - 1; - - wrap = wrap && !renderer->no_wrap; - - if (renderer->in_tight_list_item && renderer->need_cr > 1) { - renderer->need_cr = 1; - } - while (renderer->need_cr) { - if (k < 0 || renderer->buffer->ptr[k] == '\n') { - k -= 1; - } else { - cmark_strbuf_putc(renderer->buffer, '\n'); - if (renderer->need_cr > 1) { - cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, - renderer->prefix->size); - } - } - renderer->column = 0; - renderer->begin_line = true; - renderer->need_cr -= 1; - } - - while (i < length) { - if (renderer->begin_line) { - cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, - renderer->prefix->size); - // note: this assumes prefix is ascii: - renderer->column = renderer->prefix->size; - } - - len = utf8proc_iterate((const uint8_t *)source + i, length - i, &c); - if (len == -1) { // error condition - return; // return without rendering rest of string - } - nextc = source[i + len]; - if (c == 32 && wrap) { - if (!renderer->begin_line) { - cmark_strbuf_putc(renderer->buffer, ' '); - renderer->column += 1; - renderer->begin_line = false; - renderer->last_breakable = renderer->buffer->size - - 1; - // skip following spaces - while (source[i + 1] == ' ') { - i++; - } - } - - } else if (c == 10) { - cmark_strbuf_putc(renderer->buffer, '\n'); - renderer->column = 0; - renderer->begin_line = true; - renderer->last_breakable = 0; - } else if (escape == LITERAL) { - cmark_render_code_point(renderer, c); - renderer->begin_line = false; - } else { - (renderer->outc)(renderer, escape, c, nextc); - renderer->begin_line = false; - } - - // If adding the character went beyond width, look for an - // earlier place where the line could be broken: - if (renderer->width > 0 && - renderer->column > renderer->width && - !renderer->begin_line && - renderer->last_breakable > 0) { - - // copy from last_breakable to remainder - cmark_chunk_set_cstr(&remainder, (char *) renderer->buffer->ptr + renderer->last_breakable + 1); - // truncate at last_breakable - cmark_strbuf_truncate(renderer->buffer, renderer->last_breakable); - // add newline, prefix, and remainder - cmark_strbuf_putc(renderer->buffer, '\n'); - cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, - renderer->prefix->size); - cmark_strbuf_put(renderer->buffer, remainder.data, remainder.len); - renderer->column = renderer->prefix->size + remainder.len; - cmark_chunk_free(&remainder); - renderer->last_breakable = 0; - renderer->begin_line = false; - } - - i += len; - } +static void S_out(cmark_renderer *renderer, const char *source, bool wrap, + cmark_escaping escape) { + int length = cmark_strbuf_safe_strlen(source); + unsigned char nextc; + int32_t c; + int i = 0; + int len; + cmark_chunk remainder = cmark_chunk_literal(""); + int k = renderer->buffer->size - 1; + + wrap = wrap && !renderer->no_wrap; + + if (renderer->in_tight_list_item && renderer->need_cr > 1) { + renderer->need_cr = 1; + } + while (renderer->need_cr) { + if (k < 0 || renderer->buffer->ptr[k] == '\n') { + k -= 1; + } else { + cmark_strbuf_putc(renderer->buffer, '\n'); + if (renderer->need_cr > 1) { + cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, + renderer->prefix->size); + } + } + renderer->column = 0; + renderer->begin_line = true; + renderer->need_cr -= 1; + } + + while (i < length) { + if (renderer->begin_line) { + cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, + renderer->prefix->size); + // note: this assumes prefix is ascii: + renderer->column = renderer->prefix->size; + } + + len = cmark_utf8proc_iterate((const uint8_t *)source + i, length - i, &c); + if (len == -1) { // error condition + return; // return without rendering rest of string + } + nextc = source[i + len]; + if (c == 32 && wrap) { + if (!renderer->begin_line) { + cmark_strbuf_putc(renderer->buffer, ' '); + renderer->column += 1; + renderer->begin_line = false; + renderer->last_breakable = renderer->buffer->size - 1; + // skip following spaces + while (source[i + 1] == ' ') { + i++; + } + } + + } else if (c == 10) { + cmark_strbuf_putc(renderer->buffer, '\n'); + renderer->column = 0; + renderer->begin_line = true; + renderer->last_breakable = 0; + } else if (escape == LITERAL) { + cmark_render_code_point(renderer, c); + renderer->begin_line = false; + } else { + (renderer->outc)(renderer, escape, c, nextc); + renderer->begin_line = false; + } + + // If adding the character went beyond width, look for an + // earlier place where the line could be broken: + if (renderer->width > 0 && renderer->column > renderer->width && + !renderer->begin_line && renderer->last_breakable > 0) { + + // copy from last_breakable to remainder + cmark_chunk_set_cstr(&remainder, (char *)renderer->buffer->ptr + + renderer->last_breakable + 1); + // truncate at last_breakable + cmark_strbuf_truncate(renderer->buffer, renderer->last_breakable); + // add newline, prefix, and remainder + cmark_strbuf_putc(renderer->buffer, '\n'); + cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, + renderer->prefix->size); + cmark_strbuf_put(renderer->buffer, remainder.data, remainder.len); + renderer->column = renderer->prefix->size + remainder.len; + cmark_chunk_free(&remainder); + renderer->last_breakable = 0; + renderer->begin_line = false; + } + + i += len; + } } // Assumes no newlines, assumes ascii content: -void -cmark_render_ascii(cmark_renderer* renderer, const char* s) -{ - int origsize = renderer->buffer->size; - cmark_strbuf_puts(renderer->buffer, s); - renderer->column += renderer->buffer->size - origsize; +void cmark_render_ascii(cmark_renderer *renderer, const char *s) { + int origsize = renderer->buffer->size; + cmark_strbuf_puts(renderer->buffer, s); + renderer->column += renderer->buffer->size - origsize; } -void -cmark_render_code_point(cmark_renderer *renderer, uint32_t c) -{ - utf8proc_encode_char(c, renderer->buffer); - renderer->column += 1; +void cmark_render_code_point(cmark_renderer *renderer, uint32_t c) { + cmark_utf8proc_encode_char(c, renderer->buffer); + renderer->column += 1; } -char* -cmark_render(cmark_node *root, - int options, - int width, - void (*outc)(cmark_renderer*, - cmark_escaping, - int32_t, - unsigned char), - int (*render_node)(cmark_renderer *renderer, - cmark_node *node, - cmark_event_type ev_type, - int options)) -{ - cmark_strbuf pref = GH_BUF_INIT; - cmark_strbuf buf = GH_BUF_INIT; - cmark_node *cur; - cmark_event_type ev_type; - char *result; - cmark_iter *iter = cmark_iter_new(root); - - cmark_renderer renderer = { &buf, &pref, 0, width, - 0, 0, true, false, false, - outc, S_cr, S_blankline, S_out - }; - - while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { - cur = cmark_iter_get_node(iter); - if (!render_node(&renderer, cur, ev_type, options)) { - // a false value causes us to skip processing - // the node's contents. this is used for - // autolinks. - cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT); - } - } - - // ensure final newline - if (renderer.buffer->ptr[renderer.buffer->size - 1] != '\n') { - cmark_strbuf_putc(renderer.buffer, '\n'); - } - - result = (char *)cmark_strbuf_detach(renderer.buffer); - - cmark_iter_free(iter); - cmark_strbuf_free(renderer.prefix); - cmark_strbuf_free(renderer.buffer); - - return result; +char *cmark_render(cmark_node *root, int options, int width, + void (*outc)(cmark_renderer *, cmark_escaping, int32_t, + unsigned char), + int (*render_node)(cmark_renderer *renderer, + cmark_node *node, + cmark_event_type ev_type, int options)) { + cmark_strbuf pref = GH_BUF_INIT; + cmark_strbuf buf = GH_BUF_INIT; + cmark_node *cur; + cmark_event_type ev_type; + char *result; + cmark_iter *iter = cmark_iter_new(root); + + cmark_renderer renderer = {&buf, &pref, 0, width, 0, 0, true, + false, false, outc, S_cr, S_blankline, S_out}; + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + if (!render_node(&renderer, cur, ev_type, options)) { + // a false value causes us to skip processing + // the node's contents. this is used for + // autolinks. + cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT); + } + } + + // ensure final newline + if (renderer.buffer->ptr[renderer.buffer->size - 1] != '\n') { + cmark_strbuf_putc(renderer.buffer, '\n'); + } + + result = (char *)cmark_strbuf_detach(renderer.buffer); + + cmark_iter_free(iter); + cmark_strbuf_free(renderer.prefix); + cmark_strbuf_free(renderer.buffer); + + return result; } diff --git a/render.h b/render.h index ca541bc..9ab347b 100644 --- a/render.h +++ b/render.h @@ -9,55 +9,36 @@ extern "C" { #include "buffer.h" #include "chunk.h" -typedef enum { - LITERAL, - NORMAL, - TITLE, - URL -} cmark_escaping; +typedef enum { LITERAL, NORMAL, TITLE, URL } cmark_escaping; struct cmark_renderer { - cmark_strbuf* buffer; - cmark_strbuf* prefix; - int column; - int width; - int need_cr; - bufsize_t last_breakable; - bool begin_line; - bool no_wrap; - bool in_tight_list_item; - void (*outc)(struct cmark_renderer*, - cmark_escaping, - int32_t, - unsigned char); - void (*cr)(struct cmark_renderer*); - void (*blankline)(struct cmark_renderer*); - void (*out)(struct cmark_renderer*, - const char *, - bool, - cmark_escaping); + cmark_strbuf *buffer; + cmark_strbuf *prefix; + int column; + int width; + int need_cr; + bufsize_t last_breakable; + bool begin_line; + bool no_wrap; + bool in_tight_list_item; + void (*outc)(struct cmark_renderer *, cmark_escaping, int32_t, unsigned char); + void (*cr)(struct cmark_renderer *); + void (*blankline)(struct cmark_renderer *); + void (*out)(struct cmark_renderer *, const char *, bool, cmark_escaping); }; typedef struct cmark_renderer cmark_renderer; -void -cmark_render_ascii(cmark_renderer *renderer, const char* s); +void cmark_render_ascii(cmark_renderer *renderer, const char *s); -void -cmark_render_code_point(cmark_renderer *renderer, uint32_t c); +void cmark_render_code_point(cmark_renderer *renderer, uint32_t c); -char* -cmark_render(cmark_node *root, - int options, - int width, - void (*outc)(cmark_renderer*, - cmark_escaping, - int32_t, - unsigned char), - int (*render_node)(cmark_renderer *renderer, - cmark_node *node, - cmark_event_type ev_type, - int options)); +char *cmark_render(cmark_node *root, int options, int width, + void (*outc)(cmark_renderer *, cmark_escaping, int32_t, + unsigned char), + int (*render_node)(cmark_renderer *renderer, + cmark_node *node, + cmark_event_type ev_type, int options)); #ifdef __cplusplus } diff --git a/scanners.c b/scanners.c index 75fdb46..7868e01 100644 --- a/scanners.c +++ b/scanners.c @@ -3,21045 +3,27837 @@ #include "chunk.h" #include "scanners.h" -bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, bufsize_t offset) -{ - bufsize_t res; - unsigned char *ptr = (unsigned char *)c->data; - unsigned char lim = ptr[c->len]; +bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, + bufsize_t offset) { + bufsize_t 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; + ptr[c->len] = '\0'; + res = scanner(ptr + offset); + ptr[c->len] = lim; - return res; + return res; } - - // Try to match a scheme including colon. -bufsize_t _scan_scheme(const unsigned char *p) -{ +bufsize_t _scan_scheme(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; -{ - unsigned char yych; - - yych = *(marker = p); - if (yych <= 'c') { - if (yych <= 'M') { - if (yych <= 'E') { - if (yych <= 'A') { - if (yych == '\n') goto yy2; - if (yych <= '@') goto yy29; - goto yy6; - } else { - if (yych <= 'B') goto yy24; - if (yych <= 'C') goto yy3; - if (yych <= 'D') goto yy4; - goto yy25; - } - } else { - if (yych <= 'I') { - if (yych <= 'F') goto yy7; - if (yych <= 'G') goto yy8; - if (yych <= 'H') goto yy9; - goto yy10; - } else { - if (yych <= 'J') goto yy5; - if (yych <= 'K') goto yy26; - if (yych <= 'L') goto yy11; - goto yy12; - } - } - } else { - if (yych <= 'U') { - if (yych <= 'Q') { - if (yych <= 'N') goto yy13; - if (yych <= 'O') goto yy14; - if (yych <= 'P') goto yy15; - goto yy27; - } else { - if (yych <= 'R') goto yy16; - if (yych <= 'S') goto yy17; - if (yych <= 'T') goto yy18; - goto yy19; - } - } else { - if (yych <= 'Y') { - if (yych <= 'V') goto yy20; - if (yych <= 'W') goto yy21; - if (yych <= 'X') goto yy22; - goto yy28; - } else { - if (yych <= '`') { - if (yych <= 'Z') goto yy23; - goto yy29; - } else { - if (yych <= 'a') goto yy6; - if (yych <= 'b') goto yy24; - goto yy3; - } - } - } - } - } else { - if (yych <= 't') { - if (yych <= 'k') { - if (yych <= 'g') { - if (yych <= 'd') goto yy4; - if (yych <= 'e') goto yy25; - if (yych <= 'f') goto yy7; - goto yy8; - } else { - if (yych <= 'h') goto yy9; - if (yych <= 'i') goto yy10; - if (yych <= 'j') goto yy5; - goto yy26; - } - } else { - if (yych <= 'o') { - if (yych <= 'l') goto yy11; - if (yych <= 'm') goto yy12; - if (yych <= 'n') goto yy13; - goto yy14; - } else { - if (yych <= 'q') { - if (yych <= 'p') goto yy15; - goto yy27; - } else { - if (yych <= 'r') goto yy16; - if (yych <= 's') goto yy17; - goto yy18; - } - } - } - } else { - if (yych <= 0xC1) { - if (yych <= 'x') { - if (yych <= 'u') goto yy19; - if (yych <= 'v') goto yy20; - if (yych <= 'w') goto yy21; - goto yy22; - } else { - if (yych <= 'y') goto yy28; - if (yych <= 'z') goto yy23; - if (yych <= 0x7F) goto yy29; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy30; - if (yych <= 0xE0) goto yy32; - if (yych <= 0xEC) goto yy33; - goto yy37; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy33; - goto yy34; - } else { - if (yych <= 0xF3) goto yy35; - if (yych <= 0xF4) goto yy36; - } - } - } - } - } -yy2: - { return 0; } -yy3: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy447; - case 'H': - case 'h': goto yy446; - case 'I': - case 'i': goto yy449; - case 'O': - case 'o': goto yy445; - case 'R': - case 'r': goto yy448; - case 'V': - case 'v': goto yy444; - default: goto yy2; - } -yy4: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy420; - case 'I': - case 'i': goto yy419; - case 'L': - case 'l': goto yy417; - case 'N': - case 'n': goto yy418; - case 'O': - case 'o': goto yy421; - case 'T': - case 't': goto yy416; - case 'V': - case 'v': goto yy415; - default: goto yy2; - } -yy5: - yych = *(marker = ++p); - if (yych <= 'M') { - if (yych == 'A') goto yy407; - if (yych <= 'L') goto yy2; - goto yy406; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy2; - goto yy407; - } else { - if (yych == 'm') goto yy406; - goto yy2; - } - } -yy6: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy388; - case 'B': - case 'b': goto yy387; - case 'C': - case 'c': goto yy386; - case 'D': - case 'd': goto yy385; - case 'F': - case 'f': goto yy384; - case 'I': - case 'i': goto yy383; - case 'P': - case 'p': goto yy382; - case 'T': - case 't': goto yy381; - case 'W': - case 'w': goto yy41; - default: goto yy2; - } -yy7: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'E') { - if (yych == 'A') goto yy368; - if (yych <= 'D') goto yy2; - goto yy367; - } else { - if (yych == 'I') goto yy366; - if (yych <= 'S') goto yy2; - goto yy369; - } - } else { - if (yych <= 'e') { - if (yych == 'a') goto yy368; - if (yych <= 'd') goto yy2; - goto yy367; - } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy2; - goto yy366; - } else { - if (yych == 't') goto yy369; - goto yy2; - } - } - } -yy8: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': goto yy351; - case 'G': - case 'g': goto yy41; - case 'I': - case 'i': goto yy349; - case 'O': - case 'o': goto yy350; - case 'T': - case 't': goto yy348; - default: goto yy2; - } -yy9: - yych = *(marker = ++p); - if (yych <= 'S') { - if (yych <= '3') { - if (yych <= '2') goto yy2; - goto yy344; - } else { - if (yych == 'C') goto yy342; - goto yy2; - } - } else { - if (yych <= 'c') { - if (yych <= 'T') goto yy343; - if (yych <= 'b') goto yy2; - goto yy342; - } else { - if (yych == 't') goto yy343; - goto yy2; - } - } -yy10: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy324; - case 'C': - case 'c': goto yy321; - case 'M': - case 'm': goto yy323; - case 'N': - case 'n': goto yy322; - case 'P': - case 'p': goto yy320; - case 'R': - case 'r': goto yy319; - case 'T': - case 't': goto yy318; - default: goto yy2; - } -yy11: - yych = *(marker = ++p); - if (yych <= 'D') { - if (yych == 'A') goto yy312; - if (yych <= 'C') goto yy2; - goto yy311; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy2; - goto yy312; - } else { - if (yych == 'd') goto yy311; - goto yy2; - } - } -yy12: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy278; - case 'E': - case 'e': goto yy277; - case 'I': - case 'i': goto yy280; - case 'M': - case 'm': goto yy276; - case 'S': - case 's': goto yy275; - case 'T': - case 't': goto yy279; - case 'U': - case 'u': goto yy274; - case 'V': - case 'v': goto yy273; - default: goto yy2; - } -yy13: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': goto yy268; - case 'F': - case 'f': goto yy267; - case 'I': - case 'i': goto yy266; - case 'N': - case 'n': goto yy265; - case 'O': - case 'o': goto yy264; - default: goto yy2; - } -yy14: - yych = *(marker = ++p); - if (yych <= 'P') { - if (yych == 'I') goto yy250; - if (yych <= 'O') goto yy2; - goto yy251; - } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy2; - goto yy250; - } else { - if (yych == 'p') goto yy251; - goto yy2; - } - } -yy15: - yych = *(marker = ++p); - if (yych <= 'S') { - if (yych <= 'L') { - if (yych == 'A') goto yy232; - if (yych <= 'K') goto yy2; - goto yy231; - } else { - if (yych <= 'O') { - if (yych <= 'N') goto yy2; - goto yy233; - } else { - if (yych <= 'Q') goto yy2; - if (yych <= 'R') goto yy230; - goto yy229; - } - } - } else { - if (yych <= 'n') { - if (yych <= 'a') { - if (yych <= '`') goto yy2; - goto yy232; - } else { - if (yych == 'l') goto yy231; - goto yy2; - } - } else { - if (yych <= 'q') { - if (yych <= 'o') goto yy233; - goto yy2; - } else { - if (yych <= 'r') goto yy230; - if (yych <= 's') goto yy229; - goto yy2; - } - } - } -yy16: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'L') { - if (yych == 'E') goto yy219; - goto yy2; - } else { - if (yych <= 'M') goto yy218; - if (yych <= 'R') goto yy2; - if (yych <= 'S') goto yy217; - goto yy216; - } - } else { - if (yych <= 'm') { - if (yych == 'e') goto yy219; - if (yych <= 'l') goto yy2; - goto yy218; - } else { - if (yych <= 'r') goto yy2; - if (yych <= 's') goto yy217; - if (yych <= 't') goto yy216; - goto yy2; - } - } -yy17: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': goto yy172; - case 'F': - case 'f': goto yy171; - case 'G': - case 'g': goto yy170; - case 'H': - case 'h': goto yy175; - case 'I': - case 'i': goto yy174; - case 'K': - case 'k': goto yy169; - case 'M': - case 'm': goto yy168; - case 'N': - case 'n': goto yy173; - case 'O': - case 'o': goto yy167; - case 'P': - case 'p': goto yy166; - case 'S': - case 's': goto yy165; - case 'T': - case 't': goto yy164; - case 'V': - case 'v': goto yy163; - default: goto yy2; - } -yy18: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy139; - case 'E': - case 'e': goto yy135; - case 'F': - case 'f': goto yy138; - case 'H': - case 'h': goto yy134; - case 'I': - case 'i': goto yy136; - case 'N': - case 'n': goto yy137; - case 'V': - case 'v': goto yy41; - default: goto yy2; - } -yy19: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'N') { - if (yych == 'D') goto yy126; - if (yych <= 'M') goto yy2; - goto yy125; - } else { - if (yych == 'R') goto yy127; - if (yych <= 'S') goto yy2; - goto yy124; - } - } else { - if (yych <= 'n') { - if (yych == 'd') goto yy126; - if (yych <= 'm') goto yy2; - goto yy125; - } else { - if (yych <= 'r') { - if (yych <= 'q') goto yy2; - goto yy127; - } else { - if (yych == 't') goto yy124; - goto yy2; - } - } - } -yy20: - yych = *(marker = ++p); - if (yych <= 'I') { - if (yych == 'E') goto yy108; - if (yych <= 'H') goto yy2; - goto yy107; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy2; - goto yy108; - } else { - if (yych == 'i') goto yy107; - goto yy2; - } - } -yy21: - yych = *(marker = ++p); - if (yych <= 'Y') { - if (yych <= 'R') { - if (yych == 'E') goto yy97; - goto yy2; - } else { - if (yych <= 'S') goto yy98; - if (yych <= 'T') goto yy96; - if (yych <= 'X') goto yy2; - goto yy95; - } - } else { - if (yych <= 's') { - if (yych == 'e') goto yy97; - if (yych <= 'r') goto yy2; - goto yy98; - } else { - if (yych <= 't') goto yy96; - if (yych == 'y') goto yy95; - goto yy2; - } - } -yy22: - yych = *(marker = ++p); - if (yych <= 'R') { - if (yych <= 'F') { - if (yych == 'C') goto yy74; - if (yych <= 'E') goto yy2; - goto yy72; - } else { - if (yych == 'M') goto yy73; - if (yych <= 'Q') goto yy2; - goto yy71; - } - } else { - if (yych <= 'f') { - if (yych == 'c') goto yy74; - if (yych <= 'e') goto yy2; - goto yy72; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy2; - goto yy73; - } else { - if (yych == 'r') goto yy71; - goto yy2; - } - } - } -yy23: - yych = *(marker = ++p); - if (yych == '3') goto yy66; - goto yy2; -yy24: - yych = *(marker = ++p); - if (yych <= 'O') { - if (yych <= 'H') { - if (yych == 'E') goto yy56; - goto yy2; - } else { - if (yych <= 'I') goto yy55; - if (yych <= 'N') goto yy2; - goto yy54; - } - } else { - if (yych <= 'h') { - if (yych == 'e') goto yy56; - goto yy2; - } else { - if (yych <= 'i') goto yy55; - if (yych == 'o') goto yy54; - goto yy2; - } - } -yy25: - yych = *(marker = ++p); - if (yych == 'D') goto yy52; - if (yych == 'd') goto yy52; - goto yy2; -yy26: - yych = *(marker = ++p); - if (yych == 'E') goto yy47; - if (yych == 'e') goto yy47; - goto yy2; -yy27: - yych = *(marker = ++p); - if (yych == 'U') goto yy44; - if (yych == 'u') goto yy44; - goto yy2; -yy28: - yych = *(marker = ++p); - if (yych == 'M') goto yy38; - if (yych == 'm') goto yy38; - goto yy2; -yy29: - yych = *++p; - goto yy2; -yy30: - yych = *++p; - if (yych <= 0x7F) goto yy31; - if (yych <= 0xBF) goto yy29; -yy31: - p = marker; - goto yy2; -yy32: - yych = *++p; - if (yych <= 0x9F) goto yy31; - if (yych <= 0xBF) goto yy30; - goto yy31; -yy33: - yych = *++p; - if (yych <= 0x7F) goto yy31; - if (yych <= 0xBF) goto yy30; - goto yy31; -yy34: - yych = *++p; - if (yych <= 0x8F) goto yy31; - if (yych <= 0xBF) goto yy33; - goto yy31; -yy35: - yych = *++p; - if (yych <= 0x7F) goto yy31; - if (yych <= 0xBF) goto yy33; - goto yy31; -yy36: - yych = *++p; - if (yych <= 0x7F) goto yy31; - if (yych <= 0x8F) goto yy33; - goto yy31; -yy37: - yych = *++p; - if (yych <= 0x7F) goto yy31; - if (yych <= 0x9F) goto yy30; - goto yy31; -yy38: - yych = *++p; - if (yych == 'S') goto yy39; - if (yych != 's') goto yy31; -yy39: - yych = *++p; - if (yych == 'G') goto yy40; - if (yych != 'g') goto yy31; -yy40: - yych = *++p; - if (yych == 'R') goto yy41; - if (yych != 'r') goto yy31; -yy41: - yych = *++p; - if (yych != ':') goto yy31; -yy42: - ++p; - { return (bufsize_t)(p - start); } -yy44: - yych = *++p; - if (yych == 'E') goto yy45; - if (yych != 'e') goto yy31; -yy45: - yych = *++p; - if (yych == 'R') goto yy46; - if (yych != 'r') goto yy31; -yy46: - yych = *++p; - if (yych == 'Y') goto yy41; - if (yych == 'y') goto yy41; - goto yy31; -yy47: - yych = *++p; - if (yych == 'Y') goto yy48; - if (yych != 'y') goto yy31; -yy48: - yych = *++p; - if (yych == 'P') goto yy49; - if (yych != 'p') goto yy31; -yy49: - yych = *++p; - if (yych == 'A') goto yy50; - if (yych != 'a') goto yy31; -yy50: - yych = *++p; - if (yych == 'R') goto yy51; - if (yych != 'r') goto yy31; -yy51: - yych = *++p; - if (yych == 'C') goto yy41; - if (yych == 'c') goto yy41; - goto yy31; -yy52: - yych = *++p; - if (yych != '2') goto yy31; - yych = *++p; - if (yych == 'K') goto yy41; - if (yych == 'k') goto yy41; - goto yy31; -yy54: - yych = *++p; - if (yych == 'L') goto yy65; - if (yych == 'l') goto yy65; - goto yy31; -yy55: - yych = *++p; - if (yych == 'T') goto yy61; - if (yych == 't') goto yy61; - goto yy31; -yy56: - yych = *++p; - if (yych == 'S') goto yy57; - if (yych != 's') goto yy31; -yy57: - yych = *++p; - if (yych == 'H') goto yy58; - if (yych != 'h') goto yy31; -yy58: - yych = *++p; - if (yych == 'A') goto yy59; - if (yych != 'a') goto yy31; -yy59: - yych = *++p; - if (yych == 'R') goto yy60; - if (yych != 'r') goto yy31; -yy60: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy61: - yych = *++p; - if (yych == 'C') goto yy62; - if (yych != 'c') goto yy31; -yy62: - yych = *++p; - if (yych == 'O') goto yy63; - if (yych != 'o') goto yy31; -yy63: - yych = *++p; - if (yych == 'I') goto yy64; - if (yych != 'i') goto yy31; -yy64: - yych = *++p; - if (yych == 'N') goto yy41; - if (yych == 'n') goto yy41; - goto yy31; -yy65: - yych = *++p; - if (yych == 'O') goto yy41; - if (yych == 'o') goto yy41; - goto yy31; -yy66: - 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 yy41; - if (yych <= 'q') goto yy31; - if (yych <= 's') goto yy41; - goto yy31; -yy71: - yych = *++p; - if (yych == 'I') goto yy41; - if (yych == 'i') goto yy41; - goto yy31; -yy72: - yych = *++p; - if (yych == 'I') goto yy93; - if (yych == 'i') goto yy93; - goto yy31; -yy73: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy83; - if (yych <= 'O') goto yy31; - goto yy84; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy31; - goto yy83; - } else { - if (yych == 'p') goto yy84; - goto yy31; - } - } -yy74: - yych = *++p; - if (yych == 'O') goto yy75; - if (yych != 'o') goto yy31; -yy75: - yych = *++p; - if (yych == 'N') goto yy76; - if (yych != 'n') goto yy31; -yy76: - yych = *++p; - if (yych == '-') goto yy77; - if (yych == ':') goto yy42; - goto yy31; -yy77: - yych = *++p; - if (yych == 'U') goto yy78; - if (yych != 'u') goto yy31; -yy78: - yych = *++p; - if (yych == 'S') goto yy79; - if (yych != 's') goto yy31; -yy79: - yych = *++p; - if (yych == 'E') goto yy80; - if (yych != 'e') goto yy31; -yy80: - yych = *++p; - if (yych == 'R') goto yy81; - if (yych != 'r') goto yy31; -yy81: - yych = *++p; - if (yych == 'I') goto yy82; - if (yych != 'i') goto yy31; -yy82: - yych = *++p; - if (yych == 'D') goto yy41; - if (yych == 'd') goto yy41; - goto yy31; -yy83: - yych = *++p; - if (yych == 'R') goto yy85; - if (yych == 'r') goto yy85; - goto yy31; -yy84: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy85: - yych = *++p; - if (yych == 'P') goto yy86; - if (yych != 'p') goto yy31; -yy86: - yych = *++p; - if (yych == 'C') goto yy87; - if (yych != 'c') goto yy31; -yy87: - yych = *++p; - if (yych != '.') goto yy31; - yych = *++p; - if (yych == 'B') goto yy89; - if (yych != 'b') goto yy31; -yy89: - yych = *++p; - if (yych == 'E') goto yy90; - if (yych != 'e') goto yy31; -yy90: - yych = *++p; - if (yych == 'E') goto yy91; - if (yych != 'e') goto yy31; -yy91: - yych = *++p; - if (yych == 'P') goto yy92; - if (yych != 'p') goto yy31; -yy92: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; - } -yy93: - yych = *++p; - if (yych == 'R') goto yy94; - if (yych != 'r') goto yy31; -yy94: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy95: - yych = *++p; - if (yych == 'C') goto yy103; - if (yych == 'c') goto yy103; - goto yy31; -yy96: - yych = *++p; - if (yych == 'A') goto yy102; - if (yych == 'a') goto yy102; - goto yy31; -yy97: - yych = *++p; - if (yych == 'B') goto yy99; - if (yych == 'b') goto yy99; - goto yy31; -yy98: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; - } -yy99: - yych = *++p; - if (yych == 'C') goto yy100; - if (yych != 'c') goto yy31; -yy100: - yych = *++p; - if (yych == 'A') goto yy101; - if (yych != 'a') goto yy31; -yy101: - yych = *++p; - if (yych == 'L') goto yy41; - if (yych == 'l') goto yy41; - goto yy31; -yy102: - yych = *++p; - if (yych == 'I') goto yy41; - if (yych == 'i') goto yy41; - goto yy31; -yy103: - yych = *++p; - if (yych == 'I') goto yy104; - if (yych != 'i') goto yy31; -yy104: - yych = *++p; - if (yych == 'W') goto yy105; - if (yych != 'w') goto yy31; -yy105: - yych = *++p; - if (yych == 'Y') goto yy106; - if (yych != 'y') goto yy31; -yy106: - yych = *++p; - if (yych == 'G') goto yy41; - if (yych == 'g') goto yy41; - goto yy31; -yy107: - yych = *++p; - if (yych == 'E') goto yy116; - if (yych == 'e') goto yy116; - goto yy31; -yy108: - yych = *++p; - if (yych <= 'N') { - if (yych <= 'L') goto yy31; - if (yych >= 'N') goto yy110; - } else { - if (yych <= 'l') goto yy31; - if (yych <= 'm') goto yy109; - if (yych <= 'n') goto yy110; - goto yy31; - } -yy109: - yych = *++p; - if (yych == 'M') goto yy115; - if (yych == 'm') goto yy115; - goto yy31; -yy110: - yych = *++p; - if (yych == 'T') goto yy111; - if (yych != 't') goto yy31; -yy111: - yych = *++p; - if (yych == 'R') goto yy112; - if (yych != 'r') goto yy31; -yy112: - yych = *++p; - if (yych == 'I') goto yy113; - if (yych != 'i') goto yy31; -yy113: - yych = *++p; - if (yych == 'L') goto yy114; - if (yych != 'l') goto yy31; -yy114: - yych = *++p; - if (yych == 'O') goto yy41; - if (yych == 'o') goto yy41; - goto yy31; -yy115: - yych = *++p; - if (yych == 'I') goto yy41; - if (yych == 'i') goto yy41; - goto yy31; -yy116: - yych = *++p; - if (yych == 'W') goto yy117; - if (yych != 'w') goto yy31; -yy117: - yych = *++p; - if (yych != '-') goto yy31; - yych = *++p; - if (yych == 'S') goto yy119; - if (yych != 's') goto yy31; -yy119: - yych = *++p; - if (yych == 'O') goto yy120; - if (yych != 'o') goto yy31; -yy120: - yych = *++p; - if (yych == 'U') goto yy121; - if (yych != 'u') goto yy31; -yy121: - yych = *++p; - if (yych == 'R') goto yy122; - if (yych != 'r') goto yy31; -yy122: - yych = *++p; - if (yych == 'C') goto yy123; - if (yych != 'c') goto yy31; -yy123: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy124: - yych = *++p; - if (yych == '2') goto yy131; - goto yy31; -yy125: - yych = *++p; - if (yych == 'R') goto yy128; - if (yych == 'r') goto yy128; - goto yy31; -yy126: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy127: - yych = *++p; - if (yych == 'N') goto yy41; - if (yych == 'n') goto yy41; - goto yy31; -yy128: - yych = *++p; - if (yych == 'E') goto yy129; - if (yych != 'e') goto yy31; -yy129: - yych = *++p; - if (yych == 'A') goto yy130; - if (yych != 'a') goto yy31; -yy130: - yych = *++p; - if (yych == 'L') goto yy41; - if (yych == 'l') goto yy41; - goto yy31; -yy131: - yych = *++p; - if (yych != '0') goto yy31; - yych = *++p; - if (yych != '0') goto yy31; - yych = *++p; - if (yych == '4') goto yy41; - goto yy31; -yy134: - yych = *++p; - if (yych == 'I') goto yy153; - if (yych == 'i') goto yy153; - goto yy31; -yy135: - yych = *++p; - if (yych <= 'L') { - if (yych == 'A') goto yy145; - if (yych <= 'K') goto yy31; - goto yy144; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy31; - goto yy145; - } else { - if (yych == 'l') goto yy144; - goto yy31; - } - } -yy136: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy137: - yych = *++p; - if (yych == '3') goto yy141; - goto yy31; -yy138: - yych = *++p; - if (yych == 'T') goto yy140; - if (yych == 't') goto yy140; - goto yy31; -yy139: - yych = *++p; - if (yych == 'G') goto yy41; - if (yych == 'g') goto yy41; - goto yy31; -yy140: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy141: - yych = *++p; - if (yych != '2') goto yy31; - yych = *++p; - if (yych != '7') goto yy31; - yych = *++p; - if (yych == '0') goto yy41; - goto yy31; -yy144: - yych = *++p; - if (yych <= 'M') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'N') goto yy151; - if (yych == 'n') goto yy151; - goto yy31; - } -yy145: - yych = *++p; - if (yych == 'M') goto yy146; - if (yych != 'm') goto yy31; -yy146: - yych = *++p; - if (yych == 'S') goto yy147; - if (yych != 's') goto yy31; -yy147: - yych = *++p; - if (yych == 'P') goto yy148; - if (yych != 'p') goto yy31; -yy148: - yych = *++p; - if (yych == 'E') goto yy149; - if (yych != 'e') goto yy31; -yy149: - yych = *++p; - if (yych == 'A') goto yy150; - if (yych != 'a') goto yy31; -yy150: - yych = *++p; - if (yych == 'K') goto yy41; - if (yych == 'k') goto yy41; - goto yy31; -yy151: - yych = *++p; - if (yych == 'E') goto yy152; - if (yych != 'e') goto yy31; -yy152: - yych = *++p; - if (yych == 'T') goto yy41; - if (yych == 't') goto yy41; - goto yy31; -yy153: - yych = *++p; - if (yych <= 'S') { - if (yych == 'N') goto yy154; - if (yych <= 'R') goto yy31; - goto yy155; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy31; - } else { - if (yych == 's') goto yy155; - goto yy31; - } - } -yy154: - yych = *++p; - if (yych == 'G') goto yy162; - if (yych == 'g') goto yy162; - goto yy31; -yy155: - yych = *++p; - if (yych == 'M') goto yy156; - if (yych != 'm') goto yy31; -yy156: - yych = *++p; - if (yych == 'E') goto yy157; - if (yych != 'e') goto yy31; -yy157: - yych = *++p; - if (yych == 'S') goto yy158; - if (yych != 's') goto yy31; -yy158: - yych = *++p; - if (yych == 'S') goto yy159; - if (yych != 's') goto yy31; -yy159: - yych = *++p; - if (yych == 'A') goto yy160; - if (yych != 'a') goto yy31; -yy160: - yych = *++p; - if (yych == 'G') goto yy161; - if (yych != 'g') goto yy31; -yy161: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy162: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy163: - yych = *++p; - if (yych == 'N') goto yy41; - if (yych == 'n') goto yy41; - goto yy31; -yy164: - yych = *++p; - if (yych == 'E') goto yy214; - if (yych == 'e') goto yy214; - goto yy31; -yy165: - yych = *++p; - if (yych == 'H') goto yy41; - if (yych == 'h') goto yy41; - goto yy31; -yy166: - yych = *++p; - if (yych == 'O') goto yy210; - if (yych == 'o') goto yy210; - goto yy31; -yy167: - yych = *++p; - if (yych <= 'L') { - if (yych == 'A') goto yy200; - if (yych <= 'K') goto yy31; - goto yy201; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy31; - goto yy200; - } else { - if (yych == 'l') goto yy201; - goto yy31; - } - } -yy168: - yych = *++p; - if (yych <= 'S') { - if (yych == 'B') goto yy41; - if (yych <= 'R') goto yy31; - goto yy41; - } else { - if (yych <= 'b') { - if (yych <= 'a') goto yy31; - goto yy41; - } else { - if (yych == 's') goto yy41; - goto yy31; - } - } -yy169: - yych = *++p; - if (yych == 'Y') goto yy198; - if (yych == 'y') goto yy198; - goto yy31; -yy170: - yych = *++p; - if (yych == 'N') goto yy41; - if (yych == 'n') goto yy41; - goto yy31; -yy171: - yych = *++p; - if (yych == 'T') goto yy197; - if (yych == 't') goto yy197; - goto yy31; -yy172: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'C') { - if (yych <= 'B') goto yy31; - goto yy184; - } else { - if (yych <= 'Q') goto yy31; - if (yych <= 'R') goto yy182; - goto yy183; - } - } else { - if (yych <= 'q') { - if (yych == 'c') goto yy184; - goto yy31; - } else { - if (yych <= 'r') goto yy182; - if (yych <= 's') goto yy183; - goto yy31; - } - } -yy173: - yych = *++p; - if (yych == 'M') goto yy181; - if (yych == 'm') goto yy181; - goto yy31; -yy174: - yych = *++p; - if (yych <= 'P') { - if (yych == 'E') goto yy178; - if (yych <= 'O') goto yy31; - goto yy179; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy31; - goto yy178; - } else { - if (yych == 'p') goto yy179; - goto yy31; - } - } -yy175: - yych = *++p; - if (yych == 'T') goto yy176; - if (yych != 't') goto yy31; -yy176: - yych = *++p; - if (yych == 'T') goto yy177; - if (yych != 't') goto yy31; -yy177: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy178: - yych = *++p; - if (yych == 'V') goto yy180; - if (yych == 'v') goto yy180; - goto yy31; -yy179: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; - } -yy180: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy181: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy182: - yych = *++p; - if (yych == 'V') goto yy194; - if (yych == 'v') goto yy194; - goto yy31; -yy183: - yych = *++p; - if (yych == 'S') goto yy191; - if (yych == 's') goto yy191; - goto yy31; -yy184: - yych = *++p; - if (yych == 'O') goto yy185; - if (yych != 'o') goto yy31; -yy185: - yych = *++p; - if (yych == 'N') goto yy186; - if (yych != 'n') goto yy31; -yy186: - yych = *++p; - if (yych == 'D') goto yy187; - if (yych != 'd') goto yy31; -yy187: - yych = *++p; - if (yych == 'L') goto yy188; - if (yych != 'l') goto yy31; -yy188: - yych = *++p; - if (yych == 'I') goto yy189; - if (yych != 'i') goto yy31; -yy189: - yych = *++p; - if (yych == 'F') goto yy190; - if (yych != 'f') goto yy31; -yy190: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy191: - yych = *++p; - if (yych == 'I') goto yy192; - if (yych != 'i') goto yy31; -yy192: - yych = *++p; - if (yych == 'O') goto yy193; - if (yych != 'o') goto yy31; -yy193: - yych = *++p; - if (yych == 'N') goto yy41; - if (yych == 'n') goto yy41; - goto yy31; -yy194: - yych = *++p; - if (yych == 'I') goto yy195; - if (yych != 'i') goto yy31; -yy195: - yych = *++p; - if (yych == 'C') goto yy196; - if (yych != 'c') goto yy31; -yy196: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy197: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy198: - yych = *++p; - if (yych == 'P') goto yy199; - if (yych != 'p') goto yy31; -yy199: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy200: - yych = *++p; - if (yych == 'P') goto yy204; - if (yych == 'p') goto yy204; - goto yy31; -yy201: - yych = *++p; - if (yych == 'D') goto yy202; - if (yych != 'd') goto yy31; -yy202: - yych = *++p; - if (yych == 'A') goto yy203; - if (yych != 'a') goto yy31; -yy203: - yych = *++p; - if (yych == 'T') goto yy41; - if (yych == 't') goto yy41; - goto yy31; -yy204: - yych = *++p; - if (yych != '.') goto yy31; - yych = *++p; - if (yych == 'B') goto yy206; - if (yych != 'b') goto yy31; -yy206: - yych = *++p; - if (yych == 'E') goto yy207; - if (yych != 'e') goto yy31; -yy207: - yych = *++p; - if (yych == 'E') goto yy208; - if (yych != 'e') goto yy31; -yy208: - yych = *++p; - if (yych == 'P') goto yy209; - if (yych != 'p') goto yy31; -yy209: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; - } -yy210: - yych = *++p; - if (yych == 'T') goto yy211; - if (yych != 't') goto yy31; -yy211: - yych = *++p; - if (yych == 'I') goto yy212; - if (yych != 'i') goto yy31; -yy212: - yych = *++p; - if (yych == 'F') goto yy213; - if (yych != 'f') goto yy31; -yy213: - yych = *++p; - if (yych == 'Y') goto yy41; - if (yych == 'y') goto yy41; - goto yy31; -yy214: - yych = *++p; - if (yych == 'A') goto yy215; - if (yych != 'a') goto yy31; -yy215: - yych = *++p; - if (yych == 'M') goto yy41; - if (yych == 'm') goto yy41; - goto yy31; -yy216: - yych = *++p; - if (yych <= 'S') { - if (yych == 'M') goto yy228; - if (yych <= 'R') goto yy31; - goto yy227; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy31; - goto yy228; - } else { - if (yych == 's') goto yy227; - goto yy31; - } - } -yy217: - yych = *++p; - if (yych == 'Y') goto yy225; - if (yych == 'y') goto yy225; - goto yy31; -yy218: - yych = *++p; - if (yych == 'I') goto yy41; - if (yych == 'i') goto yy41; - goto yy31; -yy219: - yych = *++p; - if (yych == 'S') goto yy220; - if (yych != 's') goto yy31; -yy220: - yych = *++p; - if (yych <= 'N') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'O') goto yy221; - if (yych != 'o') goto yy31; - } -yy221: - yych = *++p; - if (yych == 'U') goto yy222; - if (yych != 'u') goto yy31; -yy222: - yych = *++p; - if (yych == 'R') goto yy223; - if (yych != 'r') goto yy31; -yy223: - yych = *++p; - if (yych == 'C') goto yy224; - if (yych != 'c') goto yy31; -yy224: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy225: - yych = *++p; - if (yych == 'N') goto yy226; - if (yych != 'n') goto yy31; -yy226: - yych = *++p; - if (yych == 'C') goto yy41; - if (yych == 'c') goto yy41; - goto yy31; -yy227: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy228: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy229: - yych = *++p; - if (yych == 'Y') goto yy249; - if (yych == 'y') goto yy249; - goto yy31; -yy230: - yych = *++p; - if (yych <= 'O') { - if (yych == 'E') goto yy246; - if (yych <= 'N') goto yy31; - goto yy247; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy31; - goto yy246; - } else { - if (yych == 'o') goto yy247; - goto yy31; - } - } -yy231: - yych = *++p; - if (yych == 'A') goto yy241; - if (yych == 'a') goto yy241; - goto yy31; -yy232: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy234; - if (yych <= 'O') goto yy31; - goto yy235; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy31; - goto yy234; - } else { - if (yych == 'p') goto yy235; - goto yy31; - } - } -yy233: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy234: - yych = *++p; - if (yych == 'M') goto yy41; - if (yych == 'm') goto yy41; - goto yy31; -yy235: - yych = *++p; - if (yych == 'A') goto yy236; - if (yych != 'a') goto yy31; -yy236: - yych = *++p; - if (yych == 'R') goto yy237; - if (yych != 'r') goto yy31; -yy237: - yych = *++p; - if (yych == 'A') goto yy238; - if (yych != 'a') goto yy31; -yy238: - yych = *++p; - if (yych == 'Z') goto yy239; - if (yych != 'z') goto yy31; -yy239: - yych = *++p; - if (yych == 'Z') goto yy240; - if (yych != 'z') goto yy31; -yy240: - yych = *++p; - if (yych == 'I') goto yy41; - if (yych == 'i') goto yy41; - goto yy31; -yy241: - yych = *++p; - if (yych == 'T') goto yy242; - if (yych != 't') goto yy31; -yy242: - yych = *++p; - if (yych == 'F') goto yy243; - if (yych != 'f') goto yy31; -yy243: - yych = *++p; - if (yych == 'O') goto yy244; - if (yych != 'o') goto yy31; -yy244: - yych = *++p; - if (yych == 'R') goto yy245; - if (yych != 'r') goto yy31; -yy245: - yych = *++p; - if (yych == 'M') goto yy41; - if (yych == 'm') goto yy41; - goto yy31; -yy246: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy247: - yych = *++p; - if (yych == 'X') goto yy248; - if (yych != 'x') goto yy31; -yy248: - yych = *++p; - if (yych == 'Y') goto yy41; - if (yych == 'y') goto yy41; - goto yy31; -yy249: - yych = *++p; - if (yych == 'C') goto yy41; - if (yych == 'c') goto yy41; - goto yy31; -yy250: - yych = *++p; - if (yych == 'D') goto yy41; - if (yych == 'd') goto yy41; - goto yy31; -yy251: - yych = *++p; - if (yych == 'A') goto yy252; - if (yych != 'a') goto yy31; -yy252: - yych = *++p; - if (yych == 'Q') goto yy253; - if (yych != 'q') goto yy31; -yy253: - yych = *++p; - if (yych == 'U') goto yy254; - if (yych != 'u') goto yy31; -yy254: - yych = *++p; - if (yych == 'E') goto yy255; - if (yych != 'e') goto yy31; -yy255: - yych = *++p; - if (yych == 'L') goto yy256; - if (yych != 'l') goto yy31; -yy256: - yych = *++p; - if (yych == 'O') goto yy257; - if (yych != 'o') goto yy31; -yy257: - yych = *++p; - if (yych == 'C') goto yy258; - if (yych != 'c') goto yy31; -yy258: - yych = *++p; - if (yych == 'K') goto yy259; - if (yych != 'k') goto yy31; -yy259: - yych = *++p; - if (yych == 'T') goto yy260; - if (yych != 't') goto yy31; -yy260: - yych = *++p; - if (yych == 'O') goto yy261; - if (yych != 'o') goto yy31; -yy261: - yych = *++p; - if (yych == 'K') goto yy262; - if (yych != 'k') goto yy31; -yy262: - yych = *++p; - if (yych == 'E') goto yy263; - if (yych != 'e') goto yy31; -yy263: - yych = *++p; - if (yych == 'N') goto yy41; - if (yych == 'n') goto yy41; - goto yy31; -yy264: - yych = *++p; - if (yych == 'T') goto yy271; - if (yych == 't') goto yy271; - goto yy31; -yy265: - yych = *++p; - if (yych == 'T') goto yy270; - if (yych == 't') goto yy270; - goto yy31; -yy266: - yych = *++p; - if (yych <= 'G') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'H') goto yy41; - if (yych == 'h') goto yy41; - goto yy31; - } -yy267: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy268: - yych = *++p; - if (yych == 'W') goto yy269; - if (yych != 'w') goto yy31; -yy269: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy270: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy271: - yych = *++p; - if (yych == 'E') goto yy272; - if (yych != 'e') goto yy31; -yy272: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy273: - yych = *++p; - if (yych == 'N') goto yy41; - if (yych == 'n') goto yy41; - goto yy31; -yy274: - yych = *++p; - if (yych <= 'P') { - if (yych == 'M') goto yy305; - if (yych <= 'O') goto yy31; - goto yy304; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy31; - goto yy305; - } else { - if (yych == 'p') goto yy304; - goto yy31; - } - } -yy275: - yych = *++p; - if (yych <= 'Q') { - if (yych <= '-') { - if (yych <= ',') goto yy31; - goto yy297; - } else { - if (yych == 'N') goto yy298; - goto yy31; - } - } else { - if (yych <= 'n') { - if (yych <= 'R') goto yy296; - if (yych <= 'm') goto yy31; - goto yy298; - } else { - if (yych == 'r') goto yy296; - goto yy31; - } - } -yy276: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy277: - yych = *++p; - if (yych == 'S') goto yy292; - if (yych == 's') goto yy292; - goto yy31; -yy278: - yych = *++p; - switch (yych) { - case 'G': - case 'g': goto yy283; - case 'I': - case 'i': goto yy282; - case 'P': - case 'p': goto yy284; - case 'R': - case 'r': goto yy285; - default: goto yy31; - } -yy279: - yych = *++p; - if (yych == 'Q') goto yy281; - if (yych == 'q') goto yy281; - goto yy31; -yy280: - yych = *++p; - if (yych == 'D') goto yy41; - if (yych == 'd') goto yy41; - goto yy31; -yy281: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy282: - yych = *++p; - if (yych == 'L') goto yy290; - if (yych == 'l') goto yy290; - goto yy31; -yy283: - yych = *++p; - if (yych == 'N') goto yy288; - if (yych == 'n') goto yy288; - goto yy31; -yy284: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy285: - yych = *++p; - if (yych == 'K') goto yy286; - if (yych != 'k') goto yy31; -yy286: - yych = *++p; - if (yych == 'E') goto yy287; - if (yych != 'e') goto yy31; -yy287: - yych = *++p; - if (yych == 'T') goto yy41; - if (yych == 't') goto yy41; - goto yy31; -yy288: - yych = *++p; - if (yych == 'E') goto yy289; - if (yych != 'e') goto yy31; -yy289: - yych = *++p; - if (yych == 'T') goto yy41; - if (yych == 't') goto yy41; - goto yy31; -yy290: - yych = *++p; - if (yych == 'T') goto yy291; - if (yych != 't') goto yy31; -yy291: - yych = *++p; - if (yych == 'O') goto yy41; - if (yych == 'o') goto yy41; - goto yy31; -yy292: - yych = *++p; - if (yych == 'S') goto yy293; - if (yych != 's') goto yy31; -yy293: - yych = *++p; - if (yych == 'A') goto yy294; - if (yych != 'a') goto yy31; -yy294: - yych = *++p; - if (yych == 'G') goto yy295; - if (yych != 'g') goto yy31; -yy295: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy296: - yych = *++p; - if (yych == 'P') goto yy303; - if (yych == 'p') goto yy303; - goto yy31; -yy297: - yych = *++p; - if (yych == 'H') goto yy300; - if (yych == 'h') goto yy300; - goto yy31; -yy298: - yych = *++p; - if (yych == 'I') goto yy299; - if (yych != 'i') goto yy31; -yy299: - yych = *++p; - if (yych == 'M') goto yy41; - if (yych == 'm') goto yy41; - goto yy31; -yy300: - yych = *++p; - if (yych == 'E') goto yy301; - if (yych != 'e') goto yy31; -yy301: - yych = *++p; - if (yych == 'L') goto yy302; - if (yych != 'l') goto yy31; -yy302: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy303: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; - } -yy304: - yych = *++p; - if (yych == 'D') goto yy308; - if (yych == 'd') goto yy308; - goto yy31; -yy305: - yych = *++p; - if (yych == 'B') goto yy306; - if (yych != 'b') goto yy31; -yy306: - yych = *++p; - if (yych == 'L') goto yy307; - if (yych != 'l') goto yy31; -yy307: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy308: - yych = *++p; - if (yych == 'A') goto yy309; - if (yych != 'a') goto yy31; -yy309: - yych = *++p; - if (yych == 'T') goto yy310; - if (yych != 't') goto yy31; -yy310: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy311: - yych = *++p; - if (yych == 'A') goto yy316; - if (yych == 'a') goto yy316; - goto yy31; -yy312: - yych = *++p; - if (yych == 'S') goto yy313; - if (yych != 's') goto yy31; -yy313: - yych = *++p; - if (yych == 'T') goto yy314; - if (yych != 't') goto yy31; -yy314: - yych = *++p; - if (yych == 'F') goto yy315; - if (yych != 'f') goto yy31; -yy315: - yych = *++p; - if (yych == 'M') goto yy41; - if (yych == 'm') goto yy41; - goto yy31; -yy316: - yych = *++p; - if (yych == 'P') goto yy317; - if (yych != 'p') goto yy31; -yy317: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; - } -yy318: - yych = *++p; - if (yych == 'M') goto yy341; - if (yych == 'm') goto yy341; - goto yy31; -yy319: - yych = *++p; - if (yych <= 'I') { - if (yych == 'C') goto yy330; - if (yych <= 'H') goto yy31; - goto yy329; - } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy31; - goto yy330; - } else { - if (yych == 'i') goto yy329; - goto yy31; - } - } -yy320: - yych = *++p; - if (yych <= 'P') { - if (yych == 'N') goto yy41; - if (yych <= 'O') goto yy31; - goto yy41; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy31; - goto yy41; - } else { - if (yych == 'p') goto yy41; - goto yy31; - } - } -yy321: - yych = *++p; - if (yych <= 'O') { - if (yych == 'A') goto yy327; - if (yych <= 'N') goto yy31; - goto yy328; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy31; - goto yy327; - } else { - if (yych == 'o') goto yy328; - goto yy31; - } - } -yy322: - yych = *++p; - if (yych == 'F') goto yy326; - if (yych == 'f') goto yy326; - goto yy31; -yy323: - yych = *++p; - if (yych <= '@') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'A') goto yy325; - if (yych == 'a') goto yy325; - goto yy31; - } -yy324: - yych = *++p; - if (yych == 'X') goto yy41; - if (yych == 'x') goto yy41; - goto yy31; -yy325: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy326: - yych = *++p; - if (yych == 'O') goto yy41; - if (yych == 'o') goto yy41; - goto yy31; -yy327: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy328: - yych = *++p; - if (yych == 'N') goto yy41; - if (yych == 'n') goto yy41; - goto yy31; -yy329: - yych = *++p; - if (yych == 'S') goto yy331; - if (yych == 's') goto yy331; - goto yy31; -yy330: - yych = *++p; - if (yych <= ':') { - if (yych == '6') goto yy41; - if (yych <= '9') goto yy31; - goto yy42; - } else { - if (yych <= 'S') { - if (yych <= 'R') goto yy31; - goto yy41; - } else { - if (yych == 's') goto yy41; - goto yy31; - } - } -yy331: - yych = *++p; - if (yych == '.') goto yy332; - if (yych == ':') goto yy42; - goto yy31; -yy332: - yych = *++p; - if (yych <= 'X') { - if (yych <= 'K') { - if (yych == 'B') goto yy335; - goto yy31; - } else { - if (yych <= 'L') goto yy333; - if (yych <= 'W') goto yy31; - goto yy334; - } - } else { - if (yych <= 'k') { - if (yych == 'b') goto yy335; - goto yy31; - } else { - if (yych <= 'l') goto yy333; - if (yych == 'x') goto yy334; - goto yy31; - } - } -yy333: - yych = *++p; - if (yych == 'W') goto yy340; - if (yych == 'w') goto yy340; - goto yy31; -yy334: - yych = *++p; - if (yych == 'P') goto yy338; - if (yych == 'p') goto yy338; - goto yy31; -yy335: - yych = *++p; - if (yych == 'E') goto yy336; - if (yych != 'e') goto yy31; -yy336: - yych = *++p; - if (yych == 'E') goto yy337; - if (yych != 'e') goto yy31; -yy337: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy338: - yych = *++p; - if (yych == 'C') goto yy339; - if (yych != 'c') goto yy31; -yy339: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; - } -yy340: - yych = *++p; - if (yych == 'Z') goto yy41; - if (yych == 'z') goto yy41; - goto yy31; -yy341: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy342: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy343: - yych = *++p; - if (yych == 'T') goto yy346; - if (yych == 't') goto yy346; - goto yy31; -yy344: - yych = *++p; - if (yych != '2') goto yy31; - yych = *++p; - if (yych == '3') goto yy41; - goto yy31; -yy346: - yych = *++p; - if (yych == 'P') goto yy347; - if (yych != 'p') goto yy31; -yy347: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; - } -yy348: - yych = *++p; - if (yych == 'A') goto yy364; - if (yych == 'a') goto yy364; - goto yy31; -yy349: - yych = *++p; - if (yych <= 'Z') { - if (yych == 'T') goto yy41; - if (yych <= 'Y') goto yy31; - goto yy355; - } else { - if (yych <= 't') { - if (yych <= 's') goto yy31; - goto yy41; - } else { - if (yych == 'z') goto yy355; - goto yy31; - } - } -yy350: - yych = *++p; - if (yych <= 'O') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'P') goto yy352; - if (yych == 'p') goto yy352; - goto yy31; - } -yy351: - yych = *++p; - if (yych == 'O') goto yy41; - if (yych == 'o') goto yy41; - goto yy31; -yy352: - yych = *++p; - if (yych == 'H') goto yy353; - if (yych != 'h') goto yy31; -yy353: - yych = *++p; - if (yych == 'E') goto yy354; - if (yych != 'e') goto yy31; -yy354: - yych = *++p; - if (yych == 'R') goto yy41; - if (yych == 'r') goto yy41; - goto yy31; -yy355: - yych = *++p; - if (yych == 'M') goto yy356; - if (yych != 'm') goto yy31; -yy356: - yych = *++p; - if (yych == 'O') goto yy357; - if (yych != 'o') goto yy31; -yy357: - yych = *++p; - if (yych == 'P') goto yy358; - if (yych != 'p') goto yy31; -yy358: - yych = *++p; - if (yych == 'R') goto yy359; - if (yych != 'r') goto yy31; -yy359: - yych = *++p; - if (yych == 'O') goto yy360; - if (yych != 'o') goto yy31; -yy360: - yych = *++p; - if (yych == 'J') goto yy361; - if (yych != 'j') goto yy31; -yy361: - yych = *++p; - if (yych == 'E') goto yy362; - if (yych != 'e') goto yy31; -yy362: - yych = *++p; - if (yych == 'C') goto yy363; - if (yych != 'c') goto yy31; -yy363: - yych = *++p; - if (yych == 'T') goto yy41; - if (yych == 't') goto yy41; - goto yy31; -yy364: - yych = *++p; - if (yych == 'L') goto yy365; - if (yych != 'l') goto yy31; -yy365: - yych = *++p; - if (yych == 'K') goto yy41; - if (yych == 'k') goto yy41; - goto yy31; -yy366: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'M') { - if (yych == 'L') goto yy376; - goto yy31; - } else { - if (yych <= 'N') goto yy377; - if (yych <= 'R') goto yy31; - goto yy378; - } - } else { - if (yych <= 'm') { - if (yych == 'l') goto yy376; - goto yy31; - } else { - if (yych <= 'n') goto yy377; - if (yych == 's') goto yy378; - goto yy31; - } - } -yy367: - yych = *++p; - if (yych == 'E') goto yy375; - if (yych == 'e') goto yy375; - goto yy31; -yy368: - yych = *++p; - if (yych == 'C') goto yy370; - if (yych == 'c') goto yy370; - goto yy31; -yy369: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy370: - yych = *++p; - if (yych == 'E') goto yy371; - if (yych != 'e') goto yy31; -yy371: - yych = *++p; - if (yych == 'T') goto yy372; - if (yych != 't') goto yy31; -yy372: - yych = *++p; - if (yych == 'I') goto yy373; - if (yych != 'i') goto yy31; -yy373: - yych = *++p; - if (yych == 'M') goto yy374; - if (yych != 'm') goto yy31; -yy374: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy375: - yych = *++p; - if (yych == 'D') goto yy41; - if (yych == 'd') goto yy41; - goto yy31; -yy376: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy377: - yych = *++p; - if (yych == 'G') goto yy379; - if (yych == 'g') goto yy379; - goto yy31; -yy378: - yych = *++p; - if (yych == 'H') goto yy41; - if (yych == 'h') goto yy41; - goto yy31; -yy379: - yych = *++p; - if (yych == 'E') goto yy380; - if (yych != 'e') goto yy31; -yy380: - yych = *++p; - if (yych == 'R') goto yy41; - if (yych == 'r') goto yy41; - goto yy31; -yy381: - yych = *++p; - if (yych == 'T') goto yy399; - if (yych == 't') goto yy399; - goto yy31; -yy382: - yych = *++p; - if (yych == 'T') goto yy41; - if (yych == 't') goto yy41; - goto yy31; -yy383: - yych = *++p; - if (yych == 'M') goto yy41; - if (yych == 'm') goto yy41; - goto yy31; -yy384: - yych = *++p; - if (yych <= 'S') { - if (yych == 'P') goto yy41; - if (yych <= 'R') goto yy31; - goto yy41; - } else { - if (yych <= 'p') { - if (yych <= 'o') goto yy31; - goto yy41; - } else { - if (yych == 's') goto yy41; - goto yy31; - } - } -yy385: - yych = *++p; - if (yych == 'I') goto yy393; - if (yych == 'i') goto yy393; - goto yy31; -yy386: - yych = *++p; - if (yych == 'A') goto yy392; - if (yych == 'a') goto yy392; - goto yy31; -yy387: - yych = *++p; - if (yych == 'O') goto yy390; - if (yych == 'o') goto yy390; - goto yy31; -yy388: - yych = *++p; - if (yych == 'A') goto yy389; - if (yych != 'a') goto yy31; -yy389: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy42; - goto yy31; - } else { - if (yych <= 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; - } -yy390: - yych = *++p; - if (yych == 'U') goto yy391; - if (yych != 'u') goto yy31; -yy391: - yych = *++p; - if (yych == 'T') goto yy41; - if (yych == 't') goto yy41; - goto yy31; -yy392: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy393: - yych = *++p; - if (yych == 'U') goto yy394; - if (yych != 'u') goto yy31; -yy394: - yych = *++p; - if (yych == 'M') goto yy395; - if (yych != 'm') goto yy31; -yy395: - yych = *++p; - if (yych == 'X') goto yy396; - if (yych != 'x') goto yy31; -yy396: - yych = *++p; - if (yych == 'T') goto yy397; - if (yych != 't') goto yy31; -yy397: - yych = *++p; - if (yych == 'R') goto yy398; - if (yych != 'r') goto yy31; -yy398: - yych = *++p; - if (yych == 'A') goto yy41; - if (yych == 'a') goto yy41; - goto yy31; -yy399: - yych = *++p; - if (yych == 'A') goto yy400; - if (yych != 'a') goto yy31; -yy400: - yych = *++p; - if (yych == 'C') goto yy401; - if (yych != 'c') goto yy31; -yy401: - yych = *++p; - if (yych == 'H') goto yy402; - if (yych != 'h') goto yy31; -yy402: - yych = *++p; - if (yych == 'M') goto yy403; - if (yych != 'm') goto yy31; -yy403: - yych = *++p; - if (yych == 'E') goto yy404; - if (yych != 'e') goto yy31; -yy404: - yych = *++p; - if (yych == 'N') goto yy405; - if (yych != 'n') goto yy31; -yy405: - yych = *++p; - if (yych == 'T') goto yy41; - if (yych == 't') goto yy41; - goto yy31; -yy406: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy407: - yych = *++p; - if (yych <= 'V') { - if (yych == 'R') goto yy41; - if (yych <= 'U') goto yy31; - } else { - if (yych <= 'r') { - if (yych <= 'q') goto yy31; - goto yy41; - } else { - if (yych != 'v') goto yy31; - } - } - yych = *++p; - if (yych == 'A') goto yy409; - if (yych != 'a') goto yy31; -yy409: - yych = *++p; - if (yych == 'S') goto yy410; - if (yych != 's') goto yy31; -yy410: - yych = *++p; - if (yych == 'C') goto yy411; - if (yych != 'c') goto yy31; -yy411: - yych = *++p; - if (yych == 'R') goto yy412; - if (yych != 'r') goto yy31; -yy412: - yych = *++p; - if (yych == 'I') goto yy413; - if (yych != 'i') goto yy31; -yy413: - yych = *++p; - if (yych == 'P') goto yy414; - if (yych != 'p') goto yy31; -yy414: - yych = *++p; - if (yych == 'T') goto yy41; - if (yych == 't') goto yy41; - goto yy31; -yy415: - yych = *++p; - if (yych == 'B') goto yy41; - if (yych == 'b') goto yy41; - goto yy31; -yy416: - yych = *++p; - if (yych == 'N') goto yy41; - if (yych == 'n') goto yy41; - goto yy31; -yy417: - yych = *++p; - if (yych == 'N') goto yy424; - if (yych == 'n') goto yy424; - goto yy31; -yy418: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy419: - yych = *++p; - if (yych == 'C') goto yy423; - if (yych == 'c') goto yy423; - goto yy31; -yy420: - yych = *++p; - if (yych <= 'V') { - if (yych == 'T') goto yy422; - if (yych <= 'U') goto yy31; - goto yy41; - } else { - if (yych <= 't') { - if (yych <= 's') goto yy31; - goto yy422; - } else { - if (yych == 'v') goto yy41; - goto yy31; - } - } -yy421: - yych = *++p; - if (yych == 'I') goto yy41; - if (yych == 'i') goto yy41; - goto yy31; -yy422: - yych = *++p; - if (yych == 'A') goto yy41; - if (yych == 'a') goto yy41; - goto yy31; -yy423: - yych = *++p; - if (yych == 'T') goto yy41; - if (yych == 't') goto yy41; - goto yy31; -yy424: - yych = *++p; - if (yych == 'A') goto yy425; - if (yych != 'a') goto yy31; -yy425: - yych = *++p; - if (yych != '-') goto yy31; - yych = *++p; - if (yych == 'P') goto yy427; - if (yych != 'p') goto yy31; -yy427: - yych = *++p; - if (yych == 'L') goto yy428; - if (yych != 'l') goto yy31; -yy428: - yych = *++p; - if (yych == 'A') goto yy429; - if (yych != 'a') goto yy31; -yy429: - yych = *++p; - if (yych == 'Y') goto yy430; - if (yych != 'y') goto yy31; -yy430: - yych = *++p; - if (yych <= 'S') { - if (yych == 'C') goto yy431; - if (yych <= 'R') goto yy31; - goto yy432; - } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy31; - } else { - if (yych == 's') goto yy432; - goto yy31; - } - } -yy431: - yych = *++p; - if (yych == 'O') goto yy437; - if (yych == 'o') goto yy437; - goto yy31; -yy432: - yych = *++p; - if (yych == 'I') goto yy433; - if (yych != 'i') goto yy31; -yy433: - yych = *++p; - if (yych == 'N') goto yy434; - if (yych != 'n') goto yy31; -yy434: - yych = *++p; - if (yych == 'G') goto yy435; - if (yych != 'g') goto yy31; -yy435: - yych = *++p; - if (yych == 'L') goto yy436; - if (yych != 'l') goto yy31; -yy436: - yych = *++p; - if (yych == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -yy437: - yych = *++p; - if (yych == 'N') goto yy438; - if (yych != 'n') goto yy31; -yy438: - yych = *++p; - if (yych == 'T') goto yy439; - if (yych != 't') goto yy31; -yy439: - yych = *++p; - if (yych == 'A') goto yy440; - if (yych != 'a') goto yy31; -yy440: - yych = *++p; - if (yych == 'I') goto yy441; - if (yych != 'i') goto yy31; -yy441: - yych = *++p; - if (yych == 'N') goto yy442; - if (yych != 'n') goto yy31; -yy442: - yych = *++p; - if (yych == 'E') goto yy443; - if (yych != 'e') goto yy31; -yy443: - yych = *++p; - if (yych == 'R') goto yy41; - if (yych == 'r') goto yy41; - goto yy31; -yy444: - yych = *++p; - if (yych == 'S') goto yy41; - if (yych == 's') goto yy41; - goto yy31; -yy445: - yych = *++p; - if (yych <= 'N') { - if (yych <= 'A') { - if (yych <= '@') goto yy31; - goto yy467; - } else { - if (yych <= 'L') goto yy31; - if (yych <= 'M') goto yy468; - goto yy469; - } - } else { - if (yych <= 'l') { - if (yych == 'a') goto yy467; - goto yy31; - } else { - if (yych <= 'm') goto yy468; - if (yych <= 'n') goto yy469; - goto yy31; - } - } -yy446: - yych = *++p; - if (yych == 'R') goto yy454; - if (yych == 'r') goto yy454; - goto yy31; -yy447: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy451; - if (yych <= 'O') goto yy31; - goto yy41; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy31; - goto yy451; - } else { - if (yych == 'p') goto yy41; - goto yy31; - } - } -yy448: - yych = *++p; - if (yych == 'I') goto yy450; - if (yych == 'i') goto yy450; - goto yy31; -yy449: - yych = *++p; - if (yych == 'D') goto yy41; - if (yych == 'd') goto yy41; - goto yy31; -yy450: - yych = *++p; - if (yych == 'D') goto yy41; - if (yych == 'd') goto yy41; - goto yy31; -yy451: - yych = *++p; - if (yych == 'L') goto yy452; - if (yych != 'l') goto yy31; -yy452: - yych = *++p; - if (yych == 'T') goto yy453; - if (yych != 't') goto yy31; -yy453: - yych = *++p; - if (yych == 'O') goto yy41; - if (yych == 'o') goto yy41; - goto yy31; -yy454: - yych = *++p; - if (yych == 'O') goto yy455; - if (yych != 'o') goto yy31; -yy455: - yych = *++p; - if (yych == 'M') goto yy456; - if (yych != 'm') goto yy31; -yy456: - yych = *++p; - if (yych == 'E') goto yy457; - if (yych != 'e') goto yy31; -yy457: - yych = *++p; - if (yych == '-') goto yy458; - if (yych == ':') goto yy42; - goto yy31; -yy458: - yych = *++p; - if (yych == 'E') goto yy459; - if (yych != 'e') goto yy31; -yy459: - yych = *++p; - if (yych == 'X') goto yy460; - if (yych != 'x') goto yy31; -yy460: - yych = *++p; - if (yych == 'T') goto yy461; - if (yych != 't') goto yy31; -yy461: - yych = *++p; - if (yych == 'E') goto yy462; - if (yych != 'e') goto yy31; -yy462: - yych = *++p; - if (yych == 'N') goto yy463; - if (yych != 'n') goto yy31; -yy463: - yych = *++p; - if (yych == 'S') goto yy464; - if (yych != 's') goto yy31; -yy464: - yych = *++p; - if (yych == 'I') goto yy465; - if (yych != 'i') goto yy31; -yy465: - yych = *++p; - if (yych == 'O') goto yy466; - if (yych != 'o') goto yy31; -yy466: - yych = *++p; - if (yych == 'N') goto yy41; - if (yych == 'n') goto yy41; - goto yy31; -yy467: - yych = *++p; - if (yych == 'P') goto yy41; - if (yych == 'p') goto yy41; - goto yy31; -yy468: - yych = *++p; - if (yych == '-') goto yy473; - goto yy31; -yy469: - yych = *++p; - if (yych == 'T') goto yy470; - if (yych != 't') 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 yy41; - if (yych == 't') goto yy41; - goto yy31; -yy473: - yych = *++p; - if (yych == 'E') goto yy474; - if (yych != 'e') goto yy31; -yy474: - yych = *++p; - if (yych == 'V') goto yy475; - if (yych != 'v') goto yy31; -yy475: - yych = *++p; - if (yych == 'E') goto yy476; - if (yych != 'e') goto yy31; -yy476: - yych = *++p; - if (yych == 'N') goto yy477; - if (yych != 'n') goto yy31; -yy477: - yych = *++p; - if (yych == 'T') goto yy478; - if (yych != 't') goto yy31; -yy478: - yych = *++p; - if (yych == 'B') goto yy479; - if (yych != 'b') goto yy31; -yy479: - yych = *++p; - if (yych == 'R') goto yy480; - if (yych != 'r') goto yy31; -yy480: - yych = *++p; - if (yych == 'I') goto yy481; - if (yych != 'i') 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 != '-') goto yy31; - yych = *++p; - if (yych == 'A') goto yy485; - if (yych != 'a') goto yy31; -yy485: - yych = *++p; - if (yych == 'T') goto yy486; - if (yych != 't') goto yy31; -yy486: - yych = *++p; - if (yych == 'T') goto yy487; - if (yych != 't') goto yy31; -yy487: - yych = *++p; - if (yych == 'E') goto yy488; - if (yych != 'e') goto yy31; -yy488: - yych = *++p; - if (yych == 'N') goto yy489; - if (yych != 'n') goto yy31; -yy489: - yych = *++p; - if (yych == 'D') goto yy490; - if (yych != 'd') goto yy31; -yy490: - yych = *++p; - if (yych == 'E') goto yy491; - if (yych != 'e') goto yy31; -yy491: - ++p; - if ((yych = *p) == 'E') goto yy41; - if (yych == 'e') goto yy41; - goto yy31; -} + { + unsigned char yych; + yych = *(marker = p); + if (yych <= 'c') { + if (yych <= 'M') { + if (yych <= 'E') { + if (yych <= 'A') { + if (yych == '\n') + goto yy2; + if (yych <= '@') + goto yy29; + goto yy6; + } else { + if (yych <= 'B') + goto yy24; + if (yych <= 'C') + goto yy3; + if (yych <= 'D') + goto yy4; + goto yy25; + } + } else { + if (yych <= 'I') { + if (yych <= 'F') + goto yy7; + if (yych <= 'G') + goto yy8; + if (yych <= 'H') + goto yy9; + goto yy10; + } else { + if (yych <= 'J') + goto yy5; + if (yych <= 'K') + goto yy26; + if (yych <= 'L') + goto yy11; + goto yy12; + } + } + } else { + if (yych <= 'U') { + if (yych <= 'Q') { + if (yych <= 'N') + goto yy13; + if (yych <= 'O') + goto yy14; + if (yych <= 'P') + goto yy15; + goto yy27; + } else { + if (yych <= 'R') + goto yy16; + if (yych <= 'S') + goto yy17; + if (yych <= 'T') + goto yy18; + goto yy19; + } + } else { + if (yych <= 'Y') { + if (yych <= 'V') + goto yy20; + if (yych <= 'W') + goto yy21; + if (yych <= 'X') + goto yy22; + goto yy28; + } else { + if (yych <= '`') { + if (yych <= 'Z') + goto yy23; + goto yy29; + } else { + if (yych <= 'a') + goto yy6; + if (yych <= 'b') + goto yy24; + goto yy3; + } + } + } + } + } else { + if (yych <= 't') { + if (yych <= 'k') { + if (yych <= 'g') { + if (yych <= 'd') + goto yy4; + if (yych <= 'e') + goto yy25; + if (yych <= 'f') + goto yy7; + goto yy8; + } else { + if (yych <= 'h') + goto yy9; + if (yych <= 'i') + goto yy10; + if (yych <= 'j') + goto yy5; + goto yy26; + } + } else { + if (yych <= 'o') { + if (yych <= 'l') + goto yy11; + if (yych <= 'm') + goto yy12; + if (yych <= 'n') + goto yy13; + goto yy14; + } else { + if (yych <= 'q') { + if (yych <= 'p') + goto yy15; + goto yy27; + } else { + if (yych <= 'r') + goto yy16; + if (yych <= 's') + goto yy17; + goto yy18; + } + } + } + } else { + if (yych <= 0xC1) { + if (yych <= 'x') { + if (yych <= 'u') + goto yy19; + if (yych <= 'v') + goto yy20; + if (yych <= 'w') + goto yy21; + goto yy22; + } else { + if (yych <= 'y') + goto yy28; + if (yych <= 'z') + goto yy23; + if (yych <= 0x7F) + goto yy29; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy30; + if (yych <= 0xE0) + goto yy32; + if (yych <= 0xEC) + goto yy33; + goto yy37; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy33; + goto yy34; + } else { + if (yych <= 0xF3) + goto yy35; + if (yych <= 0xF4) + goto yy36; + } + } + } + } + } + yy2 : { return 0; } + yy3: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy447; + case 'H': + case 'h': + goto yy446; + case 'I': + case 'i': + goto yy449; + case 'O': + case 'o': + goto yy445; + case 'R': + case 'r': + goto yy448; + case 'V': + case 'v': + goto yy444; + default: + goto yy2; + } + yy4: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy420; + case 'I': + case 'i': + goto yy419; + case 'L': + case 'l': + goto yy417; + case 'N': + case 'n': + goto yy418; + case 'O': + case 'o': + goto yy421; + case 'T': + case 't': + goto yy416; + case 'V': + case 'v': + goto yy415; + default: + goto yy2; + } + yy5: + yych = *(marker = ++p); + if (yych <= 'M') { + if (yych == 'A') + goto yy407; + if (yych <= 'L') + goto yy2; + goto yy406; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy2; + goto yy407; + } else { + if (yych == 'm') + goto yy406; + goto yy2; + } + } + yy6: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy388; + case 'B': + case 'b': + goto yy387; + case 'C': + case 'c': + goto yy386; + case 'D': + case 'd': + goto yy385; + case 'F': + case 'f': + goto yy384; + case 'I': + case 'i': + goto yy383; + case 'P': + case 'p': + goto yy382; + case 'T': + case 't': + goto yy381; + case 'W': + case 'w': + goto yy41; + default: + goto yy2; + } + yy7: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'E') { + if (yych == 'A') + goto yy368; + if (yych <= 'D') + goto yy2; + goto yy367; + } else { + if (yych == 'I') + goto yy366; + if (yych <= 'S') + goto yy2; + goto yy369; + } + } else { + if (yych <= 'e') { + if (yych == 'a') + goto yy368; + if (yych <= 'd') + goto yy2; + goto yy367; + } else { + if (yych <= 'i') { + if (yych <= 'h') + goto yy2; + goto yy366; + } else { + if (yych == 't') + goto yy369; + goto yy2; + } + } + } + yy8: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': + goto yy351; + case 'G': + case 'g': + goto yy41; + case 'I': + case 'i': + goto yy349; + case 'O': + case 'o': + goto yy350; + case 'T': + case 't': + goto yy348; + default: + goto yy2; + } + yy9: + yych = *(marker = ++p); + if (yych <= 'S') { + if (yych <= '3') { + if (yych <= '2') + goto yy2; + goto yy344; + } else { + if (yych == 'C') + goto yy342; + goto yy2; + } + } else { + if (yych <= 'c') { + if (yych <= 'T') + goto yy343; + if (yych <= 'b') + goto yy2; + goto yy342; + } else { + if (yych == 't') + goto yy343; + goto yy2; + } + } + yy10: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy324; + case 'C': + case 'c': + goto yy321; + case 'M': + case 'm': + goto yy323; + case 'N': + case 'n': + goto yy322; + case 'P': + case 'p': + goto yy320; + case 'R': + case 'r': + goto yy319; + case 'T': + case 't': + goto yy318; + default: + goto yy2; + } + yy11: + yych = *(marker = ++p); + if (yych <= 'D') { + if (yych == 'A') + goto yy312; + if (yych <= 'C') + goto yy2; + goto yy311; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy2; + goto yy312; + } else { + if (yych == 'd') + goto yy311; + goto yy2; + } + } + yy12: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy278; + case 'E': + case 'e': + goto yy277; + case 'I': + case 'i': + goto yy280; + case 'M': + case 'm': + goto yy276; + case 'S': + case 's': + goto yy275; + case 'T': + case 't': + goto yy279; + case 'U': + case 'u': + goto yy274; + case 'V': + case 'v': + goto yy273; + default: + goto yy2; + } + yy13: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': + goto yy268; + case 'F': + case 'f': + goto yy267; + case 'I': + case 'i': + goto yy266; + case 'N': + case 'n': + goto yy265; + case 'O': + case 'o': + goto yy264; + default: + goto yy2; + } + yy14: + yych = *(marker = ++p); + if (yych <= 'P') { + if (yych == 'I') + goto yy250; + if (yych <= 'O') + goto yy2; + goto yy251; + } else { + if (yych <= 'i') { + if (yych <= 'h') + goto yy2; + goto yy250; + } else { + if (yych == 'p') + goto yy251; + goto yy2; + } + } + yy15: + yych = *(marker = ++p); + if (yych <= 'S') { + if (yych <= 'L') { + if (yych == 'A') + goto yy232; + if (yych <= 'K') + goto yy2; + goto yy231; + } else { + if (yych <= 'O') { + if (yych <= 'N') + goto yy2; + goto yy233; + } else { + if (yych <= 'Q') + goto yy2; + if (yych <= 'R') + goto yy230; + goto yy229; + } + } + } else { + if (yych <= 'n') { + if (yych <= 'a') { + if (yych <= '`') + goto yy2; + goto yy232; + } else { + if (yych == 'l') + goto yy231; + goto yy2; + } + } else { + if (yych <= 'q') { + if (yych <= 'o') + goto yy233; + goto yy2; + } else { + if (yych <= 'r') + goto yy230; + if (yych <= 's') + goto yy229; + goto yy2; + } + } + } + yy16: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'L') { + if (yych == 'E') + goto yy219; + goto yy2; + } else { + if (yych <= 'M') + goto yy218; + if (yych <= 'R') + goto yy2; + if (yych <= 'S') + goto yy217; + goto yy216; + } + } else { + if (yych <= 'm') { + if (yych == 'e') + goto yy219; + if (yych <= 'l') + goto yy2; + goto yy218; + } else { + if (yych <= 'r') + goto yy2; + if (yych <= 's') + goto yy217; + if (yych <= 't') + goto yy216; + goto yy2; + } + } + yy17: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': + goto yy172; + case 'F': + case 'f': + goto yy171; + case 'G': + case 'g': + goto yy170; + case 'H': + case 'h': + goto yy175; + case 'I': + case 'i': + goto yy174; + case 'K': + case 'k': + goto yy169; + case 'M': + case 'm': + goto yy168; + case 'N': + case 'n': + goto yy173; + case 'O': + case 'o': + goto yy167; + case 'P': + case 'p': + goto yy166; + case 'S': + case 's': + goto yy165; + case 'T': + case 't': + goto yy164; + case 'V': + case 'v': + goto yy163; + default: + goto yy2; + } + yy18: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy139; + case 'E': + case 'e': + goto yy135; + case 'F': + case 'f': + goto yy138; + case 'H': + case 'h': + goto yy134; + case 'I': + case 'i': + goto yy136; + case 'N': + case 'n': + goto yy137; + case 'V': + case 'v': + goto yy41; + default: + goto yy2; + } + yy19: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'N') { + if (yych == 'D') + goto yy126; + if (yych <= 'M') + goto yy2; + goto yy125; + } else { + if (yych == 'R') + goto yy127; + if (yych <= 'S') + goto yy2; + goto yy124; + } + } else { + if (yych <= 'n') { + if (yych == 'd') + goto yy126; + if (yych <= 'm') + goto yy2; + goto yy125; + } else { + if (yych <= 'r') { + if (yych <= 'q') + goto yy2; + goto yy127; + } else { + if (yych == 't') + goto yy124; + goto yy2; + } + } + } + yy20: + yych = *(marker = ++p); + if (yych <= 'I') { + if (yych == 'E') + goto yy108; + if (yych <= 'H') + goto yy2; + goto yy107; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy2; + goto yy108; + } else { + if (yych == 'i') + goto yy107; + goto yy2; + } + } + yy21: + yych = *(marker = ++p); + if (yych <= 'Y') { + if (yych <= 'R') { + if (yych == 'E') + goto yy97; + goto yy2; + } else { + if (yych <= 'S') + goto yy98; + if (yych <= 'T') + goto yy96; + if (yych <= 'X') + goto yy2; + goto yy95; + } + } else { + if (yych <= 's') { + if (yych == 'e') + goto yy97; + if (yych <= 'r') + goto yy2; + goto yy98; + } else { + if (yych <= 't') + goto yy96; + if (yych == 'y') + goto yy95; + goto yy2; + } + } + yy22: + yych = *(marker = ++p); + if (yych <= 'R') { + if (yych <= 'F') { + if (yych == 'C') + goto yy74; + if (yych <= 'E') + goto yy2; + goto yy72; + } else { + if (yych == 'M') + goto yy73; + if (yych <= 'Q') + goto yy2; + goto yy71; + } + } else { + if (yych <= 'f') { + if (yych == 'c') + goto yy74; + if (yych <= 'e') + goto yy2; + goto yy72; + } else { + if (yych <= 'm') { + if (yych <= 'l') + goto yy2; + goto yy73; + } else { + if (yych == 'r') + goto yy71; + goto yy2; + } + } + } + yy23: + yych = *(marker = ++p); + if (yych == '3') + goto yy66; + goto yy2; + yy24: + yych = *(marker = ++p); + if (yych <= 'O') { + if (yych <= 'H') { + if (yych == 'E') + goto yy56; + goto yy2; + } else { + if (yych <= 'I') + goto yy55; + if (yych <= 'N') + goto yy2; + goto yy54; + } + } else { + if (yych <= 'h') { + if (yych == 'e') + goto yy56; + goto yy2; + } else { + if (yych <= 'i') + goto yy55; + if (yych == 'o') + goto yy54; + goto yy2; + } + } + yy25: + yych = *(marker = ++p); + if (yych == 'D') + goto yy52; + if (yych == 'd') + goto yy52; + goto yy2; + yy26: + yych = *(marker = ++p); + if (yych == 'E') + goto yy47; + if (yych == 'e') + goto yy47; + goto yy2; + yy27: + yych = *(marker = ++p); + if (yych == 'U') + goto yy44; + if (yych == 'u') + goto yy44; + goto yy2; + yy28: + yych = *(marker = ++p); + if (yych == 'M') + goto yy38; + if (yych == 'm') + goto yy38; + goto yy2; + yy29: + yych = *++p; + goto yy2; + yy30: + yych = *++p; + if (yych <= 0x7F) + goto yy31; + if (yych <= 0xBF) + goto yy29; + yy31: + p = marker; + goto yy2; + yy32: + yych = *++p; + if (yych <= 0x9F) + goto yy31; + if (yych <= 0xBF) + goto yy30; + goto yy31; + yy33: + yych = *++p; + if (yych <= 0x7F) + goto yy31; + if (yych <= 0xBF) + goto yy30; + goto yy31; + yy34: + yych = *++p; + if (yych <= 0x8F) + goto yy31; + if (yych <= 0xBF) + goto yy33; + goto yy31; + yy35: + yych = *++p; + if (yych <= 0x7F) + goto yy31; + if (yych <= 0xBF) + goto yy33; + goto yy31; + yy36: + yych = *++p; + if (yych <= 0x7F) + goto yy31; + if (yych <= 0x8F) + goto yy33; + goto yy31; + yy37: + yych = *++p; + if (yych <= 0x7F) + goto yy31; + if (yych <= 0x9F) + goto yy30; + goto yy31; + yy38: + yych = *++p; + if (yych == 'S') + goto yy39; + if (yych != 's') + goto yy31; + yy39: + yych = *++p; + if (yych == 'G') + goto yy40; + if (yych != 'g') + goto yy31; + yy40: + yych = *++p; + if (yych == 'R') + goto yy41; + if (yych != 'r') + goto yy31; + yy41: + yych = *++p; + if (yych != ':') + goto yy31; + yy42: + ++p; + { return (bufsize_t)(p - start); } + yy44: + yych = *++p; + if (yych == 'E') + goto yy45; + if (yych != 'e') + goto yy31; + yy45: + yych = *++p; + if (yych == 'R') + goto yy46; + if (yych != 'r') + goto yy31; + yy46: + yych = *++p; + if (yych == 'Y') + goto yy41; + if (yych == 'y') + goto yy41; + goto yy31; + yy47: + yych = *++p; + if (yych == 'Y') + goto yy48; + if (yych != 'y') + goto yy31; + yy48: + yych = *++p; + if (yych == 'P') + goto yy49; + if (yych != 'p') + goto yy31; + yy49: + yych = *++p; + if (yych == 'A') + goto yy50; + if (yych != 'a') + goto yy31; + yy50: + yych = *++p; + if (yych == 'R') + goto yy51; + if (yych != 'r') + goto yy31; + yy51: + yych = *++p; + if (yych == 'C') + goto yy41; + if (yych == 'c') + goto yy41; + goto yy31; + yy52: + yych = *++p; + if (yych != '2') + goto yy31; + yych = *++p; + if (yych == 'K') + goto yy41; + if (yych == 'k') + goto yy41; + goto yy31; + yy54: + yych = *++p; + if (yych == 'L') + goto yy65; + if (yych == 'l') + goto yy65; + goto yy31; + yy55: + yych = *++p; + if (yych == 'T') + goto yy61; + if (yych == 't') + goto yy61; + goto yy31; + yy56: + yych = *++p; + if (yych == 'S') + goto yy57; + if (yych != 's') + goto yy31; + yy57: + yych = *++p; + if (yych == 'H') + goto yy58; + if (yych != 'h') + goto yy31; + yy58: + yych = *++p; + if (yych == 'A') + goto yy59; + if (yych != 'a') + goto yy31; + yy59: + yych = *++p; + if (yych == 'R') + goto yy60; + if (yych != 'r') + goto yy31; + yy60: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy61: + yych = *++p; + if (yych == 'C') + goto yy62; + if (yych != 'c') + goto yy31; + yy62: + yych = *++p; + if (yych == 'O') + goto yy63; + if (yych != 'o') + goto yy31; + yy63: + yych = *++p; + if (yych == 'I') + goto yy64; + if (yych != 'i') + goto yy31; + yy64: + yych = *++p; + if (yych == 'N') + goto yy41; + if (yych == 'n') + goto yy41; + goto yy31; + yy65: + yych = *++p; + if (yych == 'O') + goto yy41; + if (yych == 'o') + goto yy41; + goto yy31; + yy66: + 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 yy41; + if (yych <= 'q') + goto yy31; + if (yych <= 's') + goto yy41; + goto yy31; + yy71: + yych = *++p; + if (yych == 'I') + goto yy41; + if (yych == 'i') + goto yy41; + goto yy31; + yy72: + yych = *++p; + if (yych == 'I') + goto yy93; + if (yych == 'i') + goto yy93; + goto yy31; + yy73: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') + goto yy83; + if (yych <= 'O') + goto yy31; + goto yy84; + } else { + if (yych <= 'l') { + if (yych <= 'k') + goto yy31; + goto yy83; + } else { + if (yych == 'p') + goto yy84; + goto yy31; + } + } + yy74: + yych = *++p; + if (yych == 'O') + goto yy75; + if (yych != 'o') + goto yy31; + yy75: + yych = *++p; + if (yych == 'N') + goto yy76; + if (yych != 'n') + goto yy31; + yy76: + yych = *++p; + if (yych == '-') + goto yy77; + if (yych == ':') + goto yy42; + goto yy31; + yy77: + yych = *++p; + if (yych == 'U') + goto yy78; + if (yych != 'u') + goto yy31; + yy78: + yych = *++p; + if (yych == 'S') + goto yy79; + if (yych != 's') + goto yy31; + yy79: + yych = *++p; + if (yych == 'E') + goto yy80; + if (yych != 'e') + goto yy31; + yy80: + yych = *++p; + if (yych == 'R') + goto yy81; + if (yych != 'r') + goto yy31; + yy81: + yych = *++p; + if (yych == 'I') + goto yy82; + if (yych != 'i') + goto yy31; + yy82: + yych = *++p; + if (yych == 'D') + goto yy41; + if (yych == 'd') + goto yy41; + goto yy31; + yy83: + yych = *++p; + if (yych == 'R') + goto yy85; + if (yych == 'r') + goto yy85; + goto yy31; + yy84: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy85: + yych = *++p; + if (yych == 'P') + goto yy86; + if (yych != 'p') + goto yy31; + yy86: + yych = *++p; + if (yych == 'C') + goto yy87; + if (yych != 'c') + goto yy31; + yy87: + yych = *++p; + if (yych != '.') + goto yy31; + yych = *++p; + if (yych == 'B') + goto yy89; + if (yych != 'b') + goto yy31; + yy89: + yych = *++p; + if (yych == 'E') + goto yy90; + if (yych != 'e') + goto yy31; + yy90: + yych = *++p; + if (yych == 'E') + goto yy91; + if (yych != 'e') + goto yy31; + yy91: + yych = *++p; + if (yych == 'P') + goto yy92; + if (yych != 'p') + goto yy31; + yy92: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + } + yy93: + yych = *++p; + if (yych == 'R') + goto yy94; + if (yych != 'r') + goto yy31; + yy94: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy95: + yych = *++p; + if (yych == 'C') + goto yy103; + if (yych == 'c') + goto yy103; + goto yy31; + yy96: + yych = *++p; + if (yych == 'A') + goto yy102; + if (yych == 'a') + goto yy102; + goto yy31; + yy97: + yych = *++p; + if (yych == 'B') + goto yy99; + if (yych == 'b') + goto yy99; + goto yy31; + yy98: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + } + yy99: + yych = *++p; + if (yych == 'C') + goto yy100; + if (yych != 'c') + goto yy31; + yy100: + yych = *++p; + if (yych == 'A') + goto yy101; + if (yych != 'a') + goto yy31; + yy101: + yych = *++p; + if (yych == 'L') + goto yy41; + if (yych == 'l') + goto yy41; + goto yy31; + yy102: + yych = *++p; + if (yych == 'I') + goto yy41; + if (yych == 'i') + goto yy41; + goto yy31; + yy103: + yych = *++p; + if (yych == 'I') + goto yy104; + if (yych != 'i') + goto yy31; + yy104: + yych = *++p; + if (yych == 'W') + goto yy105; + if (yych != 'w') + goto yy31; + yy105: + yych = *++p; + if (yych == 'Y') + goto yy106; + if (yych != 'y') + goto yy31; + yy106: + yych = *++p; + if (yych == 'G') + goto yy41; + if (yych == 'g') + goto yy41; + goto yy31; + yy107: + yych = *++p; + if (yych == 'E') + goto yy116; + if (yych == 'e') + goto yy116; + goto yy31; + yy108: + yych = *++p; + if (yych <= 'N') { + if (yych <= 'L') + goto yy31; + if (yych >= 'N') + goto yy110; + } else { + if (yych <= 'l') + goto yy31; + if (yych <= 'm') + goto yy109; + if (yych <= 'n') + goto yy110; + goto yy31; + } + yy109: + yych = *++p; + if (yych == 'M') + goto yy115; + if (yych == 'm') + goto yy115; + goto yy31; + yy110: + yych = *++p; + if (yych == 'T') + goto yy111; + if (yych != 't') + goto yy31; + yy111: + yych = *++p; + if (yych == 'R') + goto yy112; + if (yych != 'r') + goto yy31; + yy112: + yych = *++p; + if (yych == 'I') + goto yy113; + if (yych != 'i') + goto yy31; + yy113: + yych = *++p; + if (yych == 'L') + goto yy114; + if (yych != 'l') + goto yy31; + yy114: + yych = *++p; + if (yych == 'O') + goto yy41; + if (yych == 'o') + goto yy41; + goto yy31; + yy115: + yych = *++p; + if (yych == 'I') + goto yy41; + if (yych == 'i') + goto yy41; + goto yy31; + yy116: + yych = *++p; + if (yych == 'W') + goto yy117; + if (yych != 'w') + goto yy31; + yy117: + yych = *++p; + if (yych != '-') + goto yy31; + yych = *++p; + if (yych == 'S') + goto yy119; + if (yych != 's') + goto yy31; + yy119: + yych = *++p; + if (yych == 'O') + goto yy120; + if (yych != 'o') + goto yy31; + yy120: + yych = *++p; + if (yych == 'U') + goto yy121; + if (yych != 'u') + goto yy31; + yy121: + yych = *++p; + if (yych == 'R') + goto yy122; + if (yych != 'r') + goto yy31; + yy122: + yych = *++p; + if (yych == 'C') + goto yy123; + if (yych != 'c') + goto yy31; + yy123: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy124: + yych = *++p; + if (yych == '2') + goto yy131; + goto yy31; + yy125: + yych = *++p; + if (yych == 'R') + goto yy128; + if (yych == 'r') + goto yy128; + goto yy31; + yy126: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy127: + yych = *++p; + if (yych == 'N') + goto yy41; + if (yych == 'n') + goto yy41; + goto yy31; + yy128: + yych = *++p; + if (yych == 'E') + goto yy129; + if (yych != 'e') + goto yy31; + yy129: + yych = *++p; + if (yych == 'A') + goto yy130; + if (yych != 'a') + goto yy31; + yy130: + yych = *++p; + if (yych == 'L') + goto yy41; + if (yych == 'l') + goto yy41; + goto yy31; + yy131: + yych = *++p; + if (yych != '0') + goto yy31; + yych = *++p; + if (yych != '0') + goto yy31; + yych = *++p; + if (yych == '4') + goto yy41; + goto yy31; + yy134: + yych = *++p; + if (yych == 'I') + goto yy153; + if (yych == 'i') + goto yy153; + goto yy31; + yy135: + yych = *++p; + if (yych <= 'L') { + if (yych == 'A') + goto yy145; + if (yych <= 'K') + goto yy31; + goto yy144; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy31; + goto yy145; + } else { + if (yych == 'l') + goto yy144; + goto yy31; + } + } + yy136: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy137: + yych = *++p; + if (yych == '3') + goto yy141; + goto yy31; + yy138: + yych = *++p; + if (yych == 'T') + goto yy140; + if (yych == 't') + goto yy140; + goto yy31; + yy139: + yych = *++p; + if (yych == 'G') + goto yy41; + if (yych == 'g') + goto yy41; + goto yy31; + yy140: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy141: + yych = *++p; + if (yych != '2') + goto yy31; + yych = *++p; + if (yych != '7') + goto yy31; + yych = *++p; + if (yych == '0') + goto yy41; + goto yy31; + yy144: + yych = *++p; + if (yych <= 'M') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'N') + goto yy151; + if (yych == 'n') + goto yy151; + goto yy31; + } + yy145: + yych = *++p; + if (yych == 'M') + goto yy146; + if (yych != 'm') + goto yy31; + yy146: + yych = *++p; + if (yych == 'S') + goto yy147; + if (yych != 's') + goto yy31; + yy147: + yych = *++p; + if (yych == 'P') + goto yy148; + if (yych != 'p') + goto yy31; + yy148: + yych = *++p; + if (yych == 'E') + goto yy149; + if (yych != 'e') + goto yy31; + yy149: + yych = *++p; + if (yych == 'A') + goto yy150; + if (yych != 'a') + goto yy31; + yy150: + yych = *++p; + if (yych == 'K') + goto yy41; + if (yych == 'k') + goto yy41; + goto yy31; + yy151: + yych = *++p; + if (yych == 'E') + goto yy152; + if (yych != 'e') + goto yy31; + yy152: + yych = *++p; + if (yych == 'T') + goto yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy153: + yych = *++p; + if (yych <= 'S') { + if (yych == 'N') + goto yy154; + if (yych <= 'R') + goto yy31; + goto yy155; + } else { + if (yych <= 'n') { + if (yych <= 'm') + goto yy31; + } else { + if (yych == 's') + goto yy155; + goto yy31; + } + } + yy154: + yych = *++p; + if (yych == 'G') + goto yy162; + if (yych == 'g') + goto yy162; + goto yy31; + yy155: + yych = *++p; + if (yych == 'M') + goto yy156; + if (yych != 'm') + goto yy31; + yy156: + yych = *++p; + if (yych == 'E') + goto yy157; + if (yych != 'e') + goto yy31; + yy157: + yych = *++p; + if (yych == 'S') + goto yy158; + if (yych != 's') + goto yy31; + yy158: + yych = *++p; + if (yych == 'S') + goto yy159; + if (yych != 's') + goto yy31; + yy159: + yych = *++p; + if (yych == 'A') + goto yy160; + if (yych != 'a') + goto yy31; + yy160: + yych = *++p; + if (yych == 'G') + goto yy161; + if (yych != 'g') + goto yy31; + yy161: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy162: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy163: + yych = *++p; + if (yych == 'N') + goto yy41; + if (yych == 'n') + goto yy41; + goto yy31; + yy164: + yych = *++p; + if (yych == 'E') + goto yy214; + if (yych == 'e') + goto yy214; + goto yy31; + yy165: + yych = *++p; + if (yych == 'H') + goto yy41; + if (yych == 'h') + goto yy41; + goto yy31; + yy166: + yych = *++p; + if (yych == 'O') + goto yy210; + if (yych == 'o') + goto yy210; + goto yy31; + yy167: + yych = *++p; + if (yych <= 'L') { + if (yych == 'A') + goto yy200; + if (yych <= 'K') + goto yy31; + goto yy201; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy31; + goto yy200; + } else { + if (yych == 'l') + goto yy201; + goto yy31; + } + } + yy168: + yych = *++p; + if (yych <= 'S') { + if (yych == 'B') + goto yy41; + if (yych <= 'R') + goto yy31; + goto yy41; + } else { + if (yych <= 'b') { + if (yych <= 'a') + goto yy31; + goto yy41; + } else { + if (yych == 's') + goto yy41; + goto yy31; + } + } + yy169: + yych = *++p; + if (yych == 'Y') + goto yy198; + if (yych == 'y') + goto yy198; + goto yy31; + yy170: + yych = *++p; + if (yych == 'N') + goto yy41; + if (yych == 'n') + goto yy41; + goto yy31; + yy171: + yych = *++p; + if (yych == 'T') + goto yy197; + if (yych == 't') + goto yy197; + goto yy31; + yy172: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'C') { + if (yych <= 'B') + goto yy31; + goto yy184; + } else { + if (yych <= 'Q') + goto yy31; + if (yych <= 'R') + goto yy182; + goto yy183; + } + } else { + if (yych <= 'q') { + if (yych == 'c') + goto yy184; + goto yy31; + } else { + if (yych <= 'r') + goto yy182; + if (yych <= 's') + goto yy183; + goto yy31; + } + } + yy173: + yych = *++p; + if (yych == 'M') + goto yy181; + if (yych == 'm') + goto yy181; + goto yy31; + yy174: + yych = *++p; + if (yych <= 'P') { + if (yych == 'E') + goto yy178; + if (yych <= 'O') + goto yy31; + goto yy179; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy31; + goto yy178; + } else { + if (yych == 'p') + goto yy179; + goto yy31; + } + } + yy175: + yych = *++p; + if (yych == 'T') + goto yy176; + if (yych != 't') + goto yy31; + yy176: + yych = *++p; + if (yych == 'T') + goto yy177; + if (yych != 't') + goto yy31; + yy177: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy178: + yych = *++p; + if (yych == 'V') + goto yy180; + if (yych == 'v') + goto yy180; + goto yy31; + yy179: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + } + yy180: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy181: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy182: + yych = *++p; + if (yych == 'V') + goto yy194; + if (yych == 'v') + goto yy194; + goto yy31; + yy183: + yych = *++p; + if (yych == 'S') + goto yy191; + if (yych == 's') + goto yy191; + goto yy31; + yy184: + yych = *++p; + if (yych == 'O') + goto yy185; + if (yych != 'o') + goto yy31; + yy185: + yych = *++p; + if (yych == 'N') + goto yy186; + if (yych != 'n') + goto yy31; + yy186: + yych = *++p; + if (yych == 'D') + goto yy187; + if (yych != 'd') + goto yy31; + yy187: + yych = *++p; + if (yych == 'L') + goto yy188; + if (yych != 'l') + goto yy31; + yy188: + yych = *++p; + if (yych == 'I') + goto yy189; + if (yych != 'i') + goto yy31; + yy189: + yych = *++p; + if (yych == 'F') + goto yy190; + if (yych != 'f') + goto yy31; + yy190: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy191: + yych = *++p; + if (yych == 'I') + goto yy192; + if (yych != 'i') + goto yy31; + yy192: + yych = *++p; + if (yych == 'O') + goto yy193; + if (yych != 'o') + goto yy31; + yy193: + yych = *++p; + if (yych == 'N') + goto yy41; + if (yych == 'n') + goto yy41; + goto yy31; + yy194: + yych = *++p; + if (yych == 'I') + goto yy195; + if (yych != 'i') + goto yy31; + yy195: + yych = *++p; + if (yych == 'C') + goto yy196; + if (yych != 'c') + goto yy31; + yy196: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy197: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy198: + yych = *++p; + if (yych == 'P') + goto yy199; + if (yych != 'p') + goto yy31; + yy199: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy200: + yych = *++p; + if (yych == 'P') + goto yy204; + if (yych == 'p') + goto yy204; + goto yy31; + yy201: + yych = *++p; + if (yych == 'D') + goto yy202; + if (yych != 'd') + goto yy31; + yy202: + yych = *++p; + if (yych == 'A') + goto yy203; + if (yych != 'a') + goto yy31; + yy203: + yych = *++p; + if (yych == 'T') + goto yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy204: + yych = *++p; + if (yych != '.') + goto yy31; + yych = *++p; + if (yych == 'B') + goto yy206; + if (yych != 'b') + goto yy31; + yy206: + yych = *++p; + if (yych == 'E') + goto yy207; + if (yych != 'e') + goto yy31; + yy207: + yych = *++p; + if (yych == 'E') + goto yy208; + if (yych != 'e') + goto yy31; + yy208: + yych = *++p; + if (yych == 'P') + goto yy209; + if (yych != 'p') + goto yy31; + yy209: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + } + yy210: + yych = *++p; + if (yych == 'T') + goto yy211; + if (yych != 't') + goto yy31; + yy211: + yych = *++p; + if (yych == 'I') + goto yy212; + if (yych != 'i') + goto yy31; + yy212: + yych = *++p; + if (yych == 'F') + goto yy213; + if (yych != 'f') + goto yy31; + yy213: + yych = *++p; + if (yych == 'Y') + goto yy41; + if (yych == 'y') + goto yy41; + goto yy31; + yy214: + yych = *++p; + if (yych == 'A') + goto yy215; + if (yych != 'a') + goto yy31; + yy215: + yych = *++p; + if (yych == 'M') + goto yy41; + if (yych == 'm') + goto yy41; + goto yy31; + yy216: + yych = *++p; + if (yych <= 'S') { + if (yych == 'M') + goto yy228; + if (yych <= 'R') + goto yy31; + goto yy227; + } else { + if (yych <= 'm') { + if (yych <= 'l') + goto yy31; + goto yy228; + } else { + if (yych == 's') + goto yy227; + goto yy31; + } + } + yy217: + yych = *++p; + if (yych == 'Y') + goto yy225; + if (yych == 'y') + goto yy225; + goto yy31; + yy218: + yych = *++p; + if (yych == 'I') + goto yy41; + if (yych == 'i') + goto yy41; + goto yy31; + yy219: + yych = *++p; + if (yych == 'S') + goto yy220; + if (yych != 's') + goto yy31; + yy220: + yych = *++p; + if (yych <= 'N') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'O') + goto yy221; + if (yych != 'o') + goto yy31; + } + yy221: + yych = *++p; + if (yych == 'U') + goto yy222; + if (yych != 'u') + goto yy31; + yy222: + yych = *++p; + if (yych == 'R') + goto yy223; + if (yych != 'r') + goto yy31; + yy223: + yych = *++p; + if (yych == 'C') + goto yy224; + if (yych != 'c') + goto yy31; + yy224: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy225: + yych = *++p; + if (yych == 'N') + goto yy226; + if (yych != 'n') + goto yy31; + yy226: + yych = *++p; + if (yych == 'C') + goto yy41; + if (yych == 'c') + goto yy41; + goto yy31; + yy227: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy228: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy229: + yych = *++p; + if (yych == 'Y') + goto yy249; + if (yych == 'y') + goto yy249; + goto yy31; + yy230: + yych = *++p; + if (yych <= 'O') { + if (yych == 'E') + goto yy246; + if (yych <= 'N') + goto yy31; + goto yy247; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy31; + goto yy246; + } else { + if (yych == 'o') + goto yy247; + goto yy31; + } + } + yy231: + yych = *++p; + if (yych == 'A') + goto yy241; + if (yych == 'a') + goto yy241; + goto yy31; + yy232: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') + goto yy234; + if (yych <= 'O') + goto yy31; + goto yy235; + } else { + if (yych <= 'l') { + if (yych <= 'k') + goto yy31; + goto yy234; + } else { + if (yych == 'p') + goto yy235; + goto yy31; + } + } + yy233: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy234: + yych = *++p; + if (yych == 'M') + goto yy41; + if (yych == 'm') + goto yy41; + goto yy31; + yy235: + yych = *++p; + if (yych == 'A') + goto yy236; + if (yych != 'a') + goto yy31; + yy236: + yych = *++p; + if (yych == 'R') + goto yy237; + if (yych != 'r') + goto yy31; + yy237: + yych = *++p; + if (yych == 'A') + goto yy238; + if (yych != 'a') + goto yy31; + yy238: + yych = *++p; + if (yych == 'Z') + goto yy239; + if (yych != 'z') + goto yy31; + yy239: + yych = *++p; + if (yych == 'Z') + goto yy240; + if (yych != 'z') + goto yy31; + yy240: + yych = *++p; + if (yych == 'I') + goto yy41; + if (yych == 'i') + goto yy41; + goto yy31; + yy241: + yych = *++p; + if (yych == 'T') + goto yy242; + if (yych != 't') + goto yy31; + yy242: + yych = *++p; + if (yych == 'F') + goto yy243; + if (yych != 'f') + goto yy31; + yy243: + yych = *++p; + if (yych == 'O') + goto yy244; + if (yych != 'o') + goto yy31; + yy244: + yych = *++p; + if (yych == 'R') + goto yy245; + if (yych != 'r') + goto yy31; + yy245: + yych = *++p; + if (yych == 'M') + goto yy41; + if (yych == 'm') + goto yy41; + goto yy31; + yy246: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy247: + yych = *++p; + if (yych == 'X') + goto yy248; + if (yych != 'x') + goto yy31; + yy248: + yych = *++p; + if (yych == 'Y') + goto yy41; + if (yych == 'y') + goto yy41; + goto yy31; + yy249: + yych = *++p; + if (yych == 'C') + goto yy41; + if (yych == 'c') + goto yy41; + goto yy31; + yy250: + yych = *++p; + if (yych == 'D') + goto yy41; + if (yych == 'd') + goto yy41; + goto yy31; + yy251: + yych = *++p; + if (yych == 'A') + goto yy252; + if (yych != 'a') + goto yy31; + yy252: + yych = *++p; + if (yych == 'Q') + goto yy253; + if (yych != 'q') + goto yy31; + yy253: + yych = *++p; + if (yych == 'U') + goto yy254; + if (yych != 'u') + goto yy31; + yy254: + yych = *++p; + if (yych == 'E') + goto yy255; + if (yych != 'e') + goto yy31; + yy255: + yych = *++p; + if (yych == 'L') + goto yy256; + if (yych != 'l') + goto yy31; + yy256: + yych = *++p; + if (yych == 'O') + goto yy257; + if (yych != 'o') + goto yy31; + yy257: + yych = *++p; + if (yych == 'C') + goto yy258; + if (yych != 'c') + goto yy31; + yy258: + yych = *++p; + if (yych == 'K') + goto yy259; + if (yych != 'k') + goto yy31; + yy259: + yych = *++p; + if (yych == 'T') + goto yy260; + if (yych != 't') + goto yy31; + yy260: + yych = *++p; + if (yych == 'O') + goto yy261; + if (yych != 'o') + goto yy31; + yy261: + yych = *++p; + if (yych == 'K') + goto yy262; + if (yych != 'k') + goto yy31; + yy262: + yych = *++p; + if (yych == 'E') + goto yy263; + if (yych != 'e') + goto yy31; + yy263: + yych = *++p; + if (yych == 'N') + goto yy41; + if (yych == 'n') + goto yy41; + goto yy31; + yy264: + yych = *++p; + if (yych == 'T') + goto yy271; + if (yych == 't') + goto yy271; + goto yy31; + yy265: + yych = *++p; + if (yych == 'T') + goto yy270; + if (yych == 't') + goto yy270; + goto yy31; + yy266: + yych = *++p; + if (yych <= 'G') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'H') + goto yy41; + if (yych == 'h') + goto yy41; + goto yy31; + } + yy267: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy268: + yych = *++p; + if (yych == 'W') + goto yy269; + if (yych != 'w') + goto yy31; + yy269: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy270: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy271: + yych = *++p; + if (yych == 'E') + goto yy272; + if (yych != 'e') + goto yy31; + yy272: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy273: + yych = *++p; + if (yych == 'N') + goto yy41; + if (yych == 'n') + goto yy41; + goto yy31; + yy274: + yych = *++p; + if (yych <= 'P') { + if (yych == 'M') + goto yy305; + if (yych <= 'O') + goto yy31; + goto yy304; + } else { + if (yych <= 'm') { + if (yych <= 'l') + goto yy31; + goto yy305; + } else { + if (yych == 'p') + goto yy304; + goto yy31; + } + } + yy275: + yych = *++p; + if (yych <= 'Q') { + if (yych <= '-') { + if (yych <= ',') + goto yy31; + goto yy297; + } else { + if (yych == 'N') + goto yy298; + goto yy31; + } + } else { + if (yych <= 'n') { + if (yych <= 'R') + goto yy296; + if (yych <= 'm') + goto yy31; + goto yy298; + } else { + if (yych == 'r') + goto yy296; + goto yy31; + } + } + yy276: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy277: + yych = *++p; + if (yych == 'S') + goto yy292; + if (yych == 's') + goto yy292; + goto yy31; + yy278: + yych = *++p; + switch (yych) { + case 'G': + case 'g': + goto yy283; + case 'I': + case 'i': + goto yy282; + case 'P': + case 'p': + goto yy284; + case 'R': + case 'r': + goto yy285; + default: + goto yy31; + } + yy279: + yych = *++p; + if (yych == 'Q') + goto yy281; + if (yych == 'q') + goto yy281; + goto yy31; + yy280: + yych = *++p; + if (yych == 'D') + goto yy41; + if (yych == 'd') + goto yy41; + goto yy31; + yy281: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy282: + yych = *++p; + if (yych == 'L') + goto yy290; + if (yych == 'l') + goto yy290; + goto yy31; + yy283: + yych = *++p; + if (yych == 'N') + goto yy288; + if (yych == 'n') + goto yy288; + goto yy31; + yy284: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy285: + yych = *++p; + if (yych == 'K') + goto yy286; + if (yych != 'k') + goto yy31; + yy286: + yych = *++p; + if (yych == 'E') + goto yy287; + if (yych != 'e') + goto yy31; + yy287: + yych = *++p; + if (yych == 'T') + goto yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy288: + yych = *++p; + if (yych == 'E') + goto yy289; + if (yych != 'e') + goto yy31; + yy289: + yych = *++p; + if (yych == 'T') + goto yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy290: + yych = *++p; + if (yych == 'T') + goto yy291; + if (yych != 't') + goto yy31; + yy291: + yych = *++p; + if (yych == 'O') + goto yy41; + if (yych == 'o') + goto yy41; + goto yy31; + yy292: + yych = *++p; + if (yych == 'S') + goto yy293; + if (yych != 's') + goto yy31; + yy293: + yych = *++p; + if (yych == 'A') + goto yy294; + if (yych != 'a') + goto yy31; + yy294: + yych = *++p; + if (yych == 'G') + goto yy295; + if (yych != 'g') + goto yy31; + yy295: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy296: + yych = *++p; + if (yych == 'P') + goto yy303; + if (yych == 'p') + goto yy303; + goto yy31; + yy297: + yych = *++p; + if (yych == 'H') + goto yy300; + if (yych == 'h') + goto yy300; + goto yy31; + yy298: + yych = *++p; + if (yych == 'I') + goto yy299; + if (yych != 'i') + goto yy31; + yy299: + yych = *++p; + if (yych == 'M') + goto yy41; + if (yych == 'm') + goto yy41; + goto yy31; + yy300: + yych = *++p; + if (yych == 'E') + goto yy301; + if (yych != 'e') + goto yy31; + yy301: + yych = *++p; + if (yych == 'L') + goto yy302; + if (yych != 'l') + goto yy31; + yy302: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy303: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + } + yy304: + yych = *++p; + if (yych == 'D') + goto yy308; + if (yych == 'd') + goto yy308; + goto yy31; + yy305: + yych = *++p; + if (yych == 'B') + goto yy306; + if (yych != 'b') + goto yy31; + yy306: + yych = *++p; + if (yych == 'L') + goto yy307; + if (yych != 'l') + goto yy31; + yy307: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy308: + yych = *++p; + if (yych == 'A') + goto yy309; + if (yych != 'a') + goto yy31; + yy309: + yych = *++p; + if (yych == 'T') + goto yy310; + if (yych != 't') + goto yy31; + yy310: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy311: + yych = *++p; + if (yych == 'A') + goto yy316; + if (yych == 'a') + goto yy316; + goto yy31; + yy312: + yych = *++p; + if (yych == 'S') + goto yy313; + if (yych != 's') + goto yy31; + yy313: + yych = *++p; + if (yych == 'T') + goto yy314; + if (yych != 't') + goto yy31; + yy314: + yych = *++p; + if (yych == 'F') + goto yy315; + if (yych != 'f') + goto yy31; + yy315: + yych = *++p; + if (yych == 'M') + goto yy41; + if (yych == 'm') + goto yy41; + goto yy31; + yy316: + yych = *++p; + if (yych == 'P') + goto yy317; + if (yych != 'p') + goto yy31; + yy317: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + } + yy318: + yych = *++p; + if (yych == 'M') + goto yy341; + if (yych == 'm') + goto yy341; + goto yy31; + yy319: + yych = *++p; + if (yych <= 'I') { + if (yych == 'C') + goto yy330; + if (yych <= 'H') + goto yy31; + goto yy329; + } else { + if (yych <= 'c') { + if (yych <= 'b') + goto yy31; + goto yy330; + } else { + if (yych == 'i') + goto yy329; + goto yy31; + } + } + yy320: + yych = *++p; + if (yych <= 'P') { + if (yych == 'N') + goto yy41; + if (yych <= 'O') + goto yy31; + goto yy41; + } else { + if (yych <= 'n') { + if (yych <= 'm') + goto yy31; + goto yy41; + } else { + if (yych == 'p') + goto yy41; + goto yy31; + } + } + yy321: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') + goto yy327; + if (yych <= 'N') + goto yy31; + goto yy328; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy31; + goto yy327; + } else { + if (yych == 'o') + goto yy328; + goto yy31; + } + } + yy322: + yych = *++p; + if (yych == 'F') + goto yy326; + if (yych == 'f') + goto yy326; + goto yy31; + yy323: + yych = *++p; + if (yych <= '@') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'A') + goto yy325; + if (yych == 'a') + goto yy325; + goto yy31; + } + yy324: + yych = *++p; + if (yych == 'X') + goto yy41; + if (yych == 'x') + goto yy41; + goto yy31; + yy325: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy326: + yych = *++p; + if (yych == 'O') + goto yy41; + if (yych == 'o') + goto yy41; + goto yy31; + yy327: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy328: + yych = *++p; + if (yych == 'N') + goto yy41; + if (yych == 'n') + goto yy41; + goto yy31; + yy329: + yych = *++p; + if (yych == 'S') + goto yy331; + if (yych == 's') + goto yy331; + goto yy31; + yy330: + yych = *++p; + if (yych <= ':') { + if (yych == '6') + goto yy41; + if (yych <= '9') + goto yy31; + goto yy42; + } else { + if (yych <= 'S') { + if (yych <= 'R') + goto yy31; + goto yy41; + } else { + if (yych == 's') + goto yy41; + goto yy31; + } + } + yy331: + yych = *++p; + if (yych == '.') + goto yy332; + if (yych == ':') + goto yy42; + goto yy31; + yy332: + yych = *++p; + if (yych <= 'X') { + if (yych <= 'K') { + if (yych == 'B') + goto yy335; + goto yy31; + } else { + if (yych <= 'L') + goto yy333; + if (yych <= 'W') + goto yy31; + goto yy334; + } + } else { + if (yych <= 'k') { + if (yych == 'b') + goto yy335; + goto yy31; + } else { + if (yych <= 'l') + goto yy333; + if (yych == 'x') + goto yy334; + goto yy31; + } + } + yy333: + yych = *++p; + if (yych == 'W') + goto yy340; + if (yych == 'w') + goto yy340; + goto yy31; + yy334: + yych = *++p; + if (yych == 'P') + goto yy338; + if (yych == 'p') + goto yy338; + goto yy31; + yy335: + yych = *++p; + if (yych == 'E') + goto yy336; + if (yych != 'e') + goto yy31; + yy336: + yych = *++p; + if (yych == 'E') + goto yy337; + if (yych != 'e') + goto yy31; + yy337: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy338: + yych = *++p; + if (yych == 'C') + goto yy339; + if (yych != 'c') + goto yy31; + yy339: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + } + yy340: + yych = *++p; + if (yych == 'Z') + goto yy41; + if (yych == 'z') + goto yy41; + goto yy31; + yy341: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy342: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy343: + yych = *++p; + if (yych == 'T') + goto yy346; + if (yych == 't') + goto yy346; + goto yy31; + yy344: + yych = *++p; + if (yych != '2') + goto yy31; + yych = *++p; + if (yych == '3') + goto yy41; + goto yy31; + yy346: + yych = *++p; + if (yych == 'P') + goto yy347; + if (yych != 'p') + goto yy31; + yy347: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + } + yy348: + yych = *++p; + if (yych == 'A') + goto yy364; + if (yych == 'a') + goto yy364; + goto yy31; + yy349: + yych = *++p; + if (yych <= 'Z') { + if (yych == 'T') + goto yy41; + if (yych <= 'Y') + goto yy31; + goto yy355; + } else { + if (yych <= 't') { + if (yych <= 's') + goto yy31; + goto yy41; + } else { + if (yych == 'z') + goto yy355; + goto yy31; + } + } + yy350: + yych = *++p; + if (yych <= 'O') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'P') + goto yy352; + if (yych == 'p') + goto yy352; + goto yy31; + } + yy351: + yych = *++p; + if (yych == 'O') + goto yy41; + if (yych == 'o') + goto yy41; + goto yy31; + yy352: + yych = *++p; + if (yych == 'H') + goto yy353; + if (yych != 'h') + goto yy31; + yy353: + yych = *++p; + if (yych == 'E') + goto yy354; + if (yych != 'e') + goto yy31; + yy354: + yych = *++p; + if (yych == 'R') + goto yy41; + if (yych == 'r') + goto yy41; + goto yy31; + yy355: + yych = *++p; + if (yych == 'M') + goto yy356; + if (yych != 'm') + goto yy31; + yy356: + yych = *++p; + if (yych == 'O') + goto yy357; + if (yych != 'o') + goto yy31; + yy357: + yych = *++p; + if (yych == 'P') + goto yy358; + if (yych != 'p') + goto yy31; + yy358: + yych = *++p; + if (yych == 'R') + goto yy359; + if (yych != 'r') + goto yy31; + yy359: + yych = *++p; + if (yych == 'O') + goto yy360; + if (yych != 'o') + goto yy31; + yy360: + yych = *++p; + if (yych == 'J') + goto yy361; + if (yych != 'j') + goto yy31; + yy361: + yych = *++p; + if (yych == 'E') + goto yy362; + if (yych != 'e') + goto yy31; + yy362: + yych = *++p; + if (yych == 'C') + goto yy363; + if (yych != 'c') + goto yy31; + yy363: + yych = *++p; + if (yych == 'T') + goto yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy364: + yych = *++p; + if (yych == 'L') + goto yy365; + if (yych != 'l') + goto yy31; + yy365: + yych = *++p; + if (yych == 'K') + goto yy41; + if (yych == 'k') + goto yy41; + goto yy31; + yy366: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'M') { + if (yych == 'L') + goto yy376; + goto yy31; + } else { + if (yych <= 'N') + goto yy377; + if (yych <= 'R') + goto yy31; + goto yy378; + } + } else { + if (yych <= 'm') { + if (yych == 'l') + goto yy376; + goto yy31; + } else { + if (yych <= 'n') + goto yy377; + if (yych == 's') + goto yy378; + goto yy31; + } + } + yy367: + yych = *++p; + if (yych == 'E') + goto yy375; + if (yych == 'e') + goto yy375; + goto yy31; + yy368: + yych = *++p; + if (yych == 'C') + goto yy370; + if (yych == 'c') + goto yy370; + goto yy31; + yy369: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy370: + yych = *++p; + if (yych == 'E') + goto yy371; + if (yych != 'e') + goto yy31; + yy371: + yych = *++p; + if (yych == 'T') + goto yy372; + if (yych != 't') + goto yy31; + yy372: + yych = *++p; + if (yych == 'I') + goto yy373; + if (yych != 'i') + goto yy31; + yy373: + yych = *++p; + if (yych == 'M') + goto yy374; + if (yych != 'm') + goto yy31; + yy374: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy375: + yych = *++p; + if (yych == 'D') + goto yy41; + if (yych == 'd') + goto yy41; + goto yy31; + yy376: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy377: + yych = *++p; + if (yych == 'G') + goto yy379; + if (yych == 'g') + goto yy379; + goto yy31; + yy378: + yych = *++p; + if (yych == 'H') + goto yy41; + if (yych == 'h') + goto yy41; + goto yy31; + yy379: + yych = *++p; + if (yych == 'E') + goto yy380; + if (yych != 'e') + goto yy31; + yy380: + yych = *++p; + if (yych == 'R') + goto yy41; + if (yych == 'r') + goto yy41; + goto yy31; + yy381: + yych = *++p; + if (yych == 'T') + goto yy399; + if (yych == 't') + goto yy399; + goto yy31; + yy382: + yych = *++p; + if (yych == 'T') + goto yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy383: + yych = *++p; + if (yych == 'M') + goto yy41; + if (yych == 'm') + goto yy41; + goto yy31; + yy384: + yych = *++p; + if (yych <= 'S') { + if (yych == 'P') + goto yy41; + if (yych <= 'R') + goto yy31; + goto yy41; + } else { + if (yych <= 'p') { + if (yych <= 'o') + goto yy31; + goto yy41; + } else { + if (yych == 's') + goto yy41; + goto yy31; + } + } + yy385: + yych = *++p; + if (yych == 'I') + goto yy393; + if (yych == 'i') + goto yy393; + goto yy31; + yy386: + yych = *++p; + if (yych == 'A') + goto yy392; + if (yych == 'a') + goto yy392; + goto yy31; + yy387: + yych = *++p; + if (yych == 'O') + goto yy390; + if (yych == 'o') + goto yy390; + goto yy31; + yy388: + yych = *++p; + if (yych == 'A') + goto yy389; + if (yych != 'a') + goto yy31; + yy389: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy42; + goto yy31; + } else { + if (yych <= 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + } + yy390: + yych = *++p; + if (yych == 'U') + goto yy391; + if (yych != 'u') + goto yy31; + yy391: + yych = *++p; + if (yych == 'T') + goto yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy392: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy393: + yych = *++p; + if (yych == 'U') + goto yy394; + if (yych != 'u') + goto yy31; + yy394: + yych = *++p; + if (yych == 'M') + goto yy395; + if (yych != 'm') + goto yy31; + yy395: + yych = *++p; + if (yych == 'X') + goto yy396; + if (yych != 'x') + goto yy31; + yy396: + yych = *++p; + if (yych == 'T') + goto yy397; + if (yych != 't') + goto yy31; + yy397: + yych = *++p; + if (yych == 'R') + goto yy398; + if (yych != 'r') + goto yy31; + yy398: + yych = *++p; + if (yych == 'A') + goto yy41; + if (yych == 'a') + goto yy41; + goto yy31; + yy399: + yych = *++p; + if (yych == 'A') + goto yy400; + if (yych != 'a') + goto yy31; + yy400: + yych = *++p; + if (yych == 'C') + goto yy401; + if (yych != 'c') + goto yy31; + yy401: + yych = *++p; + if (yych == 'H') + goto yy402; + if (yych != 'h') + goto yy31; + yy402: + yych = *++p; + if (yych == 'M') + goto yy403; + if (yych != 'm') + goto yy31; + yy403: + yych = *++p; + if (yych == 'E') + goto yy404; + if (yych != 'e') + goto yy31; + yy404: + yych = *++p; + if (yych == 'N') + goto yy405; + if (yych != 'n') + goto yy31; + yy405: + yych = *++p; + if (yych == 'T') + goto yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy406: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy407: + yych = *++p; + if (yych <= 'V') { + if (yych == 'R') + goto yy41; + if (yych <= 'U') + goto yy31; + } else { + if (yych <= 'r') { + if (yych <= 'q') + goto yy31; + goto yy41; + } else { + if (yych != 'v') + goto yy31; + } + } + yych = *++p; + if (yych == 'A') + goto yy409; + if (yych != 'a') + goto yy31; + yy409: + yych = *++p; + if (yych == 'S') + goto yy410; + if (yych != 's') + goto yy31; + yy410: + yych = *++p; + if (yych == 'C') + goto yy411; + if (yych != 'c') + goto yy31; + yy411: + yych = *++p; + if (yych == 'R') + goto yy412; + if (yych != 'r') + goto yy31; + yy412: + yych = *++p; + if (yych == 'I') + goto yy413; + if (yych != 'i') + goto yy31; + yy413: + yych = *++p; + if (yych == 'P') + goto yy414; + if (yych != 'p') + goto yy31; + yy414: + yych = *++p; + if (yych == 'T') + goto yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy415: + yych = *++p; + if (yych == 'B') + goto yy41; + if (yych == 'b') + goto yy41; + goto yy31; + yy416: + yych = *++p; + if (yych == 'N') + goto yy41; + if (yych == 'n') + goto yy41; + goto yy31; + yy417: + yych = *++p; + if (yych == 'N') + goto yy424; + if (yych == 'n') + goto yy424; + goto yy31; + yy418: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy419: + yych = *++p; + if (yych == 'C') + goto yy423; + if (yych == 'c') + goto yy423; + goto yy31; + yy420: + yych = *++p; + if (yych <= 'V') { + if (yych == 'T') + goto yy422; + if (yych <= 'U') + goto yy31; + goto yy41; + } else { + if (yych <= 't') { + if (yych <= 's') + goto yy31; + goto yy422; + } else { + if (yych == 'v') + goto yy41; + goto yy31; + } + } + yy421: + yych = *++p; + if (yych == 'I') + goto yy41; + if (yych == 'i') + goto yy41; + goto yy31; + yy422: + yych = *++p; + if (yych == 'A') + goto yy41; + if (yych == 'a') + goto yy41; + goto yy31; + yy423: + yych = *++p; + if (yych == 'T') + goto yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy424: + yych = *++p; + if (yych == 'A') + goto yy425; + if (yych != 'a') + goto yy31; + yy425: + yych = *++p; + if (yych != '-') + goto yy31; + yych = *++p; + if (yych == 'P') + goto yy427; + if (yych != 'p') + goto yy31; + yy427: + yych = *++p; + if (yych == 'L') + goto yy428; + if (yych != 'l') + goto yy31; + yy428: + yych = *++p; + if (yych == 'A') + goto yy429; + if (yych != 'a') + goto yy31; + yy429: + yych = *++p; + if (yych == 'Y') + goto yy430; + if (yych != 'y') + goto yy31; + yy430: + yych = *++p; + if (yych <= 'S') { + if (yych == 'C') + goto yy431; + if (yych <= 'R') + goto yy31; + goto yy432; + } else { + if (yych <= 'c') { + if (yych <= 'b') + goto yy31; + } else { + if (yych == 's') + goto yy432; + goto yy31; + } + } + yy431: + yych = *++p; + if (yych == 'O') + goto yy437; + if (yych == 'o') + goto yy437; + goto yy31; + yy432: + yych = *++p; + if (yych == 'I') + goto yy433; + if (yych != 'i') + goto yy31; + yy433: + yych = *++p; + if (yych == 'N') + goto yy434; + if (yych != 'n') + goto yy31; + yy434: + yych = *++p; + if (yych == 'G') + goto yy435; + if (yych != 'g') + goto yy31; + yy435: + yych = *++p; + if (yych == 'L') + goto yy436; + if (yych != 'l') + goto yy31; + yy436: + yych = *++p; + if (yych == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + yy437: + yych = *++p; + if (yych == 'N') + goto yy438; + if (yych != 'n') + goto yy31; + yy438: + yych = *++p; + if (yych == 'T') + goto yy439; + if (yych != 't') + goto yy31; + yy439: + yych = *++p; + if (yych == 'A') + goto yy440; + if (yych != 'a') + goto yy31; + yy440: + yych = *++p; + if (yych == 'I') + goto yy441; + if (yych != 'i') + goto yy31; + yy441: + yych = *++p; + if (yych == 'N') + goto yy442; + if (yych != 'n') + goto yy31; + yy442: + yych = *++p; + if (yych == 'E') + goto yy443; + if (yych != 'e') + goto yy31; + yy443: + yych = *++p; + if (yych == 'R') + goto yy41; + if (yych == 'r') + goto yy41; + goto yy31; + yy444: + yych = *++p; + if (yych == 'S') + goto yy41; + if (yych == 's') + goto yy41; + goto yy31; + yy445: + yych = *++p; + if (yych <= 'N') { + if (yych <= 'A') { + if (yych <= '@') + goto yy31; + goto yy467; + } else { + if (yych <= 'L') + goto yy31; + if (yych <= 'M') + goto yy468; + goto yy469; + } + } else { + if (yych <= 'l') { + if (yych == 'a') + goto yy467; + goto yy31; + } else { + if (yych <= 'm') + goto yy468; + if (yych <= 'n') + goto yy469; + goto yy31; + } + } + yy446: + yych = *++p; + if (yych == 'R') + goto yy454; + if (yych == 'r') + goto yy454; + goto yy31; + yy447: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') + goto yy451; + if (yych <= 'O') + goto yy31; + goto yy41; + } else { + if (yych <= 'l') { + if (yych <= 'k') + goto yy31; + goto yy451; + } else { + if (yych == 'p') + goto yy41; + goto yy31; + } + } + yy448: + yych = *++p; + if (yych == 'I') + goto yy450; + if (yych == 'i') + goto yy450; + goto yy31; + yy449: + yych = *++p; + if (yych == 'D') + goto yy41; + if (yych == 'd') + goto yy41; + goto yy31; + yy450: + yych = *++p; + if (yych == 'D') + goto yy41; + if (yych == 'd') + goto yy41; + goto yy31; + yy451: + yych = *++p; + if (yych == 'L') + goto yy452; + if (yych != 'l') + goto yy31; + yy452: + yych = *++p; + if (yych == 'T') + goto yy453; + if (yych != 't') + goto yy31; + yy453: + yych = *++p; + if (yych == 'O') + goto yy41; + if (yych == 'o') + goto yy41; + goto yy31; + yy454: + yych = *++p; + if (yych == 'O') + goto yy455; + if (yych != 'o') + goto yy31; + yy455: + yych = *++p; + if (yych == 'M') + goto yy456; + if (yych != 'm') + goto yy31; + yy456: + yych = *++p; + if (yych == 'E') + goto yy457; + if (yych != 'e') + goto yy31; + yy457: + yych = *++p; + if (yych == '-') + goto yy458; + if (yych == ':') + goto yy42; + goto yy31; + yy458: + yych = *++p; + if (yych == 'E') + goto yy459; + if (yych != 'e') + goto yy31; + yy459: + yych = *++p; + if (yych == 'X') + goto yy460; + if (yych != 'x') + goto yy31; + yy460: + yych = *++p; + if (yych == 'T') + goto yy461; + if (yych != 't') + goto yy31; + yy461: + yych = *++p; + if (yych == 'E') + goto yy462; + if (yych != 'e') + goto yy31; + yy462: + yych = *++p; + if (yych == 'N') + goto yy463; + if (yych != 'n') + goto yy31; + yy463: + yych = *++p; + if (yych == 'S') + goto yy464; + if (yych != 's') + goto yy31; + yy464: + yych = *++p; + if (yych == 'I') + goto yy465; + if (yych != 'i') + goto yy31; + yy465: + yych = *++p; + if (yych == 'O') + goto yy466; + if (yych != 'o') + goto yy31; + yy466: + yych = *++p; + if (yych == 'N') + goto yy41; + if (yych == 'n') + goto yy41; + goto yy31; + yy467: + yych = *++p; + if (yych == 'P') + goto yy41; + if (yych == 'p') + goto yy41; + goto yy31; + yy468: + yych = *++p; + if (yych == '-') + goto yy473; + goto yy31; + yy469: + yych = *++p; + if (yych == 'T') + goto yy470; + if (yych != 't') + 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 yy41; + if (yych == 't') + goto yy41; + goto yy31; + yy473: + yych = *++p; + if (yych == 'E') + goto yy474; + if (yych != 'e') + goto yy31; + yy474: + yych = *++p; + if (yych == 'V') + goto yy475; + if (yych != 'v') + goto yy31; + yy475: + yych = *++p; + if (yych == 'E') + goto yy476; + if (yych != 'e') + goto yy31; + yy476: + yych = *++p; + if (yych == 'N') + goto yy477; + if (yych != 'n') + goto yy31; + yy477: + yych = *++p; + if (yych == 'T') + goto yy478; + if (yych != 't') + goto yy31; + yy478: + yych = *++p; + if (yych == 'B') + goto yy479; + if (yych != 'b') + goto yy31; + yy479: + yych = *++p; + if (yych == 'R') + goto yy480; + if (yych != 'r') + goto yy31; + yy480: + yych = *++p; + if (yych == 'I') + goto yy481; + if (yych != 'i') + 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 != '-') + goto yy31; + yych = *++p; + if (yych == 'A') + goto yy485; + if (yych != 'a') + goto yy31; + yy485: + yych = *++p; + if (yych == 'T') + goto yy486; + if (yych != 't') + goto yy31; + yy486: + yych = *++p; + if (yych == 'T') + goto yy487; + if (yych != 't') + goto yy31; + yy487: + yych = *++p; + if (yych == 'E') + goto yy488; + if (yych != 'e') + goto yy31; + yy488: + yych = *++p; + if (yych == 'N') + goto yy489; + if (yych != 'n') + goto yy31; + yy489: + yych = *++p; + if (yych == 'D') + goto yy490; + if (yych != 'd') + goto yy31; + yy490: + yych = *++p; + if (yych == 'E') + goto yy491; + if (yych != 'e') + goto yy31; + yy491: + ++p; + if ((yych = *p) == 'E') + goto yy41; + if (yych == 'e') + goto yy41; + goto yy31; + } } // Try to match URI autolink after first <, returning number of chars matched. -bufsize_t _scan_autolink_uri(const unsigned char *p) -{ +bufsize_t _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, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 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 = *(marker = p); - if (yych <= 'c') { - if (yych <= 'M') { - if (yych <= 'E') { - if (yych <= 'A') { - if (yych == '\n') goto yy494; - if (yych <= '@') goto yy521; - goto yy498; - } else { - if (yych <= 'B') goto yy516; - if (yych <= 'C') goto yy495; - if (yych <= 'D') goto yy496; - goto yy517; - } - } else { - if (yych <= 'I') { - if (yych <= 'F') goto yy499; - if (yych <= 'G') goto yy500; - if (yych <= 'H') goto yy501; - goto yy502; - } else { - if (yych <= 'J') goto yy497; - if (yych <= 'K') goto yy518; - if (yych <= 'L') goto yy503; - goto yy504; - } - } - } else { - if (yych <= 'U') { - if (yych <= 'Q') { - if (yych <= 'N') goto yy505; - if (yych <= 'O') goto yy506; - if (yych <= 'P') goto yy507; - goto yy519; - } else { - if (yych <= 'R') goto yy508; - if (yych <= 'S') goto yy509; - if (yych <= 'T') goto yy510; - goto yy511; - } - } else { - if (yych <= 'Y') { - if (yych <= 'V') goto yy512; - if (yych <= 'W') goto yy513; - if (yych <= 'X') goto yy514; - goto yy520; - } else { - if (yych <= '`') { - if (yych <= 'Z') goto yy515; - goto yy521; - } else { - if (yych <= 'a') goto yy498; - if (yych <= 'b') goto yy516; - goto yy495; - } - } - } - } - } else { - if (yych <= 't') { - if (yych <= 'k') { - if (yych <= 'g') { - if (yych <= 'd') goto yy496; - if (yych <= 'e') goto yy517; - if (yych <= 'f') goto yy499; - goto yy500; - } else { - if (yych <= 'h') goto yy501; - if (yych <= 'i') goto yy502; - if (yych <= 'j') goto yy497; - goto yy518; - } - } else { - if (yych <= 'o') { - if (yych <= 'l') goto yy503; - if (yych <= 'm') goto yy504; - if (yych <= 'n') goto yy505; - goto yy506; - } else { - if (yych <= 'q') { - if (yych <= 'p') goto yy507; - goto yy519; - } else { - if (yych <= 'r') goto yy508; - if (yych <= 's') goto yy509; - goto yy510; - } - } - } - } else { - if (yych <= 0xC1) { - if (yych <= 'x') { - if (yych <= 'u') goto yy511; - if (yych <= 'v') goto yy512; - if (yych <= 'w') goto yy513; - goto yy514; - } else { - if (yych <= 'y') goto yy520; - if (yych <= 'z') goto yy515; - if (yych <= 0x7F) goto yy521; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy522; - if (yych <= 0xE0) goto yy524; - if (yych <= 0xEC) goto yy525; - goto yy529; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy525; - goto yy526; - } else { - if (yych <= 0xF3) goto yy527; - if (yych <= 0xF4) goto yy528; - } - } - } - } - } -yy494: - { return 0; } -yy495: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy948; - case 'H': - case 'h': goto yy947; - case 'I': - case 'i': goto yy950; - case 'O': - case 'o': goto yy946; - case 'R': - case 'r': goto yy949; - case 'V': - case 'v': goto yy945; - default: goto yy494; - } -yy496: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy921; - case 'I': - case 'i': goto yy920; - case 'L': - case 'l': goto yy918; - case 'N': - case 'n': goto yy919; - case 'O': - case 'o': goto yy922; - case 'T': - case 't': goto yy917; - case 'V': - case 'v': goto yy916; - default: goto yy494; - } -yy497: - yych = *(marker = ++p); - if (yych <= 'M') { - if (yych == 'A') goto yy908; - if (yych <= 'L') goto yy494; - goto yy907; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy494; - goto yy908; - } else { - if (yych == 'm') goto yy907; - goto yy494; - } - } -yy498: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy889; - case 'B': - case 'b': goto yy888; - case 'C': - case 'c': goto yy887; - case 'D': - case 'd': goto yy886; - case 'F': - case 'f': goto yy885; - case 'I': - case 'i': goto yy884; - case 'P': - case 'p': goto yy883; - case 'T': - case 't': goto yy882; - case 'W': - case 'w': goto yy533; - default: goto yy494; - } -yy499: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'E') { - if (yych == 'A') goto yy869; - if (yych <= 'D') goto yy494; - goto yy868; - } else { - if (yych == 'I') goto yy867; - if (yych <= 'S') goto yy494; - goto yy870; - } - } else { - if (yych <= 'e') { - if (yych == 'a') goto yy869; - if (yych <= 'd') goto yy494; - goto yy868; - } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy494; - goto yy867; - } else { - if (yych == 't') goto yy870; - goto yy494; - } - } - } -yy500: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': goto yy852; - case 'G': - case 'g': goto yy533; - case 'I': - case 'i': goto yy850; - case 'O': - case 'o': goto yy851; - case 'T': - case 't': goto yy849; - default: goto yy494; - } -yy501: - yych = *(marker = ++p); - if (yych <= 'S') { - if (yych <= '3') { - if (yych <= '2') goto yy494; - goto yy845; - } else { - if (yych == 'C') goto yy843; - goto yy494; - } - } else { - if (yych <= 'c') { - if (yych <= 'T') goto yy844; - if (yych <= 'b') goto yy494; - goto yy843; - } else { - if (yych == 't') goto yy844; - goto yy494; - } - } -yy502: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy825; - case 'C': - case 'c': goto yy822; - case 'M': - case 'm': goto yy824; - case 'N': - case 'n': goto yy823; - case 'P': - case 'p': goto yy821; - case 'R': - case 'r': goto yy820; - case 'T': - case 't': goto yy819; - default: goto yy494; - } -yy503: - yych = *(marker = ++p); - if (yych <= 'D') { - if (yych == 'A') goto yy813; - if (yych <= 'C') goto yy494; - goto yy812; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy494; - goto yy813; - } else { - if (yych == 'd') goto yy812; - goto yy494; - } - } -yy504: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy779; - case 'E': - case 'e': goto yy778; - case 'I': - case 'i': goto yy781; - case 'M': - case 'm': goto yy777; - case 'S': - case 's': goto yy776; - case 'T': - case 't': goto yy780; - case 'U': - case 'u': goto yy775; - case 'V': - case 'v': goto yy774; - default: goto yy494; - } -yy505: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': goto yy769; - case 'F': - case 'f': goto yy768; - case 'I': - case 'i': goto yy767; - case 'N': - case 'n': goto yy766; - case 'O': - case 'o': goto yy765; - default: goto yy494; - } -yy506: - yych = *(marker = ++p); - if (yych <= 'P') { - if (yych == 'I') goto yy751; - if (yych <= 'O') goto yy494; - goto yy752; - } else { - if (yych <= 'i') { - if (yych <= 'h') goto yy494; - goto yy751; - } else { - if (yych == 'p') goto yy752; - goto yy494; - } - } -yy507: - yych = *(marker = ++p); - if (yych <= 'S') { - if (yych <= 'L') { - if (yych == 'A') goto yy733; - if (yych <= 'K') goto yy494; - goto yy732; - } else { - if (yych <= 'O') { - if (yych <= 'N') goto yy494; - goto yy734; - } else { - if (yych <= 'Q') goto yy494; - if (yych <= 'R') goto yy731; - goto yy730; - } - } - } else { - if (yych <= 'n') { - if (yych <= 'a') { - if (yych <= '`') goto yy494; - goto yy733; - } else { - if (yych == 'l') goto yy732; - goto yy494; - } - } else { - if (yych <= 'q') { - if (yych <= 'o') goto yy734; - goto yy494; - } else { - if (yych <= 'r') goto yy731; - if (yych <= 's') goto yy730; - goto yy494; - } - } - } -yy508: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'L') { - if (yych == 'E') goto yy720; - goto yy494; - } else { - if (yych <= 'M') goto yy719; - if (yych <= 'R') goto yy494; - if (yych <= 'S') goto yy718; - goto yy717; - } - } else { - if (yych <= 'm') { - if (yych == 'e') goto yy720; - if (yych <= 'l') goto yy494; - goto yy719; - } else { - if (yych <= 'r') goto yy494; - if (yych <= 's') goto yy718; - if (yych <= 't') goto yy717; - goto yy494; - } - } -yy509: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': goto yy673; - case 'F': - case 'f': goto yy672; - case 'G': - case 'g': goto yy671; - case 'H': - case 'h': goto yy676; - case 'I': - case 'i': goto yy675; - case 'K': - case 'k': goto yy670; - case 'M': - case 'm': goto yy669; - case 'N': - case 'n': goto yy674; - case 'O': - case 'o': goto yy668; - case 'P': - case 'p': goto yy667; - case 'S': - case 's': goto yy666; - case 'T': - case 't': goto yy665; - case 'V': - case 'v': goto yy664; - default: goto yy494; - } -yy510: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': goto yy640; - case 'E': - case 'e': goto yy636; - case 'F': - case 'f': goto yy639; - case 'H': - case 'h': goto yy635; - case 'I': - case 'i': goto yy637; - case 'N': - case 'n': goto yy638; - case 'V': - case 'v': goto yy533; - default: goto yy494; - } -yy511: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'N') { - if (yych == 'D') goto yy627; - if (yych <= 'M') goto yy494; - goto yy626; - } else { - if (yych == 'R') goto yy628; - if (yych <= 'S') goto yy494; - goto yy625; - } - } else { - if (yych <= 'n') { - if (yych == 'd') goto yy627; - if (yych <= 'm') goto yy494; - goto yy626; - } else { - if (yych <= 'r') { - if (yych <= 'q') goto yy494; - goto yy628; - } else { - if (yych == 't') goto yy625; - goto yy494; - } - } - } -yy512: - yych = *(marker = ++p); - if (yych <= 'I') { - if (yych == 'E') goto yy609; - if (yych <= 'H') goto yy494; - goto yy608; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy494; - goto yy609; - } else { - if (yych == 'i') goto yy608; - goto yy494; - } - } -yy513: - yych = *(marker = ++p); - if (yych <= 'Y') { - if (yych <= 'R') { - if (yych == 'E') goto yy598; - goto yy494; - } else { - if (yych <= 'S') goto yy599; - if (yych <= 'T') goto yy597; - if (yych <= 'X') goto yy494; - goto yy596; - } - } else { - if (yych <= 's') { - if (yych == 'e') goto yy598; - if (yych <= 'r') goto yy494; - goto yy599; - } else { - if (yych <= 't') goto yy597; - if (yych == 'y') goto yy596; - goto yy494; - } - } -yy514: - yych = *(marker = ++p); - if (yych <= 'R') { - if (yych <= 'F') { - if (yych == 'C') goto yy575; - if (yych <= 'E') goto yy494; - goto yy573; - } else { - if (yych == 'M') goto yy574; - if (yych <= 'Q') goto yy494; - goto yy572; - } - } else { - if (yych <= 'f') { - if (yych == 'c') goto yy575; - if (yych <= 'e') goto yy494; - goto yy573; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy494; - goto yy574; - } else { - if (yych == 'r') goto yy572; - goto yy494; - } - } - } -yy515: - yych = *(marker = ++p); - if (yych == '3') goto yy567; - goto yy494; -yy516: - yych = *(marker = ++p); - if (yych <= 'O') { - if (yych <= 'H') { - if (yych == 'E') goto yy557; - goto yy494; - } else { - if (yych <= 'I') goto yy556; - if (yych <= 'N') goto yy494; - goto yy555; - } - } else { - if (yych <= 'h') { - if (yych == 'e') goto yy557; - goto yy494; - } else { - if (yych <= 'i') goto yy556; - if (yych == 'o') goto yy555; - goto yy494; - } - } -yy517: - yych = *(marker = ++p); - if (yych == 'D') goto yy553; - if (yych == 'd') goto yy553; - goto yy494; -yy518: - yych = *(marker = ++p); - if (yych == 'E') goto yy548; - if (yych == 'e') goto yy548; - goto yy494; -yy519: - yych = *(marker = ++p); - if (yych == 'U') goto yy545; - if (yych == 'u') goto yy545; - goto yy494; -yy520: - yych = *(marker = ++p); - if (yych == 'M') goto yy530; - if (yych == 'm') goto yy530; - goto yy494; -yy521: - yych = *++p; - goto yy494; -yy522: - yych = *++p; - if (yych <= 0x7F) goto yy523; - if (yych <= 0xBF) goto yy521; -yy523: - p = marker; - goto yy494; -yy524: - yych = *++p; - if (yych <= 0x9F) goto yy523; - if (yych <= 0xBF) goto yy522; - goto yy523; -yy525: - yych = *++p; - if (yych <= 0x7F) goto yy523; - if (yych <= 0xBF) goto yy522; - goto yy523; -yy526: - yych = *++p; - if (yych <= 0x8F) goto yy523; - if (yych <= 0xBF) goto yy525; - goto yy523; -yy527: - yych = *++p; - if (yych <= 0x7F) goto yy523; - if (yych <= 0xBF) goto yy525; - goto yy523; -yy528: - yych = *++p; - if (yych <= 0x7F) goto yy523; - if (yych <= 0x8F) goto yy525; - goto yy523; -yy529: - yych = *++p; - if (yych <= 0x7F) goto yy523; - if (yych <= 0x9F) goto yy522; - goto yy523; -yy530: - yych = *++p; - if (yych == 'S') goto yy531; - if (yych != 's') goto yy523; -yy531: - yych = *++p; - if (yych == 'G') goto yy532; - if (yych != 'g') goto yy523; -yy532: - yych = *++p; - if (yych == 'R') goto yy533; - if (yych != 'r') goto yy523; -yy533: - yych = *++p; - if (yych != ':') goto yy523; -yy534: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy534; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '<') goto yy523; - if (yych <= '>') goto yy543; - goto yy523; - } else { - if (yych <= 0xDF) goto yy536; - if (yych <= 0xE0) goto yy537; - goto yy538; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy542; - if (yych <= 0xEF) goto yy538; - goto yy539; - } else { - if (yych <= 0xF3) goto yy540; - if (yych <= 0xF4) goto yy541; - goto yy523; - } - } -yy536: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy523; - if (yych <= 0xBF) goto yy534; - goto yy523; -yy537: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy523; - if (yych <= 0xBF) goto yy536; - goto yy523; -yy538: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy523; - if (yych <= 0xBF) goto yy536; - goto yy523; -yy539: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy523; - if (yych <= 0xBF) goto yy538; - goto yy523; -yy540: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy523; - if (yych <= 0xBF) goto yy538; - goto yy523; -yy541: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy523; - if (yych <= 0x8F) goto yy538; - goto yy523; -yy542: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy523; - if (yych <= 0x9F) goto yy536; - goto yy523; -yy543: - ++p; - { return (bufsize_t)(p - start); } -yy545: - yych = *++p; - if (yych == 'E') goto yy546; - if (yych != 'e') goto yy523; -yy546: - yych = *++p; - if (yych == 'R') goto yy547; - if (yych != 'r') goto yy523; -yy547: - yych = *++p; - if (yych == 'Y') goto yy533; - if (yych == 'y') goto yy533; - goto yy523; -yy548: - yych = *++p; - if (yych == 'Y') goto yy549; - if (yych != 'y') goto yy523; -yy549: - yych = *++p; - if (yych == 'P') goto yy550; - if (yych != 'p') goto yy523; -yy550: - yych = *++p; - if (yych == 'A') goto yy551; - if (yych != 'a') goto yy523; -yy551: - yych = *++p; - if (yych == 'R') goto yy552; - if (yych != 'r') goto yy523; -yy552: - yych = *++p; - if (yych == 'C') goto yy533; - if (yych == 'c') goto yy533; - goto yy523; -yy553: - yych = *++p; - if (yych != '2') goto yy523; - yych = *++p; - if (yych == 'K') goto yy533; - if (yych == 'k') goto yy533; - goto yy523; -yy555: - yych = *++p; - if (yych == 'L') goto yy566; - if (yych == 'l') goto yy566; - goto yy523; -yy556: - yych = *++p; - if (yych == 'T') goto yy562; - if (yych == 't') goto yy562; - goto yy523; -yy557: - yych = *++p; - if (yych == 'S') goto yy558; - if (yych != 's') goto yy523; -yy558: - yych = *++p; - if (yych == 'H') goto yy559; - if (yych != 'h') goto yy523; -yy559: - yych = *++p; - if (yych == 'A') goto yy560; - if (yych != 'a') goto yy523; -yy560: - yych = *++p; - if (yych == 'R') goto yy561; - if (yych != 'r') goto yy523; -yy561: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy562: - yych = *++p; - if (yych == 'C') goto yy563; - if (yych != 'c') goto yy523; -yy563: - yych = *++p; - if (yych == 'O') goto yy564; - if (yych != 'o') goto yy523; -yy564: - yych = *++p; - if (yych == 'I') goto yy565; - if (yych != 'i') goto yy523; -yy565: - yych = *++p; - if (yych == 'N') goto yy533; - if (yych == 'n') goto yy533; - goto yy523; -yy566: - yych = *++p; - if (yych == 'O') goto yy533; - if (yych == 'o') goto yy533; - goto yy523; -yy567: - yych = *++p; - if (yych != '9') goto yy523; - yych = *++p; - if (yych != '.') goto yy523; - yych = *++p; - if (yych != '5') goto yy523; - yych = *++p; - if (yych != '0') goto yy523; - yych = *++p; - if (yych <= 'Q') goto yy523; - if (yych <= 'S') goto yy533; - if (yych <= 'q') goto yy523; - if (yych <= 's') goto yy533; - goto yy523; -yy572: - yych = *++p; - if (yych == 'I') goto yy533; - if (yych == 'i') goto yy533; - goto yy523; -yy573: - yych = *++p; - if (yych == 'I') goto yy594; - if (yych == 'i') goto yy594; - goto yy523; -yy574: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy584; - if (yych <= 'O') goto yy523; - goto yy585; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy523; - goto yy584; - } else { - if (yych == 'p') goto yy585; - goto yy523; - } - } -yy575: - yych = *++p; - if (yych == 'O') goto yy576; - if (yych != 'o') goto yy523; -yy576: - yych = *++p; - if (yych == 'N') goto yy577; - if (yych != 'n') goto yy523; -yy577: - yych = *++p; - if (yych == '-') goto yy578; - if (yych == ':') goto yy534; - goto yy523; -yy578: - yych = *++p; - if (yych == 'U') goto yy579; - if (yych != 'u') goto yy523; -yy579: - yych = *++p; - if (yych == 'S') goto yy580; - if (yych != 's') goto yy523; -yy580: - yych = *++p; - if (yych == 'E') goto yy581; - if (yych != 'e') goto yy523; -yy581: - yych = *++p; - if (yych == 'R') goto yy582; - if (yych != 'r') goto yy523; -yy582: - yych = *++p; - if (yych == 'I') goto yy583; - if (yych != 'i') goto yy523; -yy583: - yych = *++p; - if (yych == 'D') goto yy533; - if (yych == 'd') goto yy533; - goto yy523; -yy584: - yych = *++p; - if (yych == 'R') goto yy586; - if (yych == 'r') goto yy586; - goto yy523; -yy585: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy586: - yych = *++p; - if (yych == 'P') goto yy587; - if (yych != 'p') goto yy523; -yy587: - yych = *++p; - if (yych == 'C') goto yy588; - if (yych != 'c') goto yy523; -yy588: - yych = *++p; - if (yych != '.') goto yy523; - yych = *++p; - if (yych == 'B') goto yy590; - if (yych != 'b') goto yy523; -yy590: - yych = *++p; - if (yych == 'E') goto yy591; - if (yych != 'e') goto yy523; -yy591: - yych = *++p; - if (yych == 'E') goto yy592; - if (yych != 'e') goto yy523; -yy592: - yych = *++p; - if (yych == 'P') goto yy593; - if (yych != 'p') goto yy523; -yy593: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; - } -yy594: - yych = *++p; - if (yych == 'R') goto yy595; - if (yych != 'r') goto yy523; -yy595: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy596: - yych = *++p; - if (yych == 'C') goto yy604; - if (yych == 'c') goto yy604; - goto yy523; -yy597: - yych = *++p; - if (yych == 'A') goto yy603; - if (yych == 'a') goto yy603; - goto yy523; -yy598: - yych = *++p; - if (yych == 'B') goto yy600; - if (yych == 'b') goto yy600; - goto yy523; -yy599: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; - } -yy600: - yych = *++p; - if (yych == 'C') goto yy601; - if (yych != 'c') goto yy523; -yy601: - yych = *++p; - if (yych == 'A') goto yy602; - if (yych != 'a') goto yy523; -yy602: - yych = *++p; - if (yych == 'L') goto yy533; - if (yych == 'l') goto yy533; - goto yy523; -yy603: - yych = *++p; - if (yych == 'I') goto yy533; - if (yych == 'i') goto yy533; - goto yy523; -yy604: - yych = *++p; - if (yych == 'I') goto yy605; - if (yych != 'i') goto yy523; -yy605: - yych = *++p; - if (yych == 'W') goto yy606; - if (yych != 'w') goto yy523; -yy606: - yych = *++p; - if (yych == 'Y') goto yy607; - if (yych != 'y') goto yy523; -yy607: - yych = *++p; - if (yych == 'G') goto yy533; - if (yych == 'g') goto yy533; - goto yy523; -yy608: - yych = *++p; - if (yych == 'E') goto yy617; - if (yych == 'e') goto yy617; - goto yy523; -yy609: - yych = *++p; - if (yych <= 'N') { - if (yych <= 'L') goto yy523; - if (yych >= 'N') goto yy611; - } else { - if (yych <= 'l') goto yy523; - if (yych <= 'm') goto yy610; - if (yych <= 'n') goto yy611; - goto yy523; - } -yy610: - yych = *++p; - if (yych == 'M') goto yy616; - if (yych == 'm') goto yy616; - goto yy523; -yy611: - yych = *++p; - if (yych == 'T') goto yy612; - if (yych != 't') goto yy523; -yy612: - yych = *++p; - if (yych == 'R') goto yy613; - if (yych != 'r') goto yy523; -yy613: - yych = *++p; - if (yych == 'I') goto yy614; - if (yych != 'i') goto yy523; -yy614: - yych = *++p; - if (yych == 'L') goto yy615; - if (yych != 'l') goto yy523; -yy615: - yych = *++p; - if (yych == 'O') goto yy533; - if (yych == 'o') goto yy533; - goto yy523; -yy616: - yych = *++p; - if (yych == 'I') goto yy533; - if (yych == 'i') goto yy533; - goto yy523; -yy617: - yych = *++p; - if (yych == 'W') goto yy618; - if (yych != 'w') goto yy523; -yy618: - yych = *++p; - if (yych != '-') goto yy523; - yych = *++p; - if (yych == 'S') goto yy620; - if (yych != 's') goto yy523; -yy620: - yych = *++p; - if (yych == 'O') goto yy621; - if (yych != 'o') goto yy523; -yy621: - yych = *++p; - if (yych == 'U') goto yy622; - if (yych != 'u') goto yy523; -yy622: - yych = *++p; - if (yych == 'R') goto yy623; - if (yych != 'r') goto yy523; -yy623: - yych = *++p; - if (yych == 'C') goto yy624; - if (yych != 'c') goto yy523; -yy624: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy625: - yych = *++p; - if (yych == '2') goto yy632; - goto yy523; -yy626: - yych = *++p; - if (yych == 'R') goto yy629; - if (yych == 'r') goto yy629; - goto yy523; -yy627: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy628: - yych = *++p; - if (yych == 'N') goto yy533; - if (yych == 'n') goto yy533; - goto yy523; -yy629: - yych = *++p; - if (yych == 'E') goto yy630; - if (yych != 'e') goto yy523; -yy630: - yych = *++p; - if (yych == 'A') goto yy631; - if (yych != 'a') goto yy523; -yy631: - yych = *++p; - if (yych == 'L') goto yy533; - if (yych == 'l') goto yy533; - goto yy523; -yy632: - yych = *++p; - if (yych != '0') goto yy523; - yych = *++p; - if (yych != '0') goto yy523; - yych = *++p; - if (yych == '4') goto yy533; - goto yy523; -yy635: - yych = *++p; - if (yych == 'I') goto yy654; - if (yych == 'i') goto yy654; - goto yy523; -yy636: - yych = *++p; - if (yych <= 'L') { - if (yych == 'A') goto yy646; - if (yych <= 'K') goto yy523; - goto yy645; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy523; - goto yy646; - } else { - if (yych == 'l') goto yy645; - goto yy523; - } - } -yy637: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy638: - yych = *++p; - if (yych == '3') goto yy642; - goto yy523; -yy639: - yych = *++p; - if (yych == 'T') goto yy641; - if (yych == 't') goto yy641; - goto yy523; -yy640: - yych = *++p; - if (yych == 'G') goto yy533; - if (yych == 'g') goto yy533; - goto yy523; -yy641: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy642: - yych = *++p; - if (yych != '2') goto yy523; - yych = *++p; - if (yych != '7') goto yy523; - yych = *++p; - if (yych == '0') goto yy533; - goto yy523; -yy645: - yych = *++p; - if (yych <= 'M') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'N') goto yy652; - if (yych == 'n') goto yy652; - goto yy523; - } -yy646: - yych = *++p; - if (yych == 'M') goto yy647; - if (yych != 'm') goto yy523; -yy647: - yych = *++p; - if (yych == 'S') goto yy648; - if (yych != 's') goto yy523; -yy648: - yych = *++p; - if (yych == 'P') goto yy649; - if (yych != 'p') goto yy523; -yy649: - yych = *++p; - if (yych == 'E') goto yy650; - if (yych != 'e') goto yy523; -yy650: - yych = *++p; - if (yych == 'A') goto yy651; - if (yych != 'a') goto yy523; -yy651: - yych = *++p; - if (yych == 'K') goto yy533; - if (yych == 'k') goto yy533; - goto yy523; -yy652: - yych = *++p; - if (yych == 'E') goto yy653; - if (yych != 'e') goto yy523; -yy653: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy654: - yych = *++p; - if (yych <= 'S') { - if (yych == 'N') goto yy655; - if (yych <= 'R') goto yy523; - goto yy656; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy523; - } else { - if (yych == 's') goto yy656; - goto yy523; - } - } -yy655: - yych = *++p; - if (yych == 'G') goto yy663; - if (yych == 'g') goto yy663; - goto yy523; -yy656: - yych = *++p; - if (yych == 'M') goto yy657; - if (yych != 'm') goto yy523; -yy657: - yych = *++p; - if (yych == 'E') goto yy658; - if (yych != 'e') goto yy523; -yy658: - yych = *++p; - if (yych == 'S') goto yy659; - if (yych != 's') goto yy523; -yy659: - yych = *++p; - if (yych == 'S') goto yy660; - if (yych != 's') goto yy523; -yy660: - yych = *++p; - if (yych == 'A') goto yy661; - if (yych != 'a') goto yy523; -yy661: - yych = *++p; - if (yych == 'G') goto yy662; - if (yych != 'g') goto yy523; -yy662: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy663: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy664: - yych = *++p; - if (yych == 'N') goto yy533; - if (yych == 'n') goto yy533; - goto yy523; -yy665: - yych = *++p; - if (yych == 'E') goto yy715; - if (yych == 'e') goto yy715; - goto yy523; -yy666: - yych = *++p; - if (yych == 'H') goto yy533; - if (yych == 'h') goto yy533; - goto yy523; -yy667: - yych = *++p; - if (yych == 'O') goto yy711; - if (yych == 'o') goto yy711; - goto yy523; -yy668: - yych = *++p; - if (yych <= 'L') { - if (yych == 'A') goto yy701; - if (yych <= 'K') goto yy523; - goto yy702; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy523; - goto yy701; - } else { - if (yych == 'l') goto yy702; - goto yy523; - } - } -yy669: - yych = *++p; - if (yych <= 'S') { - if (yych == 'B') goto yy533; - if (yych <= 'R') goto yy523; - goto yy533; - } else { - if (yych <= 'b') { - if (yych <= 'a') goto yy523; - goto yy533; - } else { - if (yych == 's') goto yy533; - goto yy523; - } - } -yy670: - yych = *++p; - if (yych == 'Y') goto yy699; - if (yych == 'y') goto yy699; - goto yy523; -yy671: - yych = *++p; - if (yych == 'N') goto yy533; - if (yych == 'n') goto yy533; - goto yy523; -yy672: - yych = *++p; - if (yych == 'T') goto yy698; - if (yych == 't') goto yy698; - goto yy523; -yy673: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'C') { - if (yych <= 'B') goto yy523; - goto yy685; - } else { - if (yych <= 'Q') goto yy523; - if (yych <= 'R') goto yy683; - goto yy684; - } - } else { - if (yych <= 'q') { - if (yych == 'c') goto yy685; - goto yy523; - } else { - if (yych <= 'r') goto yy683; - if (yych <= 's') goto yy684; - goto yy523; - } - } -yy674: - yych = *++p; - if (yych == 'M') goto yy682; - if (yych == 'm') goto yy682; - goto yy523; -yy675: - yych = *++p; - if (yych <= 'P') { - if (yych == 'E') goto yy679; - if (yych <= 'O') goto yy523; - goto yy680; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy523; - goto yy679; - } else { - if (yych == 'p') goto yy680; - goto yy523; - } - } -yy676: - yych = *++p; - if (yych == 'T') goto yy677; - if (yych != 't') goto yy523; -yy677: - yych = *++p; - if (yych == 'T') goto yy678; - if (yych != 't') goto yy523; -yy678: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy679: - yych = *++p; - if (yych == 'V') goto yy681; - if (yych == 'v') goto yy681; - goto yy523; -yy680: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; - } -yy681: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy682: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy683: - yych = *++p; - if (yych == 'V') goto yy695; - if (yych == 'v') goto yy695; - goto yy523; -yy684: - yych = *++p; - if (yych == 'S') goto yy692; - if (yych == 's') goto yy692; - goto yy523; -yy685: - yych = *++p; - if (yych == 'O') goto yy686; - if (yych != 'o') goto yy523; -yy686: - yych = *++p; - if (yych == 'N') goto yy687; - if (yych != 'n') goto yy523; -yy687: - yych = *++p; - if (yych == 'D') goto yy688; - if (yych != 'd') goto yy523; -yy688: - yych = *++p; - if (yych == 'L') goto yy689; - if (yych != 'l') goto yy523; -yy689: - yych = *++p; - if (yych == 'I') goto yy690; - if (yych != 'i') goto yy523; -yy690: - yych = *++p; - if (yych == 'F') goto yy691; - if (yych != 'f') goto yy523; -yy691: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy692: - yych = *++p; - if (yych == 'I') goto yy693; - if (yych != 'i') goto yy523; -yy693: - yych = *++p; - if (yych == 'O') goto yy694; - if (yych != 'o') goto yy523; -yy694: - yych = *++p; - if (yych == 'N') goto yy533; - if (yych == 'n') goto yy533; - goto yy523; -yy695: - yych = *++p; - if (yych == 'I') goto yy696; - if (yych != 'i') goto yy523; -yy696: - yych = *++p; - if (yych == 'C') goto yy697; - if (yych != 'c') goto yy523; -yy697: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy698: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy699: - yych = *++p; - if (yych == 'P') goto yy700; - if (yych != 'p') goto yy523; -yy700: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy701: - yych = *++p; - if (yych == 'P') goto yy705; - if (yych == 'p') goto yy705; - goto yy523; -yy702: - yych = *++p; - if (yych == 'D') goto yy703; - if (yych != 'd') goto yy523; -yy703: - yych = *++p; - if (yych == 'A') goto yy704; - if (yych != 'a') goto yy523; -yy704: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy705: - yych = *++p; - if (yych != '.') goto yy523; - yych = *++p; - if (yych == 'B') goto yy707; - if (yych != 'b') goto yy523; -yy707: - yych = *++p; - if (yych == 'E') goto yy708; - if (yych != 'e') goto yy523; -yy708: - yych = *++p; - if (yych == 'E') goto yy709; - if (yych != 'e') goto yy523; -yy709: - yych = *++p; - if (yych == 'P') goto yy710; - if (yych != 'p') goto yy523; -yy710: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; - } -yy711: - yych = *++p; - if (yych == 'T') goto yy712; - if (yych != 't') goto yy523; -yy712: - yych = *++p; - if (yych == 'I') goto yy713; - if (yych != 'i') goto yy523; -yy713: - yych = *++p; - if (yych == 'F') goto yy714; - if (yych != 'f') goto yy523; -yy714: - yych = *++p; - if (yych == 'Y') goto yy533; - if (yych == 'y') goto yy533; - goto yy523; -yy715: - yych = *++p; - if (yych == 'A') goto yy716; - if (yych != 'a') goto yy523; -yy716: - yych = *++p; - if (yych == 'M') goto yy533; - if (yych == 'm') goto yy533; - goto yy523; -yy717: - yych = *++p; - if (yych <= 'S') { - if (yych == 'M') goto yy729; - if (yych <= 'R') goto yy523; - goto yy728; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy523; - goto yy729; - } else { - if (yych == 's') goto yy728; - goto yy523; - } - } -yy718: - yych = *++p; - if (yych == 'Y') goto yy726; - if (yych == 'y') goto yy726; - goto yy523; -yy719: - yych = *++p; - if (yych == 'I') goto yy533; - if (yych == 'i') goto yy533; - goto yy523; -yy720: - yych = *++p; - if (yych == 'S') goto yy721; - if (yych != 's') goto yy523; -yy721: - yych = *++p; - if (yych <= 'N') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'O') goto yy722; - if (yych != 'o') goto yy523; - } -yy722: - yych = *++p; - if (yych == 'U') goto yy723; - if (yych != 'u') goto yy523; -yy723: - yych = *++p; - if (yych == 'R') goto yy724; - if (yych != 'r') goto yy523; -yy724: - yych = *++p; - if (yych == 'C') goto yy725; - if (yych != 'c') goto yy523; -yy725: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy726: - yych = *++p; - if (yych == 'N') goto yy727; - if (yych != 'n') goto yy523; -yy727: - yych = *++p; - if (yych == 'C') goto yy533; - if (yych == 'c') goto yy533; - goto yy523; -yy728: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy729: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy730: - yych = *++p; - if (yych == 'Y') goto yy750; - if (yych == 'y') goto yy750; - goto yy523; -yy731: - yych = *++p; - if (yych <= 'O') { - if (yych == 'E') goto yy747; - if (yych <= 'N') goto yy523; - goto yy748; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy523; - goto yy747; - } else { - if (yych == 'o') goto yy748; - goto yy523; - } - } -yy732: - yych = *++p; - if (yych == 'A') goto yy742; - if (yych == 'a') goto yy742; - goto yy523; -yy733: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy735; - if (yych <= 'O') goto yy523; - goto yy736; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy523; - goto yy735; - } else { - if (yych == 'p') goto yy736; - goto yy523; - } - } -yy734: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy735: - yych = *++p; - if (yych == 'M') goto yy533; - if (yych == 'm') goto yy533; - goto yy523; -yy736: - yych = *++p; - if (yych == 'A') goto yy737; - if (yych != 'a') goto yy523; -yy737: - yych = *++p; - if (yych == 'R') goto yy738; - if (yych != 'r') goto yy523; -yy738: - yych = *++p; - if (yych == 'A') goto yy739; - if (yych != 'a') goto yy523; -yy739: - yych = *++p; - if (yych == 'Z') goto yy740; - if (yych != 'z') goto yy523; -yy740: - yych = *++p; - if (yych == 'Z') goto yy741; - if (yych != 'z') goto yy523; -yy741: - yych = *++p; - if (yych == 'I') goto yy533; - if (yych == 'i') goto yy533; - goto yy523; -yy742: - yych = *++p; - if (yych == 'T') goto yy743; - if (yych != 't') goto yy523; -yy743: - yych = *++p; - if (yych == 'F') goto yy744; - if (yych != 'f') goto yy523; -yy744: - yych = *++p; - if (yych == 'O') goto yy745; - if (yych != 'o') goto yy523; -yy745: - yych = *++p; - if (yych == 'R') goto yy746; - if (yych != 'r') goto yy523; -yy746: - yych = *++p; - if (yych == 'M') goto yy533; - if (yych == 'm') goto yy533; - goto yy523; -yy747: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy748: - yych = *++p; - if (yych == 'X') goto yy749; - if (yych != 'x') goto yy523; -yy749: - yych = *++p; - if (yych == 'Y') goto yy533; - if (yych == 'y') goto yy533; - goto yy523; -yy750: - yych = *++p; - if (yych == 'C') goto yy533; - if (yych == 'c') goto yy533; - goto yy523; -yy751: - yych = *++p; - if (yych == 'D') goto yy533; - if (yych == 'd') goto yy533; - goto yy523; -yy752: - yych = *++p; - if (yych == 'A') goto yy753; - if (yych != 'a') goto yy523; -yy753: - yych = *++p; - if (yych == 'Q') goto yy754; - if (yych != 'q') goto yy523; -yy754: - yych = *++p; - if (yych == 'U') goto yy755; - if (yych != 'u') goto yy523; -yy755: - yych = *++p; - if (yych == 'E') goto yy756; - if (yych != 'e') goto yy523; -yy756: - yych = *++p; - if (yych == 'L') goto yy757; - if (yych != 'l') goto yy523; -yy757: - yych = *++p; - if (yych == 'O') goto yy758; - if (yych != 'o') goto yy523; -yy758: - yych = *++p; - if (yych == 'C') goto yy759; - if (yych != 'c') goto yy523; -yy759: - yych = *++p; - if (yych == 'K') goto yy760; - if (yych != 'k') goto yy523; -yy760: - yych = *++p; - if (yych == 'T') goto yy761; - if (yych != 't') goto yy523; -yy761: - yych = *++p; - if (yych == 'O') goto yy762; - if (yych != 'o') goto yy523; -yy762: - yych = *++p; - if (yych == 'K') goto yy763; - if (yych != 'k') goto yy523; -yy763: - yych = *++p; - if (yych == 'E') goto yy764; - if (yych != 'e') goto yy523; -yy764: - yych = *++p; - if (yych == 'N') goto yy533; - if (yych == 'n') goto yy533; - goto yy523; -yy765: - yych = *++p; - if (yych == 'T') goto yy772; - if (yych == 't') goto yy772; - goto yy523; -yy766: - yych = *++p; - if (yych == 'T') goto yy771; - if (yych == 't') goto yy771; - goto yy523; -yy767: - yych = *++p; - if (yych <= 'G') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'H') goto yy533; - if (yych == 'h') goto yy533; - goto yy523; - } -yy768: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy769: - yych = *++p; - if (yych == 'W') goto yy770; - if (yych != 'w') goto yy523; -yy770: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy771: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy772: - yych = *++p; - if (yych == 'E') goto yy773; - if (yych != 'e') goto yy523; -yy773: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy774: - yych = *++p; - if (yych == 'N') goto yy533; - if (yych == 'n') goto yy533; - goto yy523; -yy775: - yych = *++p; - if (yych <= 'P') { - if (yych == 'M') goto yy806; - if (yych <= 'O') goto yy523; - goto yy805; - } else { - if (yych <= 'm') { - if (yych <= 'l') goto yy523; - goto yy806; - } else { - if (yych == 'p') goto yy805; - goto yy523; - } - } -yy776: - yych = *++p; - if (yych <= 'Q') { - if (yych <= '-') { - if (yych <= ',') goto yy523; - goto yy798; - } else { - if (yych == 'N') goto yy799; - goto yy523; - } - } else { - if (yych <= 'n') { - if (yych <= 'R') goto yy797; - if (yych <= 'm') goto yy523; - goto yy799; - } else { - if (yych == 'r') goto yy797; - goto yy523; - } - } -yy777: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy778: - yych = *++p; - if (yych == 'S') goto yy793; - if (yych == 's') goto yy793; - goto yy523; -yy779: - yych = *++p; - switch (yych) { - case 'G': - case 'g': goto yy784; - case 'I': - case 'i': goto yy783; - case 'P': - case 'p': goto yy785; - case 'R': - case 'r': goto yy786; - default: goto yy523; - } -yy780: - yych = *++p; - if (yych == 'Q') goto yy782; - if (yych == 'q') goto yy782; - goto yy523; -yy781: - yych = *++p; - if (yych == 'D') goto yy533; - if (yych == 'd') goto yy533; - goto yy523; -yy782: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy783: - yych = *++p; - if (yych == 'L') goto yy791; - if (yych == 'l') goto yy791; - goto yy523; -yy784: - yych = *++p; - if (yych == 'N') goto yy789; - if (yych == 'n') goto yy789; - goto yy523; -yy785: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy786: - yych = *++p; - if (yych == 'K') goto yy787; - if (yych != 'k') goto yy523; -yy787: - yych = *++p; - if (yych == 'E') goto yy788; - if (yych != 'e') goto yy523; -yy788: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy789: - yych = *++p; - if (yych == 'E') goto yy790; - if (yych != 'e') goto yy523; -yy790: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy791: - yych = *++p; - if (yych == 'T') goto yy792; - if (yych != 't') goto yy523; -yy792: - yych = *++p; - if (yych == 'O') goto yy533; - if (yych == 'o') goto yy533; - goto yy523; -yy793: - yych = *++p; - if (yych == 'S') goto yy794; - if (yych != 's') goto yy523; -yy794: - yych = *++p; - if (yych == 'A') goto yy795; - if (yych != 'a') goto yy523; -yy795: - yych = *++p; - if (yych == 'G') goto yy796; - if (yych != 'g') goto yy523; -yy796: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy797: - yych = *++p; - if (yych == 'P') goto yy804; - if (yych == 'p') goto yy804; - goto yy523; -yy798: - yych = *++p; - if (yych == 'H') goto yy801; - if (yych == 'h') goto yy801; - goto yy523; -yy799: - yych = *++p; - if (yych == 'I') goto yy800; - if (yych != 'i') goto yy523; -yy800: - yych = *++p; - if (yych == 'M') goto yy533; - if (yych == 'm') goto yy533; - goto yy523; -yy801: - yych = *++p; - if (yych == 'E') goto yy802; - if (yych != 'e') goto yy523; -yy802: - yych = *++p; - if (yych == 'L') goto yy803; - if (yych != 'l') goto yy523; -yy803: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy804: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; - } -yy805: - yych = *++p; - if (yych == 'D') goto yy809; - if (yych == 'd') goto yy809; - goto yy523; -yy806: - yych = *++p; - if (yych == 'B') goto yy807; - if (yych != 'b') goto yy523; -yy807: - yych = *++p; - if (yych == 'L') goto yy808; - if (yych != 'l') goto yy523; -yy808: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy809: - yych = *++p; - if (yych == 'A') goto yy810; - if (yych != 'a') goto yy523; -yy810: - yych = *++p; - if (yych == 'T') goto yy811; - if (yych != 't') goto yy523; -yy811: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy812: - yych = *++p; - if (yych == 'A') goto yy817; - if (yych == 'a') goto yy817; - goto yy523; -yy813: - yych = *++p; - if (yych == 'S') goto yy814; - if (yych != 's') goto yy523; -yy814: - yych = *++p; - if (yych == 'T') goto yy815; - if (yych != 't') goto yy523; -yy815: - yych = *++p; - if (yych == 'F') goto yy816; - if (yych != 'f') goto yy523; -yy816: - yych = *++p; - if (yych == 'M') goto yy533; - if (yych == 'm') goto yy533; - goto yy523; -yy817: - yych = *++p; - if (yych == 'P') goto yy818; - if (yych != 'p') goto yy523; -yy818: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; - } -yy819: - yych = *++p; - if (yych == 'M') goto yy842; - if (yych == 'm') goto yy842; - goto yy523; -yy820: - yych = *++p; - if (yych <= 'I') { - if (yych == 'C') goto yy831; - if (yych <= 'H') goto yy523; - goto yy830; - } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy523; - goto yy831; - } else { - if (yych == 'i') goto yy830; - goto yy523; - } - } -yy821: - yych = *++p; - if (yych <= 'P') { - if (yych == 'N') goto yy533; - if (yych <= 'O') goto yy523; - goto yy533; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy523; - goto yy533; - } else { - if (yych == 'p') goto yy533; - goto yy523; - } - } -yy822: - yych = *++p; - if (yych <= 'O') { - if (yych == 'A') goto yy828; - if (yych <= 'N') goto yy523; - goto yy829; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy523; - goto yy828; - } else { - if (yych == 'o') goto yy829; - goto yy523; - } - } -yy823: - yych = *++p; - if (yych == 'F') goto yy827; - if (yych == 'f') goto yy827; - goto yy523; -yy824: - yych = *++p; - if (yych <= '@') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'A') goto yy826; - if (yych == 'a') goto yy826; - goto yy523; - } -yy825: - yych = *++p; - if (yych == 'X') goto yy533; - if (yych == 'x') goto yy533; - goto yy523; -yy826: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy827: - yych = *++p; - if (yych == 'O') goto yy533; - if (yych == 'o') goto yy533; - goto yy523; -yy828: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy829: - yych = *++p; - if (yych == 'N') goto yy533; - if (yych == 'n') goto yy533; - goto yy523; -yy830: - yych = *++p; - if (yych == 'S') goto yy832; - if (yych == 's') goto yy832; - goto yy523; -yy831: - yych = *++p; - if (yych <= ':') { - if (yych == '6') goto yy533; - if (yych <= '9') goto yy523; - goto yy534; - } else { - if (yych <= 'S') { - if (yych <= 'R') goto yy523; - goto yy533; - } else { - if (yych == 's') goto yy533; - goto yy523; - } - } -yy832: - yych = *++p; - if (yych == '.') goto yy833; - if (yych == ':') goto yy534; - goto yy523; -yy833: - yych = *++p; - if (yych <= 'X') { - if (yych <= 'K') { - if (yych == 'B') goto yy836; - goto yy523; - } else { - if (yych <= 'L') goto yy834; - if (yych <= 'W') goto yy523; - goto yy835; - } - } else { - if (yych <= 'k') { - if (yych == 'b') goto yy836; - goto yy523; - } else { - if (yych <= 'l') goto yy834; - if (yych == 'x') goto yy835; - goto yy523; - } - } -yy834: - yych = *++p; - if (yych == 'W') goto yy841; - if (yych == 'w') goto yy841; - goto yy523; -yy835: - yych = *++p; - if (yych == 'P') goto yy839; - if (yych == 'p') goto yy839; - goto yy523; -yy836: - yych = *++p; - if (yych == 'E') goto yy837; - if (yych != 'e') goto yy523; -yy837: - yych = *++p; - if (yych == 'E') goto yy838; - if (yych != 'e') goto yy523; -yy838: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy839: - yych = *++p; - if (yych == 'C') goto yy840; - if (yych != 'c') goto yy523; -yy840: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; - } -yy841: - yych = *++p; - if (yych == 'Z') goto yy533; - if (yych == 'z') goto yy533; - goto yy523; -yy842: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy843: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy844: - yych = *++p; - if (yych == 'T') goto yy847; - if (yych == 't') goto yy847; - goto yy523; -yy845: - yych = *++p; - if (yych != '2') goto yy523; - yych = *++p; - if (yych == '3') goto yy533; - goto yy523; -yy847: - yych = *++p; - if (yych == 'P') goto yy848; - if (yych != 'p') goto yy523; -yy848: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; - } -yy849: - yych = *++p; - if (yych == 'A') goto yy865; - if (yych == 'a') goto yy865; - goto yy523; -yy850: - yych = *++p; - if (yych <= 'Z') { - if (yych == 'T') goto yy533; - if (yych <= 'Y') goto yy523; - goto yy856; - } else { - if (yych <= 't') { - if (yych <= 's') goto yy523; - goto yy533; - } else { - if (yych == 'z') goto yy856; - goto yy523; - } - } -yy851: - yych = *++p; - if (yych <= 'O') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'P') goto yy853; - if (yych == 'p') goto yy853; - goto yy523; - } -yy852: - yych = *++p; - if (yych == 'O') goto yy533; - if (yych == 'o') goto yy533; - goto yy523; -yy853: - yych = *++p; - if (yych == 'H') goto yy854; - if (yych != 'h') goto yy523; -yy854: - yych = *++p; - if (yych == 'E') goto yy855; - if (yych != 'e') goto yy523; -yy855: - yych = *++p; - if (yych == 'R') goto yy533; - if (yych == 'r') goto yy533; - goto yy523; -yy856: - yych = *++p; - if (yych == 'M') goto yy857; - if (yych != 'm') goto yy523; -yy857: - yych = *++p; - if (yych == 'O') goto yy858; - if (yych != 'o') goto yy523; -yy858: - yych = *++p; - if (yych == 'P') goto yy859; - if (yych != 'p') goto yy523; -yy859: - yych = *++p; - if (yych == 'R') goto yy860; - if (yych != 'r') goto yy523; -yy860: - yych = *++p; - if (yych == 'O') goto yy861; - if (yych != 'o') goto yy523; -yy861: - yych = *++p; - if (yych == 'J') goto yy862; - if (yych != 'j') goto yy523; -yy862: - yych = *++p; - if (yych == 'E') goto yy863; - if (yych != 'e') goto yy523; -yy863: - yych = *++p; - if (yych == 'C') goto yy864; - if (yych != 'c') goto yy523; -yy864: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy865: - yych = *++p; - if (yych == 'L') goto yy866; - if (yych != 'l') goto yy523; -yy866: - yych = *++p; - if (yych == 'K') goto yy533; - if (yych == 'k') goto yy533; - goto yy523; -yy867: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'M') { - if (yych == 'L') goto yy877; - goto yy523; - } else { - if (yych <= 'N') goto yy878; - if (yych <= 'R') goto yy523; - goto yy879; - } - } else { - if (yych <= 'm') { - if (yych == 'l') goto yy877; - goto yy523; - } else { - if (yych <= 'n') goto yy878; - if (yych == 's') goto yy879; - goto yy523; - } - } -yy868: - yych = *++p; - if (yych == 'E') goto yy876; - if (yych == 'e') goto yy876; - goto yy523; -yy869: - yych = *++p; - if (yych == 'C') goto yy871; - if (yych == 'c') goto yy871; - goto yy523; -yy870: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy871: - yych = *++p; - if (yych == 'E') goto yy872; - if (yych != 'e') goto yy523; -yy872: - yych = *++p; - if (yych == 'T') goto yy873; - if (yych != 't') goto yy523; -yy873: - yych = *++p; - if (yych == 'I') goto yy874; - if (yych != 'i') goto yy523; -yy874: - yych = *++p; - if (yych == 'M') goto yy875; - if (yych != 'm') goto yy523; -yy875: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy876: - yych = *++p; - if (yych == 'D') goto yy533; - if (yych == 'd') goto yy533; - goto yy523; -yy877: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy878: - yych = *++p; - if (yych == 'G') goto yy880; - if (yych == 'g') goto yy880; - goto yy523; -yy879: - yych = *++p; - if (yych == 'H') goto yy533; - if (yych == 'h') goto yy533; - goto yy523; -yy880: - yych = *++p; - if (yych == 'E') goto yy881; - if (yych != 'e') goto yy523; -yy881: - yych = *++p; - if (yych == 'R') goto yy533; - if (yych == 'r') goto yy533; - goto yy523; -yy882: - yych = *++p; - if (yych == 'T') goto yy900; - if (yych == 't') goto yy900; - goto yy523; -yy883: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy884: - yych = *++p; - if (yych == 'M') goto yy533; - if (yych == 'm') goto yy533; - goto yy523; -yy885: - yych = *++p; - if (yych <= 'S') { - if (yych == 'P') goto yy533; - if (yych <= 'R') goto yy523; - goto yy533; - } else { - if (yych <= 'p') { - if (yych <= 'o') goto yy523; - goto yy533; - } else { - if (yych == 's') goto yy533; - goto yy523; - } - } -yy886: - yych = *++p; - if (yych == 'I') goto yy894; - if (yych == 'i') goto yy894; - goto yy523; -yy887: - yych = *++p; - if (yych == 'A') goto yy893; - if (yych == 'a') goto yy893; - goto yy523; -yy888: - yych = *++p; - if (yych == 'O') goto yy891; - if (yych == 'o') goto yy891; - goto yy523; -yy889: - yych = *++p; - if (yych == 'A') goto yy890; - if (yych != 'a') goto yy523; -yy890: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') goto yy534; - goto yy523; - } else { - if (yych <= 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; - } -yy891: - yych = *++p; - if (yych == 'U') goto yy892; - if (yych != 'u') goto yy523; -yy892: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy893: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy894: - yych = *++p; - if (yych == 'U') goto yy895; - if (yych != 'u') goto yy523; -yy895: - yych = *++p; - if (yych == 'M') goto yy896; - if (yych != 'm') goto yy523; -yy896: - yych = *++p; - if (yych == 'X') goto yy897; - if (yych != 'x') goto yy523; -yy897: - yych = *++p; - if (yych == 'T') goto yy898; - if (yych != 't') goto yy523; -yy898: - yych = *++p; - if (yych == 'R') goto yy899; - if (yych != 'r') goto yy523; -yy899: - yych = *++p; - if (yych == 'A') goto yy533; - if (yych == 'a') goto yy533; - goto yy523; -yy900: - yych = *++p; - if (yych == 'A') goto yy901; - if (yych != 'a') goto yy523; -yy901: - yych = *++p; - if (yych == 'C') goto yy902; - if (yych != 'c') goto yy523; -yy902: - yych = *++p; - if (yych == 'H') goto yy903; - if (yych != 'h') goto yy523; -yy903: - yych = *++p; - if (yych == 'M') goto yy904; - if (yych != 'm') goto yy523; -yy904: - yych = *++p; - if (yych == 'E') goto yy905; - if (yych != 'e') goto yy523; -yy905: - yych = *++p; - if (yych == 'N') goto yy906; - if (yych != 'n') goto yy523; -yy906: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy907: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy908: - yych = *++p; - if (yych <= 'V') { - if (yych == 'R') goto yy533; - if (yych <= 'U') goto yy523; - } else { - if (yych <= 'r') { - if (yych <= 'q') goto yy523; - goto yy533; - } else { - if (yych != 'v') goto yy523; - } - } - yych = *++p; - if (yych == 'A') goto yy910; - if (yych != 'a') goto yy523; -yy910: - yych = *++p; - if (yych == 'S') goto yy911; - if (yych != 's') goto yy523; -yy911: - yych = *++p; - if (yych == 'C') goto yy912; - if (yych != 'c') goto yy523; -yy912: - yych = *++p; - if (yych == 'R') goto yy913; - if (yych != 'r') goto yy523; -yy913: - yych = *++p; - if (yych == 'I') goto yy914; - if (yych != 'i') goto yy523; -yy914: - yych = *++p; - if (yych == 'P') goto yy915; - if (yych != 'p') goto yy523; -yy915: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy916: - yych = *++p; - if (yych == 'B') goto yy533; - if (yych == 'b') goto yy533; - goto yy523; -yy917: - yych = *++p; - if (yych == 'N') goto yy533; - if (yych == 'n') goto yy533; - goto yy523; -yy918: - yych = *++p; - if (yych == 'N') goto yy925; - if (yych == 'n') goto yy925; - goto yy523; -yy919: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy920: - yych = *++p; - if (yych == 'C') goto yy924; - if (yych == 'c') goto yy924; - goto yy523; -yy921: - yych = *++p; - if (yych <= 'V') { - if (yych == 'T') goto yy923; - if (yych <= 'U') goto yy523; - goto yy533; - } else { - if (yych <= 't') { - if (yych <= 's') goto yy523; - goto yy923; - } else { - if (yych == 'v') goto yy533; - goto yy523; - } - } -yy922: - yych = *++p; - if (yych == 'I') goto yy533; - if (yych == 'i') goto yy533; - goto yy523; -yy923: - yych = *++p; - if (yych == 'A') goto yy533; - if (yych == 'a') goto yy533; - goto yy523; -yy924: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy925: - yych = *++p; - if (yych == 'A') goto yy926; - if (yych != 'a') goto yy523; -yy926: - yych = *++p; - if (yych != '-') goto yy523; - yych = *++p; - if (yych == 'P') goto yy928; - if (yych != 'p') goto yy523; -yy928: - yych = *++p; - if (yych == 'L') goto yy929; - if (yych != 'l') goto yy523; -yy929: - yych = *++p; - if (yych == 'A') goto yy930; - if (yych != 'a') goto yy523; -yy930: - yych = *++p; - if (yych == 'Y') goto yy931; - if (yych != 'y') goto yy523; -yy931: - yych = *++p; - if (yych <= 'S') { - if (yych == 'C') goto yy932; - if (yych <= 'R') goto yy523; - goto yy933; - } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy523; - } else { - if (yych == 's') goto yy933; - goto yy523; - } - } -yy932: - yych = *++p; - if (yych == 'O') goto yy938; - if (yych == 'o') goto yy938; - goto yy523; -yy933: - yych = *++p; - if (yych == 'I') goto yy934; - if (yych != 'i') goto yy523; -yy934: - yych = *++p; - if (yych == 'N') goto yy935; - if (yych != 'n') goto yy523; -yy935: - yych = *++p; - if (yych == 'G') goto yy936; - if (yych != 'g') goto yy523; -yy936: - yych = *++p; - if (yych == 'L') goto yy937; - if (yych != 'l') goto yy523; -yy937: - yych = *++p; - if (yych == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -yy938: - yych = *++p; - if (yych == 'N') goto yy939; - if (yych != 'n') goto yy523; -yy939: - yych = *++p; - if (yych == 'T') goto yy940; - if (yych != 't') goto yy523; -yy940: - yych = *++p; - if (yych == 'A') goto yy941; - if (yych != 'a') goto yy523; -yy941: - yych = *++p; - if (yych == 'I') goto yy942; - if (yych != 'i') goto yy523; -yy942: - yych = *++p; - if (yych == 'N') goto yy943; - if (yych != 'n') goto yy523; -yy943: - yych = *++p; - if (yych == 'E') goto yy944; - if (yych != 'e') goto yy523; -yy944: - yych = *++p; - if (yych == 'R') goto yy533; - if (yych == 'r') goto yy533; - goto yy523; -yy945: - yych = *++p; - if (yych == 'S') goto yy533; - if (yych == 's') goto yy533; - goto yy523; -yy946: - yych = *++p; - if (yych <= 'N') { - if (yych <= 'A') { - if (yych <= '@') goto yy523; - goto yy968; - } else { - if (yych <= 'L') goto yy523; - if (yych <= 'M') goto yy969; - goto yy970; - } - } else { - if (yych <= 'l') { - if (yych == 'a') goto yy968; - goto yy523; - } else { - if (yych <= 'm') goto yy969; - if (yych <= 'n') goto yy970; - goto yy523; - } - } -yy947: - yych = *++p; - if (yych == 'R') goto yy955; - if (yych == 'r') goto yy955; - goto yy523; -yy948: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy952; - if (yych <= 'O') goto yy523; - goto yy533; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy523; - goto yy952; - } else { - if (yych == 'p') goto yy533; - goto yy523; - } - } -yy949: - yych = *++p; - if (yych == 'I') goto yy951; - if (yych == 'i') goto yy951; - goto yy523; -yy950: - yych = *++p; - if (yych == 'D') goto yy533; - if (yych == 'd') goto yy533; - goto yy523; -yy951: - yych = *++p; - if (yych == 'D') goto yy533; - if (yych == 'd') goto yy533; - goto yy523; -yy952: - yych = *++p; - if (yych == 'L') goto yy953; - if (yych != 'l') goto yy523; -yy953: - yych = *++p; - if (yych == 'T') goto yy954; - if (yych != 't') goto yy523; -yy954: - yych = *++p; - if (yych == 'O') goto yy533; - if (yych == 'o') goto yy533; - goto yy523; -yy955: - yych = *++p; - if (yych == 'O') goto yy956; - if (yych != 'o') goto yy523; -yy956: - yych = *++p; - if (yych == 'M') goto yy957; - if (yych != 'm') goto yy523; -yy957: - yych = *++p; - if (yych == 'E') goto yy958; - if (yych != 'e') goto yy523; -yy958: - yych = *++p; - if (yych == '-') goto yy959; - if (yych == ':') goto yy534; - goto yy523; -yy959: - yych = *++p; - if (yych == 'E') goto yy960; - if (yych != 'e') goto yy523; -yy960: - yych = *++p; - if (yych == 'X') goto yy961; - if (yych != 'x') goto yy523; -yy961: - yych = *++p; - if (yych == 'T') goto yy962; - if (yych != 't') goto yy523; -yy962: - yych = *++p; - if (yych == 'E') goto yy963; - if (yych != 'e') goto yy523; -yy963: - yych = *++p; - if (yych == 'N') goto yy964; - if (yych != 'n') goto yy523; -yy964: - yych = *++p; - if (yych == 'S') goto yy965; - if (yych != 's') goto yy523; -yy965: - yych = *++p; - if (yych == 'I') goto yy966; - if (yych != 'i') goto yy523; -yy966: - yych = *++p; - if (yych == 'O') goto yy967; - if (yych != 'o') goto yy523; -yy967: - yych = *++p; - if (yych == 'N') goto yy533; - if (yych == 'n') goto yy533; - goto yy523; -yy968: - yych = *++p; - if (yych == 'P') goto yy533; - if (yych == 'p') goto yy533; - goto yy523; -yy969: - yych = *++p; - if (yych == '-') goto yy974; - goto yy523; -yy970: - yych = *++p; - if (yych == 'T') goto yy971; - if (yych != 't') goto yy523; -yy971: - yych = *++p; - if (yych == 'E') goto yy972; - if (yych != 'e') goto yy523; -yy972: - yych = *++p; - if (yych == 'N') goto yy973; - if (yych != 'n') goto yy523; -yy973: - yych = *++p; - if (yych == 'T') goto yy533; - if (yych == 't') goto yy533; - goto yy523; -yy974: - yych = *++p; - if (yych == 'E') goto yy975; - if (yych != 'e') goto yy523; -yy975: - yych = *++p; - if (yych == 'V') goto yy976; - if (yych != 'v') goto yy523; -yy976: - yych = *++p; - if (yych == 'E') goto yy977; - if (yych != 'e') goto yy523; -yy977: - yych = *++p; - if (yych == 'N') goto yy978; - if (yych != 'n') goto yy523; -yy978: - yych = *++p; - if (yych == 'T') goto yy979; - if (yych != 't') goto yy523; -yy979: - yych = *++p; - if (yych == 'B') goto yy980; - if (yych != 'b') goto yy523; -yy980: - yych = *++p; - if (yych == 'R') goto yy981; - if (yych != 'r') goto yy523; -yy981: - yych = *++p; - if (yych == 'I') goto yy982; - if (yych != 'i') goto yy523; -yy982: - yych = *++p; - if (yych == 'T') goto yy983; - if (yych != 't') goto yy523; -yy983: - yych = *++p; - if (yych == 'E') goto yy984; - if (yych != 'e') goto yy523; -yy984: - yych = *++p; - if (yych != '-') goto yy523; - yych = *++p; - if (yych == 'A') goto yy986; - if (yych != 'a') goto yy523; -yy986: - yych = *++p; - if (yych == 'T') goto yy987; - if (yych != 't') goto yy523; -yy987: - yych = *++p; - if (yych == 'T') goto yy988; - if (yych != 't') goto yy523; -yy988: - yych = *++p; - if (yych == 'E') goto yy989; - if (yych != 'e') goto yy523; -yy989: - yych = *++p; - if (yych == 'N') goto yy990; - if (yych != 'n') goto yy523; -yy990: - yych = *++p; - if (yych == 'D') goto yy991; - if (yych != 'd') goto yy523; -yy991: - yych = *++p; - if (yych == 'E') goto yy992; - if (yych != 'e') goto yy523; -yy992: - ++p; - if ((yych = *p) == 'E') goto yy533; - if (yych == 'e') goto yy533; - goto yy523; -} - + { + 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); + if (yych <= 'c') { + if (yych <= 'M') { + if (yych <= 'E') { + if (yych <= 'A') { + if (yych == '\n') + goto yy494; + if (yych <= '@') + goto yy521; + goto yy498; + } else { + if (yych <= 'B') + goto yy516; + if (yych <= 'C') + goto yy495; + if (yych <= 'D') + goto yy496; + goto yy517; + } + } else { + if (yych <= 'I') { + if (yych <= 'F') + goto yy499; + if (yych <= 'G') + goto yy500; + if (yych <= 'H') + goto yy501; + goto yy502; + } else { + if (yych <= 'J') + goto yy497; + if (yych <= 'K') + goto yy518; + if (yych <= 'L') + goto yy503; + goto yy504; + } + } + } else { + if (yych <= 'U') { + if (yych <= 'Q') { + if (yych <= 'N') + goto yy505; + if (yych <= 'O') + goto yy506; + if (yych <= 'P') + goto yy507; + goto yy519; + } else { + if (yych <= 'R') + goto yy508; + if (yych <= 'S') + goto yy509; + if (yych <= 'T') + goto yy510; + goto yy511; + } + } else { + if (yych <= 'Y') { + if (yych <= 'V') + goto yy512; + if (yych <= 'W') + goto yy513; + if (yych <= 'X') + goto yy514; + goto yy520; + } else { + if (yych <= '`') { + if (yych <= 'Z') + goto yy515; + goto yy521; + } else { + if (yych <= 'a') + goto yy498; + if (yych <= 'b') + goto yy516; + goto yy495; + } + } + } + } + } else { + if (yych <= 't') { + if (yych <= 'k') { + if (yych <= 'g') { + if (yych <= 'd') + goto yy496; + if (yych <= 'e') + goto yy517; + if (yych <= 'f') + goto yy499; + goto yy500; + } else { + if (yych <= 'h') + goto yy501; + if (yych <= 'i') + goto yy502; + if (yych <= 'j') + goto yy497; + goto yy518; + } + } else { + if (yych <= 'o') { + if (yych <= 'l') + goto yy503; + if (yych <= 'm') + goto yy504; + if (yych <= 'n') + goto yy505; + goto yy506; + } else { + if (yych <= 'q') { + if (yych <= 'p') + goto yy507; + goto yy519; + } else { + if (yych <= 'r') + goto yy508; + if (yych <= 's') + goto yy509; + goto yy510; + } + } + } + } else { + if (yych <= 0xC1) { + if (yych <= 'x') { + if (yych <= 'u') + goto yy511; + if (yych <= 'v') + goto yy512; + if (yych <= 'w') + goto yy513; + goto yy514; + } else { + if (yych <= 'y') + goto yy520; + if (yych <= 'z') + goto yy515; + if (yych <= 0x7F) + goto yy521; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy522; + if (yych <= 0xE0) + goto yy524; + if (yych <= 0xEC) + goto yy525; + goto yy529; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy525; + goto yy526; + } else { + if (yych <= 0xF3) + goto yy527; + if (yych <= 0xF4) + goto yy528; + } + } + } + } + } + yy494 : { return 0; } + yy495: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy948; + case 'H': + case 'h': + goto yy947; + case 'I': + case 'i': + goto yy950; + case 'O': + case 'o': + goto yy946; + case 'R': + case 'r': + goto yy949; + case 'V': + case 'v': + goto yy945; + default: + goto yy494; + } + yy496: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy921; + case 'I': + case 'i': + goto yy920; + case 'L': + case 'l': + goto yy918; + case 'N': + case 'n': + goto yy919; + case 'O': + case 'o': + goto yy922; + case 'T': + case 't': + goto yy917; + case 'V': + case 'v': + goto yy916; + default: + goto yy494; + } + yy497: + yych = *(marker = ++p); + if (yych <= 'M') { + if (yych == 'A') + goto yy908; + if (yych <= 'L') + goto yy494; + goto yy907; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy494; + goto yy908; + } else { + if (yych == 'm') + goto yy907; + goto yy494; + } + } + yy498: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy889; + case 'B': + case 'b': + goto yy888; + case 'C': + case 'c': + goto yy887; + case 'D': + case 'd': + goto yy886; + case 'F': + case 'f': + goto yy885; + case 'I': + case 'i': + goto yy884; + case 'P': + case 'p': + goto yy883; + case 'T': + case 't': + goto yy882; + case 'W': + case 'w': + goto yy533; + default: + goto yy494; + } + yy499: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'E') { + if (yych == 'A') + goto yy869; + if (yych <= 'D') + goto yy494; + goto yy868; + } else { + if (yych == 'I') + goto yy867; + if (yych <= 'S') + goto yy494; + goto yy870; + } + } else { + if (yych <= 'e') { + if (yych == 'a') + goto yy869; + if (yych <= 'd') + goto yy494; + goto yy868; + } else { + if (yych <= 'i') { + if (yych <= 'h') + goto yy494; + goto yy867; + } else { + if (yych == 't') + goto yy870; + goto yy494; + } + } + } + yy500: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': + goto yy852; + case 'G': + case 'g': + goto yy533; + case 'I': + case 'i': + goto yy850; + case 'O': + case 'o': + goto yy851; + case 'T': + case 't': + goto yy849; + default: + goto yy494; + } + yy501: + yych = *(marker = ++p); + if (yych <= 'S') { + if (yych <= '3') { + if (yych <= '2') + goto yy494; + goto yy845; + } else { + if (yych == 'C') + goto yy843; + goto yy494; + } + } else { + if (yych <= 'c') { + if (yych <= 'T') + goto yy844; + if (yych <= 'b') + goto yy494; + goto yy843; + } else { + if (yych == 't') + goto yy844; + goto yy494; + } + } + yy502: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy825; + case 'C': + case 'c': + goto yy822; + case 'M': + case 'm': + goto yy824; + case 'N': + case 'n': + goto yy823; + case 'P': + case 'p': + goto yy821; + case 'R': + case 'r': + goto yy820; + case 'T': + case 't': + goto yy819; + default: + goto yy494; + } + yy503: + yych = *(marker = ++p); + if (yych <= 'D') { + if (yych == 'A') + goto yy813; + if (yych <= 'C') + goto yy494; + goto yy812; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy494; + goto yy813; + } else { + if (yych == 'd') + goto yy812; + goto yy494; + } + } + yy504: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy779; + case 'E': + case 'e': + goto yy778; + case 'I': + case 'i': + goto yy781; + case 'M': + case 'm': + goto yy777; + case 'S': + case 's': + goto yy776; + case 'T': + case 't': + goto yy780; + case 'U': + case 'u': + goto yy775; + case 'V': + case 'v': + goto yy774; + default: + goto yy494; + } + yy505: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': + goto yy769; + case 'F': + case 'f': + goto yy768; + case 'I': + case 'i': + goto yy767; + case 'N': + case 'n': + goto yy766; + case 'O': + case 'o': + goto yy765; + default: + goto yy494; + } + yy506: + yych = *(marker = ++p); + if (yych <= 'P') { + if (yych == 'I') + goto yy751; + if (yych <= 'O') + goto yy494; + goto yy752; + } else { + if (yych <= 'i') { + if (yych <= 'h') + goto yy494; + goto yy751; + } else { + if (yych == 'p') + goto yy752; + goto yy494; + } + } + yy507: + yych = *(marker = ++p); + if (yych <= 'S') { + if (yych <= 'L') { + if (yych == 'A') + goto yy733; + if (yych <= 'K') + goto yy494; + goto yy732; + } else { + if (yych <= 'O') { + if (yych <= 'N') + goto yy494; + goto yy734; + } else { + if (yych <= 'Q') + goto yy494; + if (yych <= 'R') + goto yy731; + goto yy730; + } + } + } else { + if (yych <= 'n') { + if (yych <= 'a') { + if (yych <= '`') + goto yy494; + goto yy733; + } else { + if (yych == 'l') + goto yy732; + goto yy494; + } + } else { + if (yych <= 'q') { + if (yych <= 'o') + goto yy734; + goto yy494; + } else { + if (yych <= 'r') + goto yy731; + if (yych <= 's') + goto yy730; + goto yy494; + } + } + } + yy508: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'L') { + if (yych == 'E') + goto yy720; + goto yy494; + } else { + if (yych <= 'M') + goto yy719; + if (yych <= 'R') + goto yy494; + if (yych <= 'S') + goto yy718; + goto yy717; + } + } else { + if (yych <= 'm') { + if (yych == 'e') + goto yy720; + if (yych <= 'l') + goto yy494; + goto yy719; + } else { + if (yych <= 'r') + goto yy494; + if (yych <= 's') + goto yy718; + if (yych <= 't') + goto yy717; + goto yy494; + } + } + yy509: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': + goto yy673; + case 'F': + case 'f': + goto yy672; + case 'G': + case 'g': + goto yy671; + case 'H': + case 'h': + goto yy676; + case 'I': + case 'i': + goto yy675; + case 'K': + case 'k': + goto yy670; + case 'M': + case 'm': + goto yy669; + case 'N': + case 'n': + goto yy674; + case 'O': + case 'o': + goto yy668; + case 'P': + case 'p': + goto yy667; + case 'S': + case 's': + goto yy666; + case 'T': + case 't': + goto yy665; + case 'V': + case 'v': + goto yy664; + default: + goto yy494; + } + yy510: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': + goto yy640; + case 'E': + case 'e': + goto yy636; + case 'F': + case 'f': + goto yy639; + case 'H': + case 'h': + goto yy635; + case 'I': + case 'i': + goto yy637; + case 'N': + case 'n': + goto yy638; + case 'V': + case 'v': + goto yy533; + default: + goto yy494; + } + yy511: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'N') { + if (yych == 'D') + goto yy627; + if (yych <= 'M') + goto yy494; + goto yy626; + } else { + if (yych == 'R') + goto yy628; + if (yych <= 'S') + goto yy494; + goto yy625; + } + } else { + if (yych <= 'n') { + if (yych == 'd') + goto yy627; + if (yych <= 'm') + goto yy494; + goto yy626; + } else { + if (yych <= 'r') { + if (yych <= 'q') + goto yy494; + goto yy628; + } else { + if (yych == 't') + goto yy625; + goto yy494; + } + } + } + yy512: + yych = *(marker = ++p); + if (yych <= 'I') { + if (yych == 'E') + goto yy609; + if (yych <= 'H') + goto yy494; + goto yy608; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy494; + goto yy609; + } else { + if (yych == 'i') + goto yy608; + goto yy494; + } + } + yy513: + yych = *(marker = ++p); + if (yych <= 'Y') { + if (yych <= 'R') { + if (yych == 'E') + goto yy598; + goto yy494; + } else { + if (yych <= 'S') + goto yy599; + if (yych <= 'T') + goto yy597; + if (yych <= 'X') + goto yy494; + goto yy596; + } + } else { + if (yych <= 's') { + if (yych == 'e') + goto yy598; + if (yych <= 'r') + goto yy494; + goto yy599; + } else { + if (yych <= 't') + goto yy597; + if (yych == 'y') + goto yy596; + goto yy494; + } + } + yy514: + yych = *(marker = ++p); + if (yych <= 'R') { + if (yych <= 'F') { + if (yych == 'C') + goto yy575; + if (yych <= 'E') + goto yy494; + goto yy573; + } else { + if (yych == 'M') + goto yy574; + if (yych <= 'Q') + goto yy494; + goto yy572; + } + } else { + if (yych <= 'f') { + if (yych == 'c') + goto yy575; + if (yych <= 'e') + goto yy494; + goto yy573; + } else { + if (yych <= 'm') { + if (yych <= 'l') + goto yy494; + goto yy574; + } else { + if (yych == 'r') + goto yy572; + goto yy494; + } + } + } + yy515: + yych = *(marker = ++p); + if (yych == '3') + goto yy567; + goto yy494; + yy516: + yych = *(marker = ++p); + if (yych <= 'O') { + if (yych <= 'H') { + if (yych == 'E') + goto yy557; + goto yy494; + } else { + if (yych <= 'I') + goto yy556; + if (yych <= 'N') + goto yy494; + goto yy555; + } + } else { + if (yych <= 'h') { + if (yych == 'e') + goto yy557; + goto yy494; + } else { + if (yych <= 'i') + goto yy556; + if (yych == 'o') + goto yy555; + goto yy494; + } + } + yy517: + yych = *(marker = ++p); + if (yych == 'D') + goto yy553; + if (yych == 'd') + goto yy553; + goto yy494; + yy518: + yych = *(marker = ++p); + if (yych == 'E') + goto yy548; + if (yych == 'e') + goto yy548; + goto yy494; + yy519: + yych = *(marker = ++p); + if (yych == 'U') + goto yy545; + if (yych == 'u') + goto yy545; + goto yy494; + yy520: + yych = *(marker = ++p); + if (yych == 'M') + goto yy530; + if (yych == 'm') + goto yy530; + goto yy494; + yy521: + yych = *++p; + goto yy494; + yy522: + yych = *++p; + if (yych <= 0x7F) + goto yy523; + if (yych <= 0xBF) + goto yy521; + yy523: + p = marker; + goto yy494; + yy524: + yych = *++p; + if (yych <= 0x9F) + goto yy523; + if (yych <= 0xBF) + goto yy522; + goto yy523; + yy525: + yych = *++p; + if (yych <= 0x7F) + goto yy523; + if (yych <= 0xBF) + goto yy522; + goto yy523; + yy526: + yych = *++p; + if (yych <= 0x8F) + goto yy523; + if (yych <= 0xBF) + goto yy525; + goto yy523; + yy527: + yych = *++p; + if (yych <= 0x7F) + goto yy523; + if (yych <= 0xBF) + goto yy525; + goto yy523; + yy528: + yych = *++p; + if (yych <= 0x7F) + goto yy523; + if (yych <= 0x8F) + goto yy525; + goto yy523; + yy529: + yych = *++p; + if (yych <= 0x7F) + goto yy523; + if (yych <= 0x9F) + goto yy522; + goto yy523; + yy530: + yych = *++p; + if (yych == 'S') + goto yy531; + if (yych != 's') + goto yy523; + yy531: + yych = *++p; + if (yych == 'G') + goto yy532; + if (yych != 'g') + goto yy523; + yy532: + yych = *++p; + if (yych == 'R') + goto yy533; + if (yych != 'r') + goto yy523; + yy533: + yych = *++p; + if (yych != ':') + goto yy523; + yy534: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy534; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '<') + goto yy523; + if (yych <= '>') + goto yy543; + goto yy523; + } else { + if (yych <= 0xDF) + goto yy536; + if (yych <= 0xE0) + goto yy537; + goto yy538; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy542; + if (yych <= 0xEF) + goto yy538; + goto yy539; + } else { + if (yych <= 0xF3) + goto yy540; + if (yych <= 0xF4) + goto yy541; + goto yy523; + } + } + yy536: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy523; + if (yych <= 0xBF) + goto yy534; + goto yy523; + yy537: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy523; + if (yych <= 0xBF) + goto yy536; + goto yy523; + yy538: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy523; + if (yych <= 0xBF) + goto yy536; + goto yy523; + yy539: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy523; + if (yych <= 0xBF) + goto yy538; + goto yy523; + yy540: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy523; + if (yych <= 0xBF) + goto yy538; + goto yy523; + yy541: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy523; + if (yych <= 0x8F) + goto yy538; + goto yy523; + yy542: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy523; + if (yych <= 0x9F) + goto yy536; + goto yy523; + yy543: + ++p; + { return (bufsize_t)(p - start); } + yy545: + yych = *++p; + if (yych == 'E') + goto yy546; + if (yych != 'e') + goto yy523; + yy546: + yych = *++p; + if (yych == 'R') + goto yy547; + if (yych != 'r') + goto yy523; + yy547: + yych = *++p; + if (yych == 'Y') + goto yy533; + if (yych == 'y') + goto yy533; + goto yy523; + yy548: + yych = *++p; + if (yych == 'Y') + goto yy549; + if (yych != 'y') + goto yy523; + yy549: + yych = *++p; + if (yych == 'P') + goto yy550; + if (yych != 'p') + goto yy523; + yy550: + yych = *++p; + if (yych == 'A') + goto yy551; + if (yych != 'a') + goto yy523; + yy551: + yych = *++p; + if (yych == 'R') + goto yy552; + if (yych != 'r') + goto yy523; + yy552: + yych = *++p; + if (yych == 'C') + goto yy533; + if (yych == 'c') + goto yy533; + goto yy523; + yy553: + yych = *++p; + if (yych != '2') + goto yy523; + yych = *++p; + if (yych == 'K') + goto yy533; + if (yych == 'k') + goto yy533; + goto yy523; + yy555: + yych = *++p; + if (yych == 'L') + goto yy566; + if (yych == 'l') + goto yy566; + goto yy523; + yy556: + yych = *++p; + if (yych == 'T') + goto yy562; + if (yych == 't') + goto yy562; + goto yy523; + yy557: + yych = *++p; + if (yych == 'S') + goto yy558; + if (yych != 's') + goto yy523; + yy558: + yych = *++p; + if (yych == 'H') + goto yy559; + if (yych != 'h') + goto yy523; + yy559: + yych = *++p; + if (yych == 'A') + goto yy560; + if (yych != 'a') + goto yy523; + yy560: + yych = *++p; + if (yych == 'R') + goto yy561; + if (yych != 'r') + goto yy523; + yy561: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy562: + yych = *++p; + if (yych == 'C') + goto yy563; + if (yych != 'c') + goto yy523; + yy563: + yych = *++p; + if (yych == 'O') + goto yy564; + if (yych != 'o') + goto yy523; + yy564: + yych = *++p; + if (yych == 'I') + goto yy565; + if (yych != 'i') + goto yy523; + yy565: + yych = *++p; + if (yych == 'N') + goto yy533; + if (yych == 'n') + goto yy533; + goto yy523; + yy566: + yych = *++p; + if (yych == 'O') + goto yy533; + if (yych == 'o') + goto yy533; + goto yy523; + yy567: + yych = *++p; + if (yych != '9') + goto yy523; + yych = *++p; + if (yych != '.') + goto yy523; + yych = *++p; + if (yych != '5') + goto yy523; + yych = *++p; + if (yych != '0') + goto yy523; + yych = *++p; + if (yych <= 'Q') + goto yy523; + if (yych <= 'S') + goto yy533; + if (yych <= 'q') + goto yy523; + if (yych <= 's') + goto yy533; + goto yy523; + yy572: + yych = *++p; + if (yych == 'I') + goto yy533; + if (yych == 'i') + goto yy533; + goto yy523; + yy573: + yych = *++p; + if (yych == 'I') + goto yy594; + if (yych == 'i') + goto yy594; + goto yy523; + yy574: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') + goto yy584; + if (yych <= 'O') + goto yy523; + goto yy585; + } else { + if (yych <= 'l') { + if (yych <= 'k') + goto yy523; + goto yy584; + } else { + if (yych == 'p') + goto yy585; + goto yy523; + } + } + yy575: + yych = *++p; + if (yych == 'O') + goto yy576; + if (yych != 'o') + goto yy523; + yy576: + yych = *++p; + if (yych == 'N') + goto yy577; + if (yych != 'n') + goto yy523; + yy577: + yych = *++p; + if (yych == '-') + goto yy578; + if (yych == ':') + goto yy534; + goto yy523; + yy578: + yych = *++p; + if (yych == 'U') + goto yy579; + if (yych != 'u') + goto yy523; + yy579: + yych = *++p; + if (yych == 'S') + goto yy580; + if (yych != 's') + goto yy523; + yy580: + yych = *++p; + if (yych == 'E') + goto yy581; + if (yych != 'e') + goto yy523; + yy581: + yych = *++p; + if (yych == 'R') + goto yy582; + if (yych != 'r') + goto yy523; + yy582: + yych = *++p; + if (yych == 'I') + goto yy583; + if (yych != 'i') + goto yy523; + yy583: + yych = *++p; + if (yych == 'D') + goto yy533; + if (yych == 'd') + goto yy533; + goto yy523; + yy584: + yych = *++p; + if (yych == 'R') + goto yy586; + if (yych == 'r') + goto yy586; + goto yy523; + yy585: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy586: + yych = *++p; + if (yych == 'P') + goto yy587; + if (yych != 'p') + goto yy523; + yy587: + yych = *++p; + if (yych == 'C') + goto yy588; + if (yych != 'c') + goto yy523; + yy588: + yych = *++p; + if (yych != '.') + goto yy523; + yych = *++p; + if (yych == 'B') + goto yy590; + if (yych != 'b') + goto yy523; + yy590: + yych = *++p; + if (yych == 'E') + goto yy591; + if (yych != 'e') + goto yy523; + yy591: + yych = *++p; + if (yych == 'E') + goto yy592; + if (yych != 'e') + goto yy523; + yy592: + yych = *++p; + if (yych == 'P') + goto yy593; + if (yych != 'p') + goto yy523; + yy593: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + } + yy594: + yych = *++p; + if (yych == 'R') + goto yy595; + if (yych != 'r') + goto yy523; + yy595: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy596: + yych = *++p; + if (yych == 'C') + goto yy604; + if (yych == 'c') + goto yy604; + goto yy523; + yy597: + yych = *++p; + if (yych == 'A') + goto yy603; + if (yych == 'a') + goto yy603; + goto yy523; + yy598: + yych = *++p; + if (yych == 'B') + goto yy600; + if (yych == 'b') + goto yy600; + goto yy523; + yy599: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + } + yy600: + yych = *++p; + if (yych == 'C') + goto yy601; + if (yych != 'c') + goto yy523; + yy601: + yych = *++p; + if (yych == 'A') + goto yy602; + if (yych != 'a') + goto yy523; + yy602: + yych = *++p; + if (yych == 'L') + goto yy533; + if (yych == 'l') + goto yy533; + goto yy523; + yy603: + yych = *++p; + if (yych == 'I') + goto yy533; + if (yych == 'i') + goto yy533; + goto yy523; + yy604: + yych = *++p; + if (yych == 'I') + goto yy605; + if (yych != 'i') + goto yy523; + yy605: + yych = *++p; + if (yych == 'W') + goto yy606; + if (yych != 'w') + goto yy523; + yy606: + yych = *++p; + if (yych == 'Y') + goto yy607; + if (yych != 'y') + goto yy523; + yy607: + yych = *++p; + if (yych == 'G') + goto yy533; + if (yych == 'g') + goto yy533; + goto yy523; + yy608: + yych = *++p; + if (yych == 'E') + goto yy617; + if (yych == 'e') + goto yy617; + goto yy523; + yy609: + yych = *++p; + if (yych <= 'N') { + if (yych <= 'L') + goto yy523; + if (yych >= 'N') + goto yy611; + } else { + if (yych <= 'l') + goto yy523; + if (yych <= 'm') + goto yy610; + if (yych <= 'n') + goto yy611; + goto yy523; + } + yy610: + yych = *++p; + if (yych == 'M') + goto yy616; + if (yych == 'm') + goto yy616; + goto yy523; + yy611: + yych = *++p; + if (yych == 'T') + goto yy612; + if (yych != 't') + goto yy523; + yy612: + yych = *++p; + if (yych == 'R') + goto yy613; + if (yych != 'r') + goto yy523; + yy613: + yych = *++p; + if (yych == 'I') + goto yy614; + if (yych != 'i') + goto yy523; + yy614: + yych = *++p; + if (yych == 'L') + goto yy615; + if (yych != 'l') + goto yy523; + yy615: + yych = *++p; + if (yych == 'O') + goto yy533; + if (yych == 'o') + goto yy533; + goto yy523; + yy616: + yych = *++p; + if (yych == 'I') + goto yy533; + if (yych == 'i') + goto yy533; + goto yy523; + yy617: + yych = *++p; + if (yych == 'W') + goto yy618; + if (yych != 'w') + goto yy523; + yy618: + yych = *++p; + if (yych != '-') + goto yy523; + yych = *++p; + if (yych == 'S') + goto yy620; + if (yych != 's') + goto yy523; + yy620: + yych = *++p; + if (yych == 'O') + goto yy621; + if (yych != 'o') + goto yy523; + yy621: + yych = *++p; + if (yych == 'U') + goto yy622; + if (yych != 'u') + goto yy523; + yy622: + yych = *++p; + if (yych == 'R') + goto yy623; + if (yych != 'r') + goto yy523; + yy623: + yych = *++p; + if (yych == 'C') + goto yy624; + if (yych != 'c') + goto yy523; + yy624: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy625: + yych = *++p; + if (yych == '2') + goto yy632; + goto yy523; + yy626: + yych = *++p; + if (yych == 'R') + goto yy629; + if (yych == 'r') + goto yy629; + goto yy523; + yy627: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy628: + yych = *++p; + if (yych == 'N') + goto yy533; + if (yych == 'n') + goto yy533; + goto yy523; + yy629: + yych = *++p; + if (yych == 'E') + goto yy630; + if (yych != 'e') + goto yy523; + yy630: + yych = *++p; + if (yych == 'A') + goto yy631; + if (yych != 'a') + goto yy523; + yy631: + yych = *++p; + if (yych == 'L') + goto yy533; + if (yych == 'l') + goto yy533; + goto yy523; + yy632: + yych = *++p; + if (yych != '0') + goto yy523; + yych = *++p; + if (yych != '0') + goto yy523; + yych = *++p; + if (yych == '4') + goto yy533; + goto yy523; + yy635: + yych = *++p; + if (yych == 'I') + goto yy654; + if (yych == 'i') + goto yy654; + goto yy523; + yy636: + yych = *++p; + if (yych <= 'L') { + if (yych == 'A') + goto yy646; + if (yych <= 'K') + goto yy523; + goto yy645; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy523; + goto yy646; + } else { + if (yych == 'l') + goto yy645; + goto yy523; + } + } + yy637: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy638: + yych = *++p; + if (yych == '3') + goto yy642; + goto yy523; + yy639: + yych = *++p; + if (yych == 'T') + goto yy641; + if (yych == 't') + goto yy641; + goto yy523; + yy640: + yych = *++p; + if (yych == 'G') + goto yy533; + if (yych == 'g') + goto yy533; + goto yy523; + yy641: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy642: + yych = *++p; + if (yych != '2') + goto yy523; + yych = *++p; + if (yych != '7') + goto yy523; + yych = *++p; + if (yych == '0') + goto yy533; + goto yy523; + yy645: + yych = *++p; + if (yych <= 'M') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'N') + goto yy652; + if (yych == 'n') + goto yy652; + goto yy523; + } + yy646: + yych = *++p; + if (yych == 'M') + goto yy647; + if (yych != 'm') + goto yy523; + yy647: + yych = *++p; + if (yych == 'S') + goto yy648; + if (yych != 's') + goto yy523; + yy648: + yych = *++p; + if (yych == 'P') + goto yy649; + if (yych != 'p') + goto yy523; + yy649: + yych = *++p; + if (yych == 'E') + goto yy650; + if (yych != 'e') + goto yy523; + yy650: + yych = *++p; + if (yych == 'A') + goto yy651; + if (yych != 'a') + goto yy523; + yy651: + yych = *++p; + if (yych == 'K') + goto yy533; + if (yych == 'k') + goto yy533; + goto yy523; + yy652: + yych = *++p; + if (yych == 'E') + goto yy653; + if (yych != 'e') + goto yy523; + yy653: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy654: + yych = *++p; + if (yych <= 'S') { + if (yych == 'N') + goto yy655; + if (yych <= 'R') + goto yy523; + goto yy656; + } else { + if (yych <= 'n') { + if (yych <= 'm') + goto yy523; + } else { + if (yych == 's') + goto yy656; + goto yy523; + } + } + yy655: + yych = *++p; + if (yych == 'G') + goto yy663; + if (yych == 'g') + goto yy663; + goto yy523; + yy656: + yych = *++p; + if (yych == 'M') + goto yy657; + if (yych != 'm') + goto yy523; + yy657: + yych = *++p; + if (yych == 'E') + goto yy658; + if (yych != 'e') + goto yy523; + yy658: + yych = *++p; + if (yych == 'S') + goto yy659; + if (yych != 's') + goto yy523; + yy659: + yych = *++p; + if (yych == 'S') + goto yy660; + if (yych != 's') + goto yy523; + yy660: + yych = *++p; + if (yych == 'A') + goto yy661; + if (yych != 'a') + goto yy523; + yy661: + yych = *++p; + if (yych == 'G') + goto yy662; + if (yych != 'g') + goto yy523; + yy662: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy663: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy664: + yych = *++p; + if (yych == 'N') + goto yy533; + if (yych == 'n') + goto yy533; + goto yy523; + yy665: + yych = *++p; + if (yych == 'E') + goto yy715; + if (yych == 'e') + goto yy715; + goto yy523; + yy666: + yych = *++p; + if (yych == 'H') + goto yy533; + if (yych == 'h') + goto yy533; + goto yy523; + yy667: + yych = *++p; + if (yych == 'O') + goto yy711; + if (yych == 'o') + goto yy711; + goto yy523; + yy668: + yych = *++p; + if (yych <= 'L') { + if (yych == 'A') + goto yy701; + if (yych <= 'K') + goto yy523; + goto yy702; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy523; + goto yy701; + } else { + if (yych == 'l') + goto yy702; + goto yy523; + } + } + yy669: + yych = *++p; + if (yych <= 'S') { + if (yych == 'B') + goto yy533; + if (yych <= 'R') + goto yy523; + goto yy533; + } else { + if (yych <= 'b') { + if (yych <= 'a') + goto yy523; + goto yy533; + } else { + if (yych == 's') + goto yy533; + goto yy523; + } + } + yy670: + yych = *++p; + if (yych == 'Y') + goto yy699; + if (yych == 'y') + goto yy699; + goto yy523; + yy671: + yych = *++p; + if (yych == 'N') + goto yy533; + if (yych == 'n') + goto yy533; + goto yy523; + yy672: + yych = *++p; + if (yych == 'T') + goto yy698; + if (yych == 't') + goto yy698; + goto yy523; + yy673: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'C') { + if (yych <= 'B') + goto yy523; + goto yy685; + } else { + if (yych <= 'Q') + goto yy523; + if (yych <= 'R') + goto yy683; + goto yy684; + } + } else { + if (yych <= 'q') { + if (yych == 'c') + goto yy685; + goto yy523; + } else { + if (yych <= 'r') + goto yy683; + if (yych <= 's') + goto yy684; + goto yy523; + } + } + yy674: + yych = *++p; + if (yych == 'M') + goto yy682; + if (yych == 'm') + goto yy682; + goto yy523; + yy675: + yych = *++p; + if (yych <= 'P') { + if (yych == 'E') + goto yy679; + if (yych <= 'O') + goto yy523; + goto yy680; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy523; + goto yy679; + } else { + if (yych == 'p') + goto yy680; + goto yy523; + } + } + yy676: + yych = *++p; + if (yych == 'T') + goto yy677; + if (yych != 't') + goto yy523; + yy677: + yych = *++p; + if (yych == 'T') + goto yy678; + if (yych != 't') + goto yy523; + yy678: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy679: + yych = *++p; + if (yych == 'V') + goto yy681; + if (yych == 'v') + goto yy681; + goto yy523; + yy680: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + } + yy681: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy682: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy683: + yych = *++p; + if (yych == 'V') + goto yy695; + if (yych == 'v') + goto yy695; + goto yy523; + yy684: + yych = *++p; + if (yych == 'S') + goto yy692; + if (yych == 's') + goto yy692; + goto yy523; + yy685: + yych = *++p; + if (yych == 'O') + goto yy686; + if (yych != 'o') + goto yy523; + yy686: + yych = *++p; + if (yych == 'N') + goto yy687; + if (yych != 'n') + goto yy523; + yy687: + yych = *++p; + if (yych == 'D') + goto yy688; + if (yych != 'd') + goto yy523; + yy688: + yych = *++p; + if (yych == 'L') + goto yy689; + if (yych != 'l') + goto yy523; + yy689: + yych = *++p; + if (yych == 'I') + goto yy690; + if (yych != 'i') + goto yy523; + yy690: + yych = *++p; + if (yych == 'F') + goto yy691; + if (yych != 'f') + goto yy523; + yy691: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy692: + yych = *++p; + if (yych == 'I') + goto yy693; + if (yych != 'i') + goto yy523; + yy693: + yych = *++p; + if (yych == 'O') + goto yy694; + if (yych != 'o') + goto yy523; + yy694: + yych = *++p; + if (yych == 'N') + goto yy533; + if (yych == 'n') + goto yy533; + goto yy523; + yy695: + yych = *++p; + if (yych == 'I') + goto yy696; + if (yych != 'i') + goto yy523; + yy696: + yych = *++p; + if (yych == 'C') + goto yy697; + if (yych != 'c') + goto yy523; + yy697: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy698: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy699: + yych = *++p; + if (yych == 'P') + goto yy700; + if (yych != 'p') + goto yy523; + yy700: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy701: + yych = *++p; + if (yych == 'P') + goto yy705; + if (yych == 'p') + goto yy705; + goto yy523; + yy702: + yych = *++p; + if (yych == 'D') + goto yy703; + if (yych != 'd') + goto yy523; + yy703: + yych = *++p; + if (yych == 'A') + goto yy704; + if (yych != 'a') + goto yy523; + yy704: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy705: + yych = *++p; + if (yych != '.') + goto yy523; + yych = *++p; + if (yych == 'B') + goto yy707; + if (yych != 'b') + goto yy523; + yy707: + yych = *++p; + if (yych == 'E') + goto yy708; + if (yych != 'e') + goto yy523; + yy708: + yych = *++p; + if (yych == 'E') + goto yy709; + if (yych != 'e') + goto yy523; + yy709: + yych = *++p; + if (yych == 'P') + goto yy710; + if (yych != 'p') + goto yy523; + yy710: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + } + yy711: + yych = *++p; + if (yych == 'T') + goto yy712; + if (yych != 't') + goto yy523; + yy712: + yych = *++p; + if (yych == 'I') + goto yy713; + if (yych != 'i') + goto yy523; + yy713: + yych = *++p; + if (yych == 'F') + goto yy714; + if (yych != 'f') + goto yy523; + yy714: + yych = *++p; + if (yych == 'Y') + goto yy533; + if (yych == 'y') + goto yy533; + goto yy523; + yy715: + yych = *++p; + if (yych == 'A') + goto yy716; + if (yych != 'a') + goto yy523; + yy716: + yych = *++p; + if (yych == 'M') + goto yy533; + if (yych == 'm') + goto yy533; + goto yy523; + yy717: + yych = *++p; + if (yych <= 'S') { + if (yych == 'M') + goto yy729; + if (yych <= 'R') + goto yy523; + goto yy728; + } else { + if (yych <= 'm') { + if (yych <= 'l') + goto yy523; + goto yy729; + } else { + if (yych == 's') + goto yy728; + goto yy523; + } + } + yy718: + yych = *++p; + if (yych == 'Y') + goto yy726; + if (yych == 'y') + goto yy726; + goto yy523; + yy719: + yych = *++p; + if (yych == 'I') + goto yy533; + if (yych == 'i') + goto yy533; + goto yy523; + yy720: + yych = *++p; + if (yych == 'S') + goto yy721; + if (yych != 's') + goto yy523; + yy721: + yych = *++p; + if (yych <= 'N') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'O') + goto yy722; + if (yych != 'o') + goto yy523; + } + yy722: + yych = *++p; + if (yych == 'U') + goto yy723; + if (yych != 'u') + goto yy523; + yy723: + yych = *++p; + if (yych == 'R') + goto yy724; + if (yych != 'r') + goto yy523; + yy724: + yych = *++p; + if (yych == 'C') + goto yy725; + if (yych != 'c') + goto yy523; + yy725: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy726: + yych = *++p; + if (yych == 'N') + goto yy727; + if (yych != 'n') + goto yy523; + yy727: + yych = *++p; + if (yych == 'C') + goto yy533; + if (yych == 'c') + goto yy533; + goto yy523; + yy728: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy729: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy730: + yych = *++p; + if (yych == 'Y') + goto yy750; + if (yych == 'y') + goto yy750; + goto yy523; + yy731: + yych = *++p; + if (yych <= 'O') { + if (yych == 'E') + goto yy747; + if (yych <= 'N') + goto yy523; + goto yy748; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy523; + goto yy747; + } else { + if (yych == 'o') + goto yy748; + goto yy523; + } + } + yy732: + yych = *++p; + if (yych == 'A') + goto yy742; + if (yych == 'a') + goto yy742; + goto yy523; + yy733: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') + goto yy735; + if (yych <= 'O') + goto yy523; + goto yy736; + } else { + if (yych <= 'l') { + if (yych <= 'k') + goto yy523; + goto yy735; + } else { + if (yych == 'p') + goto yy736; + goto yy523; + } + } + yy734: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy735: + yych = *++p; + if (yych == 'M') + goto yy533; + if (yych == 'm') + goto yy533; + goto yy523; + yy736: + yych = *++p; + if (yych == 'A') + goto yy737; + if (yych != 'a') + goto yy523; + yy737: + yych = *++p; + if (yych == 'R') + goto yy738; + if (yych != 'r') + goto yy523; + yy738: + yych = *++p; + if (yych == 'A') + goto yy739; + if (yych != 'a') + goto yy523; + yy739: + yych = *++p; + if (yych == 'Z') + goto yy740; + if (yych != 'z') + goto yy523; + yy740: + yych = *++p; + if (yych == 'Z') + goto yy741; + if (yych != 'z') + goto yy523; + yy741: + yych = *++p; + if (yych == 'I') + goto yy533; + if (yych == 'i') + goto yy533; + goto yy523; + yy742: + yych = *++p; + if (yych == 'T') + goto yy743; + if (yych != 't') + goto yy523; + yy743: + yych = *++p; + if (yych == 'F') + goto yy744; + if (yych != 'f') + goto yy523; + yy744: + yych = *++p; + if (yych == 'O') + goto yy745; + if (yych != 'o') + goto yy523; + yy745: + yych = *++p; + if (yych == 'R') + goto yy746; + if (yych != 'r') + goto yy523; + yy746: + yych = *++p; + if (yych == 'M') + goto yy533; + if (yych == 'm') + goto yy533; + goto yy523; + yy747: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy748: + yych = *++p; + if (yych == 'X') + goto yy749; + if (yych != 'x') + goto yy523; + yy749: + yych = *++p; + if (yych == 'Y') + goto yy533; + if (yych == 'y') + goto yy533; + goto yy523; + yy750: + yych = *++p; + if (yych == 'C') + goto yy533; + if (yych == 'c') + goto yy533; + goto yy523; + yy751: + yych = *++p; + if (yych == 'D') + goto yy533; + if (yych == 'd') + goto yy533; + goto yy523; + yy752: + yych = *++p; + if (yych == 'A') + goto yy753; + if (yych != 'a') + goto yy523; + yy753: + yych = *++p; + if (yych == 'Q') + goto yy754; + if (yych != 'q') + goto yy523; + yy754: + yych = *++p; + if (yych == 'U') + goto yy755; + if (yych != 'u') + goto yy523; + yy755: + yych = *++p; + if (yych == 'E') + goto yy756; + if (yych != 'e') + goto yy523; + yy756: + yych = *++p; + if (yych == 'L') + goto yy757; + if (yych != 'l') + goto yy523; + yy757: + yych = *++p; + if (yych == 'O') + goto yy758; + if (yych != 'o') + goto yy523; + yy758: + yych = *++p; + if (yych == 'C') + goto yy759; + if (yych != 'c') + goto yy523; + yy759: + yych = *++p; + if (yych == 'K') + goto yy760; + if (yych != 'k') + goto yy523; + yy760: + yych = *++p; + if (yych == 'T') + goto yy761; + if (yych != 't') + goto yy523; + yy761: + yych = *++p; + if (yych == 'O') + goto yy762; + if (yych != 'o') + goto yy523; + yy762: + yych = *++p; + if (yych == 'K') + goto yy763; + if (yych != 'k') + goto yy523; + yy763: + yych = *++p; + if (yych == 'E') + goto yy764; + if (yych != 'e') + goto yy523; + yy764: + yych = *++p; + if (yych == 'N') + goto yy533; + if (yych == 'n') + goto yy533; + goto yy523; + yy765: + yych = *++p; + if (yych == 'T') + goto yy772; + if (yych == 't') + goto yy772; + goto yy523; + yy766: + yych = *++p; + if (yych == 'T') + goto yy771; + if (yych == 't') + goto yy771; + goto yy523; + yy767: + yych = *++p; + if (yych <= 'G') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'H') + goto yy533; + if (yych == 'h') + goto yy533; + goto yy523; + } + yy768: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy769: + yych = *++p; + if (yych == 'W') + goto yy770; + if (yych != 'w') + goto yy523; + yy770: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy771: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy772: + yych = *++p; + if (yych == 'E') + goto yy773; + if (yych != 'e') + goto yy523; + yy773: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy774: + yych = *++p; + if (yych == 'N') + goto yy533; + if (yych == 'n') + goto yy533; + goto yy523; + yy775: + yych = *++p; + if (yych <= 'P') { + if (yych == 'M') + goto yy806; + if (yych <= 'O') + goto yy523; + goto yy805; + } else { + if (yych <= 'm') { + if (yych <= 'l') + goto yy523; + goto yy806; + } else { + if (yych == 'p') + goto yy805; + goto yy523; + } + } + yy776: + yych = *++p; + if (yych <= 'Q') { + if (yych <= '-') { + if (yych <= ',') + goto yy523; + goto yy798; + } else { + if (yych == 'N') + goto yy799; + goto yy523; + } + } else { + if (yych <= 'n') { + if (yych <= 'R') + goto yy797; + if (yych <= 'm') + goto yy523; + goto yy799; + } else { + if (yych == 'r') + goto yy797; + goto yy523; + } + } + yy777: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy778: + yych = *++p; + if (yych == 'S') + goto yy793; + if (yych == 's') + goto yy793; + goto yy523; + yy779: + yych = *++p; + switch (yych) { + case 'G': + case 'g': + goto yy784; + case 'I': + case 'i': + goto yy783; + case 'P': + case 'p': + goto yy785; + case 'R': + case 'r': + goto yy786; + default: + goto yy523; + } + yy780: + yych = *++p; + if (yych == 'Q') + goto yy782; + if (yych == 'q') + goto yy782; + goto yy523; + yy781: + yych = *++p; + if (yych == 'D') + goto yy533; + if (yych == 'd') + goto yy533; + goto yy523; + yy782: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy783: + yych = *++p; + if (yych == 'L') + goto yy791; + if (yych == 'l') + goto yy791; + goto yy523; + yy784: + yych = *++p; + if (yych == 'N') + goto yy789; + if (yych == 'n') + goto yy789; + goto yy523; + yy785: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy786: + yych = *++p; + if (yych == 'K') + goto yy787; + if (yych != 'k') + goto yy523; + yy787: + yych = *++p; + if (yych == 'E') + goto yy788; + if (yych != 'e') + goto yy523; + yy788: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy789: + yych = *++p; + if (yych == 'E') + goto yy790; + if (yych != 'e') + goto yy523; + yy790: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy791: + yych = *++p; + if (yych == 'T') + goto yy792; + if (yych != 't') + goto yy523; + yy792: + yych = *++p; + if (yych == 'O') + goto yy533; + if (yych == 'o') + goto yy533; + goto yy523; + yy793: + yych = *++p; + if (yych == 'S') + goto yy794; + if (yych != 's') + goto yy523; + yy794: + yych = *++p; + if (yych == 'A') + goto yy795; + if (yych != 'a') + goto yy523; + yy795: + yych = *++p; + if (yych == 'G') + goto yy796; + if (yych != 'g') + goto yy523; + yy796: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy797: + yych = *++p; + if (yych == 'P') + goto yy804; + if (yych == 'p') + goto yy804; + goto yy523; + yy798: + yych = *++p; + if (yych == 'H') + goto yy801; + if (yych == 'h') + goto yy801; + goto yy523; + yy799: + yych = *++p; + if (yych == 'I') + goto yy800; + if (yych != 'i') + goto yy523; + yy800: + yych = *++p; + if (yych == 'M') + goto yy533; + if (yych == 'm') + goto yy533; + goto yy523; + yy801: + yych = *++p; + if (yych == 'E') + goto yy802; + if (yych != 'e') + goto yy523; + yy802: + yych = *++p; + if (yych == 'L') + goto yy803; + if (yych != 'l') + goto yy523; + yy803: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy804: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + } + yy805: + yych = *++p; + if (yych == 'D') + goto yy809; + if (yych == 'd') + goto yy809; + goto yy523; + yy806: + yych = *++p; + if (yych == 'B') + goto yy807; + if (yych != 'b') + goto yy523; + yy807: + yych = *++p; + if (yych == 'L') + goto yy808; + if (yych != 'l') + goto yy523; + yy808: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy809: + yych = *++p; + if (yych == 'A') + goto yy810; + if (yych != 'a') + goto yy523; + yy810: + yych = *++p; + if (yych == 'T') + goto yy811; + if (yych != 't') + goto yy523; + yy811: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy812: + yych = *++p; + if (yych == 'A') + goto yy817; + if (yych == 'a') + goto yy817; + goto yy523; + yy813: + yych = *++p; + if (yych == 'S') + goto yy814; + if (yych != 's') + goto yy523; + yy814: + yych = *++p; + if (yych == 'T') + goto yy815; + if (yych != 't') + goto yy523; + yy815: + yych = *++p; + if (yych == 'F') + goto yy816; + if (yych != 'f') + goto yy523; + yy816: + yych = *++p; + if (yych == 'M') + goto yy533; + if (yych == 'm') + goto yy533; + goto yy523; + yy817: + yych = *++p; + if (yych == 'P') + goto yy818; + if (yych != 'p') + goto yy523; + yy818: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + } + yy819: + yych = *++p; + if (yych == 'M') + goto yy842; + if (yych == 'm') + goto yy842; + goto yy523; + yy820: + yych = *++p; + if (yych <= 'I') { + if (yych == 'C') + goto yy831; + if (yych <= 'H') + goto yy523; + goto yy830; + } else { + if (yych <= 'c') { + if (yych <= 'b') + goto yy523; + goto yy831; + } else { + if (yych == 'i') + goto yy830; + goto yy523; + } + } + yy821: + yych = *++p; + if (yych <= 'P') { + if (yych == 'N') + goto yy533; + if (yych <= 'O') + goto yy523; + goto yy533; + } else { + if (yych <= 'n') { + if (yych <= 'm') + goto yy523; + goto yy533; + } else { + if (yych == 'p') + goto yy533; + goto yy523; + } + } + yy822: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') + goto yy828; + if (yych <= 'N') + goto yy523; + goto yy829; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy523; + goto yy828; + } else { + if (yych == 'o') + goto yy829; + goto yy523; + } + } + yy823: + yych = *++p; + if (yych == 'F') + goto yy827; + if (yych == 'f') + goto yy827; + goto yy523; + yy824: + yych = *++p; + if (yych <= '@') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'A') + goto yy826; + if (yych == 'a') + goto yy826; + goto yy523; + } + yy825: + yych = *++p; + if (yych == 'X') + goto yy533; + if (yych == 'x') + goto yy533; + goto yy523; + yy826: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy827: + yych = *++p; + if (yych == 'O') + goto yy533; + if (yych == 'o') + goto yy533; + goto yy523; + yy828: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy829: + yych = *++p; + if (yych == 'N') + goto yy533; + if (yych == 'n') + goto yy533; + goto yy523; + yy830: + yych = *++p; + if (yych == 'S') + goto yy832; + if (yych == 's') + goto yy832; + goto yy523; + yy831: + yych = *++p; + if (yych <= ':') { + if (yych == '6') + goto yy533; + if (yych <= '9') + goto yy523; + goto yy534; + } else { + if (yych <= 'S') { + if (yych <= 'R') + goto yy523; + goto yy533; + } else { + if (yych == 's') + goto yy533; + goto yy523; + } + } + yy832: + yych = *++p; + if (yych == '.') + goto yy833; + if (yych == ':') + goto yy534; + goto yy523; + yy833: + yych = *++p; + if (yych <= 'X') { + if (yych <= 'K') { + if (yych == 'B') + goto yy836; + goto yy523; + } else { + if (yych <= 'L') + goto yy834; + if (yych <= 'W') + goto yy523; + goto yy835; + } + } else { + if (yych <= 'k') { + if (yych == 'b') + goto yy836; + goto yy523; + } else { + if (yych <= 'l') + goto yy834; + if (yych == 'x') + goto yy835; + goto yy523; + } + } + yy834: + yych = *++p; + if (yych == 'W') + goto yy841; + if (yych == 'w') + goto yy841; + goto yy523; + yy835: + yych = *++p; + if (yych == 'P') + goto yy839; + if (yych == 'p') + goto yy839; + goto yy523; + yy836: + yych = *++p; + if (yych == 'E') + goto yy837; + if (yych != 'e') + goto yy523; + yy837: + yych = *++p; + if (yych == 'E') + goto yy838; + if (yych != 'e') + goto yy523; + yy838: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy839: + yych = *++p; + if (yych == 'C') + goto yy840; + if (yych != 'c') + goto yy523; + yy840: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + } + yy841: + yych = *++p; + if (yych == 'Z') + goto yy533; + if (yych == 'z') + goto yy533; + goto yy523; + yy842: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy843: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy844: + yych = *++p; + if (yych == 'T') + goto yy847; + if (yych == 't') + goto yy847; + goto yy523; + yy845: + yych = *++p; + if (yych != '2') + goto yy523; + yych = *++p; + if (yych == '3') + goto yy533; + goto yy523; + yy847: + yych = *++p; + if (yych == 'P') + goto yy848; + if (yych != 'p') + goto yy523; + yy848: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + } + yy849: + yych = *++p; + if (yych == 'A') + goto yy865; + if (yych == 'a') + goto yy865; + goto yy523; + yy850: + yych = *++p; + if (yych <= 'Z') { + if (yych == 'T') + goto yy533; + if (yych <= 'Y') + goto yy523; + goto yy856; + } else { + if (yych <= 't') { + if (yych <= 's') + goto yy523; + goto yy533; + } else { + if (yych == 'z') + goto yy856; + goto yy523; + } + } + yy851: + yych = *++p; + if (yych <= 'O') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'P') + goto yy853; + if (yych == 'p') + goto yy853; + goto yy523; + } + yy852: + yych = *++p; + if (yych == 'O') + goto yy533; + if (yych == 'o') + goto yy533; + goto yy523; + yy853: + yych = *++p; + if (yych == 'H') + goto yy854; + if (yych != 'h') + goto yy523; + yy854: + yych = *++p; + if (yych == 'E') + goto yy855; + if (yych != 'e') + goto yy523; + yy855: + yych = *++p; + if (yych == 'R') + goto yy533; + if (yych == 'r') + goto yy533; + goto yy523; + yy856: + yych = *++p; + if (yych == 'M') + goto yy857; + if (yych != 'm') + goto yy523; + yy857: + yych = *++p; + if (yych == 'O') + goto yy858; + if (yych != 'o') + goto yy523; + yy858: + yych = *++p; + if (yych == 'P') + goto yy859; + if (yych != 'p') + goto yy523; + yy859: + yych = *++p; + if (yych == 'R') + goto yy860; + if (yych != 'r') + goto yy523; + yy860: + yych = *++p; + if (yych == 'O') + goto yy861; + if (yych != 'o') + goto yy523; + yy861: + yych = *++p; + if (yych == 'J') + goto yy862; + if (yych != 'j') + goto yy523; + yy862: + yych = *++p; + if (yych == 'E') + goto yy863; + if (yych != 'e') + goto yy523; + yy863: + yych = *++p; + if (yych == 'C') + goto yy864; + if (yych != 'c') + goto yy523; + yy864: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy865: + yych = *++p; + if (yych == 'L') + goto yy866; + if (yych != 'l') + goto yy523; + yy866: + yych = *++p; + if (yych == 'K') + goto yy533; + if (yych == 'k') + goto yy533; + goto yy523; + yy867: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'M') { + if (yych == 'L') + goto yy877; + goto yy523; + } else { + if (yych <= 'N') + goto yy878; + if (yych <= 'R') + goto yy523; + goto yy879; + } + } else { + if (yych <= 'm') { + if (yych == 'l') + goto yy877; + goto yy523; + } else { + if (yych <= 'n') + goto yy878; + if (yych == 's') + goto yy879; + goto yy523; + } + } + yy868: + yych = *++p; + if (yych == 'E') + goto yy876; + if (yych == 'e') + goto yy876; + goto yy523; + yy869: + yych = *++p; + if (yych == 'C') + goto yy871; + if (yych == 'c') + goto yy871; + goto yy523; + yy870: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy871: + yych = *++p; + if (yych == 'E') + goto yy872; + if (yych != 'e') + goto yy523; + yy872: + yych = *++p; + if (yych == 'T') + goto yy873; + if (yych != 't') + goto yy523; + yy873: + yych = *++p; + if (yych == 'I') + goto yy874; + if (yych != 'i') + goto yy523; + yy874: + yych = *++p; + if (yych == 'M') + goto yy875; + if (yych != 'm') + goto yy523; + yy875: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy876: + yych = *++p; + if (yych == 'D') + goto yy533; + if (yych == 'd') + goto yy533; + goto yy523; + yy877: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy878: + yych = *++p; + if (yych == 'G') + goto yy880; + if (yych == 'g') + goto yy880; + goto yy523; + yy879: + yych = *++p; + if (yych == 'H') + goto yy533; + if (yych == 'h') + goto yy533; + goto yy523; + yy880: + yych = *++p; + if (yych == 'E') + goto yy881; + if (yych != 'e') + goto yy523; + yy881: + yych = *++p; + if (yych == 'R') + goto yy533; + if (yych == 'r') + goto yy533; + goto yy523; + yy882: + yych = *++p; + if (yych == 'T') + goto yy900; + if (yych == 't') + goto yy900; + goto yy523; + yy883: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy884: + yych = *++p; + if (yych == 'M') + goto yy533; + if (yych == 'm') + goto yy533; + goto yy523; + yy885: + yych = *++p; + if (yych <= 'S') { + if (yych == 'P') + goto yy533; + if (yych <= 'R') + goto yy523; + goto yy533; + } else { + if (yych <= 'p') { + if (yych <= 'o') + goto yy523; + goto yy533; + } else { + if (yych == 's') + goto yy533; + goto yy523; + } + } + yy886: + yych = *++p; + if (yych == 'I') + goto yy894; + if (yych == 'i') + goto yy894; + goto yy523; + yy887: + yych = *++p; + if (yych == 'A') + goto yy893; + if (yych == 'a') + goto yy893; + goto yy523; + yy888: + yych = *++p; + if (yych == 'O') + goto yy891; + if (yych == 'o') + goto yy891; + goto yy523; + yy889: + yych = *++p; + if (yych == 'A') + goto yy890; + if (yych != 'a') + goto yy523; + yy890: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') + goto yy534; + goto yy523; + } else { + if (yych <= 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + } + yy891: + yych = *++p; + if (yych == 'U') + goto yy892; + if (yych != 'u') + goto yy523; + yy892: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy893: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy894: + yych = *++p; + if (yych == 'U') + goto yy895; + if (yych != 'u') + goto yy523; + yy895: + yych = *++p; + if (yych == 'M') + goto yy896; + if (yych != 'm') + goto yy523; + yy896: + yych = *++p; + if (yych == 'X') + goto yy897; + if (yych != 'x') + goto yy523; + yy897: + yych = *++p; + if (yych == 'T') + goto yy898; + if (yych != 't') + goto yy523; + yy898: + yych = *++p; + if (yych == 'R') + goto yy899; + if (yych != 'r') + goto yy523; + yy899: + yych = *++p; + if (yych == 'A') + goto yy533; + if (yych == 'a') + goto yy533; + goto yy523; + yy900: + yych = *++p; + if (yych == 'A') + goto yy901; + if (yych != 'a') + goto yy523; + yy901: + yych = *++p; + if (yych == 'C') + goto yy902; + if (yych != 'c') + goto yy523; + yy902: + yych = *++p; + if (yych == 'H') + goto yy903; + if (yych != 'h') + goto yy523; + yy903: + yych = *++p; + if (yych == 'M') + goto yy904; + if (yych != 'm') + goto yy523; + yy904: + yych = *++p; + if (yych == 'E') + goto yy905; + if (yych != 'e') + goto yy523; + yy905: + yych = *++p; + if (yych == 'N') + goto yy906; + if (yych != 'n') + goto yy523; + yy906: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy907: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy908: + yych = *++p; + if (yych <= 'V') { + if (yych == 'R') + goto yy533; + if (yych <= 'U') + goto yy523; + } else { + if (yych <= 'r') { + if (yych <= 'q') + goto yy523; + goto yy533; + } else { + if (yych != 'v') + goto yy523; + } + } + yych = *++p; + if (yych == 'A') + goto yy910; + if (yych != 'a') + goto yy523; + yy910: + yych = *++p; + if (yych == 'S') + goto yy911; + if (yych != 's') + goto yy523; + yy911: + yych = *++p; + if (yych == 'C') + goto yy912; + if (yych != 'c') + goto yy523; + yy912: + yych = *++p; + if (yych == 'R') + goto yy913; + if (yych != 'r') + goto yy523; + yy913: + yych = *++p; + if (yych == 'I') + goto yy914; + if (yych != 'i') + goto yy523; + yy914: + yych = *++p; + if (yych == 'P') + goto yy915; + if (yych != 'p') + goto yy523; + yy915: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy916: + yych = *++p; + if (yych == 'B') + goto yy533; + if (yych == 'b') + goto yy533; + goto yy523; + yy917: + yych = *++p; + if (yych == 'N') + goto yy533; + if (yych == 'n') + goto yy533; + goto yy523; + yy918: + yych = *++p; + if (yych == 'N') + goto yy925; + if (yych == 'n') + goto yy925; + goto yy523; + yy919: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy920: + yych = *++p; + if (yych == 'C') + goto yy924; + if (yych == 'c') + goto yy924; + goto yy523; + yy921: + yych = *++p; + if (yych <= 'V') { + if (yych == 'T') + goto yy923; + if (yych <= 'U') + goto yy523; + goto yy533; + } else { + if (yych <= 't') { + if (yych <= 's') + goto yy523; + goto yy923; + } else { + if (yych == 'v') + goto yy533; + goto yy523; + } + } + yy922: + yych = *++p; + if (yych == 'I') + goto yy533; + if (yych == 'i') + goto yy533; + goto yy523; + yy923: + yych = *++p; + if (yych == 'A') + goto yy533; + if (yych == 'a') + goto yy533; + goto yy523; + yy924: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy925: + yych = *++p; + if (yych == 'A') + goto yy926; + if (yych != 'a') + goto yy523; + yy926: + yych = *++p; + if (yych != '-') + goto yy523; + yych = *++p; + if (yych == 'P') + goto yy928; + if (yych != 'p') + goto yy523; + yy928: + yych = *++p; + if (yych == 'L') + goto yy929; + if (yych != 'l') + goto yy523; + yy929: + yych = *++p; + if (yych == 'A') + goto yy930; + if (yych != 'a') + goto yy523; + yy930: + yych = *++p; + if (yych == 'Y') + goto yy931; + if (yych != 'y') + goto yy523; + yy931: + yych = *++p; + if (yych <= 'S') { + if (yych == 'C') + goto yy932; + if (yych <= 'R') + goto yy523; + goto yy933; + } else { + if (yych <= 'c') { + if (yych <= 'b') + goto yy523; + } else { + if (yych == 's') + goto yy933; + goto yy523; + } + } + yy932: + yych = *++p; + if (yych == 'O') + goto yy938; + if (yych == 'o') + goto yy938; + goto yy523; + yy933: + yych = *++p; + if (yych == 'I') + goto yy934; + if (yych != 'i') + goto yy523; + yy934: + yych = *++p; + if (yych == 'N') + goto yy935; + if (yych != 'n') + goto yy523; + yy935: + yych = *++p; + if (yych == 'G') + goto yy936; + if (yych != 'g') + goto yy523; + yy936: + yych = *++p; + if (yych == 'L') + goto yy937; + if (yych != 'l') + goto yy523; + yy937: + yych = *++p; + if (yych == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + yy938: + yych = *++p; + if (yych == 'N') + goto yy939; + if (yych != 'n') + goto yy523; + yy939: + yych = *++p; + if (yych == 'T') + goto yy940; + if (yych != 't') + goto yy523; + yy940: + yych = *++p; + if (yych == 'A') + goto yy941; + if (yych != 'a') + goto yy523; + yy941: + yych = *++p; + if (yych == 'I') + goto yy942; + if (yych != 'i') + goto yy523; + yy942: + yych = *++p; + if (yych == 'N') + goto yy943; + if (yych != 'n') + goto yy523; + yy943: + yych = *++p; + if (yych == 'E') + goto yy944; + if (yych != 'e') + goto yy523; + yy944: + yych = *++p; + if (yych == 'R') + goto yy533; + if (yych == 'r') + goto yy533; + goto yy523; + yy945: + yych = *++p; + if (yych == 'S') + goto yy533; + if (yych == 's') + goto yy533; + goto yy523; + yy946: + yych = *++p; + if (yych <= 'N') { + if (yych <= 'A') { + if (yych <= '@') + goto yy523; + goto yy968; + } else { + if (yych <= 'L') + goto yy523; + if (yych <= 'M') + goto yy969; + goto yy970; + } + } else { + if (yych <= 'l') { + if (yych == 'a') + goto yy968; + goto yy523; + } else { + if (yych <= 'm') + goto yy969; + if (yych <= 'n') + goto yy970; + goto yy523; + } + } + yy947: + yych = *++p; + if (yych == 'R') + goto yy955; + if (yych == 'r') + goto yy955; + goto yy523; + yy948: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') + goto yy952; + if (yych <= 'O') + goto yy523; + goto yy533; + } else { + if (yych <= 'l') { + if (yych <= 'k') + goto yy523; + goto yy952; + } else { + if (yych == 'p') + goto yy533; + goto yy523; + } + } + yy949: + yych = *++p; + if (yych == 'I') + goto yy951; + if (yych == 'i') + goto yy951; + goto yy523; + yy950: + yych = *++p; + if (yych == 'D') + goto yy533; + if (yych == 'd') + goto yy533; + goto yy523; + yy951: + yych = *++p; + if (yych == 'D') + goto yy533; + if (yych == 'd') + goto yy533; + goto yy523; + yy952: + yych = *++p; + if (yych == 'L') + goto yy953; + if (yych != 'l') + goto yy523; + yy953: + yych = *++p; + if (yych == 'T') + goto yy954; + if (yych != 't') + goto yy523; + yy954: + yych = *++p; + if (yych == 'O') + goto yy533; + if (yych == 'o') + goto yy533; + goto yy523; + yy955: + yych = *++p; + if (yych == 'O') + goto yy956; + if (yych != 'o') + goto yy523; + yy956: + yych = *++p; + if (yych == 'M') + goto yy957; + if (yych != 'm') + goto yy523; + yy957: + yych = *++p; + if (yych == 'E') + goto yy958; + if (yych != 'e') + goto yy523; + yy958: + yych = *++p; + if (yych == '-') + goto yy959; + if (yych == ':') + goto yy534; + goto yy523; + yy959: + yych = *++p; + if (yych == 'E') + goto yy960; + if (yych != 'e') + goto yy523; + yy960: + yych = *++p; + if (yych == 'X') + goto yy961; + if (yych != 'x') + goto yy523; + yy961: + yych = *++p; + if (yych == 'T') + goto yy962; + if (yych != 't') + goto yy523; + yy962: + yych = *++p; + if (yych == 'E') + goto yy963; + if (yych != 'e') + goto yy523; + yy963: + yych = *++p; + if (yych == 'N') + goto yy964; + if (yych != 'n') + goto yy523; + yy964: + yych = *++p; + if (yych == 'S') + goto yy965; + if (yych != 's') + goto yy523; + yy965: + yych = *++p; + if (yych == 'I') + goto yy966; + if (yych != 'i') + goto yy523; + yy966: + yych = *++p; + if (yych == 'O') + goto yy967; + if (yych != 'o') + goto yy523; + yy967: + yych = *++p; + if (yych == 'N') + goto yy533; + if (yych == 'n') + goto yy533; + goto yy523; + yy968: + yych = *++p; + if (yych == 'P') + goto yy533; + if (yych == 'p') + goto yy533; + goto yy523; + yy969: + yych = *++p; + if (yych == '-') + goto yy974; + goto yy523; + yy970: + yych = *++p; + if (yych == 'T') + goto yy971; + if (yych != 't') + goto yy523; + yy971: + yych = *++p; + if (yych == 'E') + goto yy972; + if (yych != 'e') + goto yy523; + yy972: + yych = *++p; + if (yych == 'N') + goto yy973; + if (yych != 'n') + goto yy523; + yy973: + yych = *++p; + if (yych == 'T') + goto yy533; + if (yych == 't') + goto yy533; + goto yy523; + yy974: + yych = *++p; + if (yych == 'E') + goto yy975; + if (yych != 'e') + goto yy523; + yy975: + yych = *++p; + if (yych == 'V') + goto yy976; + if (yych != 'v') + goto yy523; + yy976: + yych = *++p; + if (yych == 'E') + goto yy977; + if (yych != 'e') + goto yy523; + yy977: + yych = *++p; + if (yych == 'N') + goto yy978; + if (yych != 'n') + goto yy523; + yy978: + yych = *++p; + if (yych == 'T') + goto yy979; + if (yych != 't') + goto yy523; + yy979: + yych = *++p; + if (yych == 'B') + goto yy980; + if (yych != 'b') + goto yy523; + yy980: + yych = *++p; + if (yych == 'R') + goto yy981; + if (yych != 'r') + goto yy523; + yy981: + yych = *++p; + if (yych == 'I') + goto yy982; + if (yych != 'i') + goto yy523; + yy982: + yych = *++p; + if (yych == 'T') + goto yy983; + if (yych != 't') + goto yy523; + yy983: + yych = *++p; + if (yych == 'E') + goto yy984; + if (yych != 'e') + goto yy523; + yy984: + yych = *++p; + if (yych != '-') + goto yy523; + yych = *++p; + if (yych == 'A') + goto yy986; + if (yych != 'a') + goto yy523; + yy986: + yych = *++p; + if (yych == 'T') + goto yy987; + if (yych != 't') + goto yy523; + yy987: + yych = *++p; + if (yych == 'T') + goto yy988; + if (yych != 't') + goto yy523; + yy988: + yych = *++p; + if (yych == 'E') + goto yy989; + if (yych != 'e') + goto yy523; + yy989: + yych = *++p; + if (yych == 'N') + goto yy990; + if (yych != 'n') + goto yy523; + yy990: + yych = *++p; + if (yych == 'D') + goto yy991; + if (yych != 'd') + goto yy523; + yy991: + yych = *++p; + if (yych == 'E') + goto yy992; + if (yych != 'e') + goto yy523; + yy992: + ++p; + if ((yych = *p) == 'E') + goto yy533; + if (yych == 'e') + goto yy533; + goto yy523; + } } // Try to match email autolink after first <, returning num of chars matched. -bufsize_t _scan_autolink_email(const unsigned char *p) -{ +bufsize_t _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 = *(marker = p); - if (yych <= '?') { - if (yych <= ')') { - if (yych <= ' ') { - if (yych != '\n') goto yy997; - } else { - if (yych == '"') goto yy997; - if (yych <= '\'') goto yy996; - goto yy997; - } - } else { - if (yych <= '9') { - if (yych == ',') goto yy997; - goto yy996; - } else { - if (yych == '=') goto yy996; - if (yych <= '>') goto yy997; - goto yy996; - } - } - } else { - if (yych <= 0xDF) { - if (yych <= ']') { - if (yych <= '@') goto yy997; - if (yych <= 'Z') goto yy996; - goto yy997; - } else { - if (yych <= '~') goto yy996; - if (yych <= 0x7F) goto yy997; - if (yych >= 0xC2) goto yy998; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1000; - if (yych == 0xED) goto yy1005; - goto yy1001; - } else { - if (yych <= 0xF0) goto yy1002; - if (yych <= 0xF3) goto yy1003; - if (yych <= 0xF4) goto yy1004; - } - } - } -yy995: - { return 0; } -yy996: - yych = *(marker = ++p); - if (yych <= ',') { - if (yych <= '"') { - if (yych == '!') goto yy1008; - goto yy995; - } else { - if (yych <= '\'') goto yy1008; - if (yych <= ')') goto yy995; - if (yych <= '+') goto yy1008; - goto yy995; - } - } else { - if (yych <= '>') { - if (yych <= '9') goto yy1008; - if (yych == '=') goto yy1008; - goto yy995; - } else { - if (yych <= 'Z') goto yy1008; - if (yych <= ']') goto yy995; - if (yych <= '~') goto yy1008; - goto yy995; - } - } -yy997: - yych = *++p; - goto yy995; -yy998: - yych = *++p; - if (yych <= 0x7F) goto yy999; - if (yych <= 0xBF) goto yy997; -yy999: - p = marker; - goto yy995; -yy1000: - yych = *++p; - if (yych <= 0x9F) goto yy999; - if (yych <= 0xBF) goto yy998; - goto yy999; -yy1001: - yych = *++p; - if (yych <= 0x7F) goto yy999; - if (yych <= 0xBF) goto yy998; - goto yy999; -yy1002: - yych = *++p; - if (yych <= 0x8F) goto yy999; - if (yych <= 0xBF) goto yy1001; - goto yy999; -yy1003: - yych = *++p; - if (yych <= 0x7F) goto yy999; - if (yych <= 0xBF) goto yy1001; - goto yy999; -yy1004: - yych = *++p; - if (yych <= 0x7F) goto yy999; - if (yych <= 0x8F) goto yy1001; - goto yy999; -yy1005: - yych = *++p; - if (yych <= 0x7F) goto yy999; - if (yych <= 0x9F) goto yy998; - goto yy999; -yy1006: - yych = *++p; - if (yych <= '@') { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1009; - goto yy999; - } else { - if (yych <= 'Z') goto yy1009; - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1009; - goto yy999; - } -yy1007: - ++p; - yych = *p; -yy1008: - if (yybm[0+yych] & 128) { - goto yy1007; - } - if (yych <= '>') goto yy999; - if (yych <= '@') goto yy1006; - goto yy999; -yy1009: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1011; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1011; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1011; - goto yy999; - } - } - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1139; - if (yych <= '/') goto yy999; - goto yy1140; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1140; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1140; - goto yy999; - } - } -yy1011: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych <= '-') goto yy1139; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1140; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1140; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1140; - goto yy999; - } - } -yy1012: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1015; - goto yy999; - } else { - if (yych <= 'Z') goto yy1015; - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1015; - goto yy999; - } -yy1013: - ++p; - { return (bufsize_t)(p - start); } -yy1015: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1017; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1017; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1017; - goto yy999; - } - } - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1018; - if (yych <= '/') goto yy999; - goto yy1019; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1019; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1019; - goto yy999; - } - } -yy1017: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1019; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1019; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1019; - goto yy999; - } - } -yy1018: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1020; - if (yych <= '/') goto yy999; - goto yy1021; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1021; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1021; - goto yy999; - } - } -yy1019: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1021; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1021; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1021; - goto yy999; - } - } -yy1020: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1022; - if (yych <= '/') goto yy999; - goto yy1023; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1023; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1023; - goto yy999; - } - } -yy1021: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1023; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1023; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1023; - goto yy999; - } - } -yy1022: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1024; - if (yych <= '/') goto yy999; - goto yy1025; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1025; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1025; - goto yy999; - } - } -yy1023: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1025; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1025; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1025; - goto yy999; - } - } -yy1024: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1026; - if (yych <= '/') goto yy999; - goto yy1027; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1027; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1027; - goto yy999; - } - } -yy1025: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1027; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1027; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1027; - goto yy999; - } - } -yy1026: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1028; - if (yych <= '/') goto yy999; - goto yy1029; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1029; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1029; - goto yy999; - } - } -yy1027: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1029; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1029; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1029; - goto yy999; - } - } -yy1028: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1030; - if (yych <= '/') goto yy999; - goto yy1031; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1031; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1031; - goto yy999; - } - } -yy1029: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1031; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1031; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1031; - goto yy999; - } - } -yy1030: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1032; - if (yych <= '/') goto yy999; - goto yy1033; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1033; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1033; - goto yy999; - } - } -yy1031: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1033; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1033; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1033; - goto yy999; - } - } -yy1032: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1034; - if (yych <= '/') goto yy999; - goto yy1035; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1035; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1035; - goto yy999; - } - } -yy1033: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1035; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1035; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1035; - goto yy999; - } - } -yy1034: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1036; - if (yych <= '/') goto yy999; - goto yy1037; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1037; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1037; - goto yy999; - } - } -yy1035: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1037; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1037; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1037; - goto yy999; - } - } -yy1036: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1038; - if (yych <= '/') goto yy999; - goto yy1039; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1039; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1039; - goto yy999; - } - } -yy1037: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1039; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1039; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1039; - goto yy999; - } - } -yy1038: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1040; - if (yych <= '/') goto yy999; - goto yy1041; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1041; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1041; - goto yy999; - } - } -yy1039: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1041; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1041; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1041; - goto yy999; - } - } -yy1040: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1042; - if (yych <= '/') goto yy999; - goto yy1043; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1043; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1043; - goto yy999; - } - } -yy1041: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1043; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1043; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1043; - goto yy999; - } - } -yy1042: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1044; - if (yych <= '/') goto yy999; - goto yy1045; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1045; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1045; - goto yy999; - } - } -yy1043: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1045; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1045; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1045; - goto yy999; - } - } -yy1044: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1046; - if (yych <= '/') goto yy999; - goto yy1047; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1047; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1047; - goto yy999; - } - } -yy1045: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1047; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1047; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1047; - goto yy999; - } - } -yy1046: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1048; - if (yych <= '/') goto yy999; - goto yy1049; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1049; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1049; - goto yy999; - } - } -yy1047: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1049; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1049; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1049; - goto yy999; - } - } -yy1048: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1050; - if (yych <= '/') goto yy999; - goto yy1051; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1051; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1051; - goto yy999; - } - } -yy1049: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1051; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1051; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1051; - goto yy999; - } - } -yy1050: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1052; - if (yych <= '/') goto yy999; - goto yy1053; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1053; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1053; - goto yy999; - } - } -yy1051: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1053; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1053; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1053; - goto yy999; - } - } -yy1052: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1054; - if (yych <= '/') goto yy999; - goto yy1055; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1055; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1055; - goto yy999; - } - } -yy1053: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1055; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1055; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1055; - goto yy999; - } - } -yy1054: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1056; - if (yych <= '/') goto yy999; - goto yy1057; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1057; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1057; - goto yy999; - } - } -yy1055: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1057; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1057; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1057; - goto yy999; - } - } -yy1056: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1058; - if (yych <= '/') goto yy999; - goto yy1059; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1059; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1059; - goto yy999; - } - } -yy1057: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1059; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1059; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1059; - goto yy999; - } - } -yy1058: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1060; - if (yych <= '/') goto yy999; - goto yy1061; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1061; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1061; - goto yy999; - } - } -yy1059: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1061; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1061; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1061; - goto yy999; - } - } -yy1060: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1062; - if (yych <= '/') goto yy999; - goto yy1063; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1063; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1063; - goto yy999; - } - } -yy1061: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1063; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1063; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1063; - goto yy999; - } - } -yy1062: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1064; - if (yych <= '/') goto yy999; - goto yy1065; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1065; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1065; - goto yy999; - } - } -yy1063: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1065; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1065; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1065; - goto yy999; - } - } -yy1064: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1066; - if (yych <= '/') goto yy999; - goto yy1067; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1067; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1067; - goto yy999; - } - } -yy1065: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1067; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1067; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1067; - goto yy999; - } - } -yy1066: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1068; - if (yych <= '/') goto yy999; - goto yy1069; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1069; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1069; - goto yy999; - } - } -yy1067: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1069; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1069; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1069; - goto yy999; - } - } -yy1068: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1070; - if (yych <= '/') goto yy999; - goto yy1071; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1071; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1071; - goto yy999; - } - } -yy1069: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1071; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1071; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1071; - goto yy999; - } - } -yy1070: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1072; - if (yych <= '/') goto yy999; - goto yy1073; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1073; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1073; - goto yy999; - } - } -yy1071: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1073; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1073; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1073; - goto yy999; - } - } -yy1072: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1074; - if (yych <= '/') goto yy999; - goto yy1075; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1075; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1075; - goto yy999; - } - } -yy1073: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1075; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1075; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1075; - goto yy999; - } - } -yy1074: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1076; - if (yych <= '/') goto yy999; - goto yy1077; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1077; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1077; - goto yy999; - } - } -yy1075: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1077; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1077; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1077; - goto yy999; - } - } -yy1076: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1078; - if (yych <= '/') goto yy999; - goto yy1079; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1079; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1079; - goto yy999; - } - } -yy1077: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1079; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1079; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1079; - goto yy999; - } - } -yy1078: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1080; - if (yych <= '/') goto yy999; - goto yy1081; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1081; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1081; - goto yy999; - } - } -yy1079: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1081; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1081; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1081; - goto yy999; - } - } -yy1080: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1082; - if (yych <= '/') goto yy999; - goto yy1083; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1083; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1083; - goto yy999; - } - } -yy1081: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1083; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1083; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1083; - goto yy999; - } - } -yy1082: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1084; - if (yych <= '/') goto yy999; - goto yy1085; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1085; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1085; - goto yy999; - } - } -yy1083: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1085; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1085; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1085; - goto yy999; - } - } -yy1084: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1086; - if (yych <= '/') goto yy999; - goto yy1087; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1087; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1087; - goto yy999; - } - } -yy1085: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1087; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1087; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1087; - goto yy999; - } - } -yy1086: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1088; - if (yych <= '/') goto yy999; - goto yy1089; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1089; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1089; - goto yy999; - } - } -yy1087: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1089; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1089; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1089; - goto yy999; - } - } -yy1088: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1090; - if (yych <= '/') goto yy999; - goto yy1091; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1091; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1091; - goto yy999; - } - } -yy1089: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1091; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1091; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1091; - goto yy999; - } - } -yy1090: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1092; - if (yych <= '/') goto yy999; - goto yy1093; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1093; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1093; - goto yy999; - } - } -yy1091: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1093; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1093; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1093; - goto yy999; - } - } -yy1092: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1094; - if (yych <= '/') goto yy999; - goto yy1095; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1095; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1095; - goto yy999; - } - } -yy1093: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1095; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1095; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1095; - goto yy999; - } - } -yy1094: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1096; - if (yych <= '/') goto yy999; - goto yy1097; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1097; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1097; - goto yy999; - } - } -yy1095: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1097; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1097; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1097; - goto yy999; - } - } -yy1096: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1098; - if (yych <= '/') goto yy999; - goto yy1099; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1099; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1099; - goto yy999; - } - } -yy1097: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1099; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1099; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1099; - goto yy999; - } - } -yy1098: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1100; - if (yych <= '/') goto yy999; - goto yy1101; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1101; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1101; - goto yy999; - } - } -yy1099: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1101; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1101; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1101; - goto yy999; - } - } -yy1100: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1102; - if (yych <= '/') goto yy999; - goto yy1103; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1103; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1103; - goto yy999; - } - } -yy1101: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1103; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1103; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1103; - goto yy999; - } - } -yy1102: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1104; - if (yych <= '/') goto yy999; - goto yy1105; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1105; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1105; - goto yy999; - } - } -yy1103: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1105; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1105; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1105; - goto yy999; - } - } -yy1104: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1106; - if (yych <= '/') goto yy999; - goto yy1107; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1107; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1107; - goto yy999; - } - } -yy1105: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1107; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1107; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1107; - goto yy999; - } - } -yy1106: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1108; - if (yych <= '/') goto yy999; - goto yy1109; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1109; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1109; - goto yy999; - } - } -yy1107: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1109; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1109; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1109; - goto yy999; - } - } -yy1108: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1110; - if (yych <= '/') goto yy999; - goto yy1111; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1111; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1111; - goto yy999; - } - } -yy1109: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1111; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1111; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1111; - goto yy999; - } - } -yy1110: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1112; - if (yych <= '/') goto yy999; - goto yy1113; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1113; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1113; - goto yy999; - } - } -yy1111: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1113; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1113; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1113; - goto yy999; - } - } -yy1112: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1114; - if (yych <= '/') goto yy999; - goto yy1115; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1115; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1115; - goto yy999; - } - } -yy1113: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1115; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1115; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1115; - goto yy999; - } - } -yy1114: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1116; - if (yych <= '/') goto yy999; - goto yy1117; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1117; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1117; - goto yy999; - } - } -yy1115: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1117; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1117; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1117; - goto yy999; - } - } -yy1116: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1118; - if (yych <= '/') goto yy999; - goto yy1119; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1119; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1119; - goto yy999; - } - } -yy1117: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1119; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1119; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1119; - goto yy999; - } - } -yy1118: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1120; - if (yych <= '/') goto yy999; - goto yy1121; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1121; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1121; - goto yy999; - } - } -yy1119: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1121; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1121; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1121; - goto yy999; - } - } -yy1120: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1122; - if (yych <= '/') goto yy999; - goto yy1123; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1123; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1123; - goto yy999; - } - } -yy1121: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1123; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1123; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1123; - goto yy999; - } - } -yy1122: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1124; - if (yych <= '/') goto yy999; - goto yy1125; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1125; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1125; - goto yy999; - } - } -yy1123: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1125; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1125; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1125; - goto yy999; - } - } -yy1124: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1126; - if (yych <= '/') goto yy999; - goto yy1127; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1127; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1127; - goto yy999; - } - } -yy1125: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1127; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1127; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1127; - goto yy999; - } - } -yy1126: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1128; - if (yych <= '/') goto yy999; - goto yy1129; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1129; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1129; - goto yy999; - } - } -yy1127: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1129; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1129; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1129; - goto yy999; - } - } -yy1128: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1130; - if (yych <= '/') goto yy999; - goto yy1131; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1131; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1131; - goto yy999; - } - } -yy1129: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1131; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1131; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1131; - goto yy999; - } - } -yy1130: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1132; - if (yych <= '/') goto yy999; - goto yy1133; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1133; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1133; - goto yy999; - } - } -yy1131: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1133; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1133; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1133; - goto yy999; - } - } -yy1132: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1134; - if (yych <= '/') goto yy999; - goto yy1135; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1135; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1135; - goto yy999; - } - } -yy1133: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1135; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1135; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1135; - goto yy999; - } - } -yy1134: - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') goto yy1136; - if (yych <= '/') goto yy999; - goto yy1137; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1137; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1137; - goto yy999; - } - } -yy1135: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1137; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1137; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1137; - goto yy999; - } - } -yy1136: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1138; - goto yy999; - } else { - if (yych <= 'Z') goto yy1138; - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1138; - goto yy999; - } -yy1137: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= '-') goto yy999; - goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych >= ':') goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - } else { - if (yych <= '`') goto yy999; - if (yych >= '{') goto yy999; - } - } -yy1138: - ++p; - yych = *p; - if (yych == '.') goto yy1012; - if (yych == '>') goto yy1013; - goto yy999; -yy1139: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1141; - if (yych <= '/') goto yy999; - goto yy1142; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1142; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1142; - goto yy999; - } - } -yy1140: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1142; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1142; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1142; - goto yy999; - } - } -yy1141: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1143; - if (yych <= '/') goto yy999; - goto yy1144; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1144; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1144; - goto yy999; - } - } -yy1142: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1144; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1144; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1144; - goto yy999; - } - } -yy1143: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1145; - if (yych <= '/') goto yy999; - goto yy1146; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1146; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1146; - goto yy999; - } - } -yy1144: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1146; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1146; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1146; - goto yy999; - } - } -yy1145: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1147; - if (yych <= '/') goto yy999; - goto yy1148; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1148; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1148; - goto yy999; - } - } -yy1146: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1148; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1148; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1148; - goto yy999; - } - } -yy1147: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1149; - if (yych <= '/') goto yy999; - goto yy1150; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1150; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1150; - goto yy999; - } - } -yy1148: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1150; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1150; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1150; - goto yy999; - } - } -yy1149: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1151; - if (yych <= '/') goto yy999; - goto yy1152; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1152; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1152; - goto yy999; - } - } -yy1150: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1152; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1152; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1152; - goto yy999; - } - } -yy1151: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1153; - if (yych <= '/') goto yy999; - goto yy1154; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1154; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1154; - goto yy999; - } - } -yy1152: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1154; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1154; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1154; - goto yy999; - } - } -yy1153: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1155; - if (yych <= '/') goto yy999; - goto yy1156; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1156; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1156; - goto yy999; - } - } -yy1154: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1156; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1156; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1156; - goto yy999; - } - } -yy1155: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1157; - if (yych <= '/') goto yy999; - goto yy1158; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1158; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1158; - goto yy999; - } - } -yy1156: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1158; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1158; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1158; - goto yy999; - } - } -yy1157: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1159; - if (yych <= '/') goto yy999; - goto yy1160; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1160; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1160; - goto yy999; - } - } -yy1158: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1160; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1160; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1160; - goto yy999; - } - } -yy1159: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1161; - if (yych <= '/') goto yy999; - goto yy1162; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1162; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1162; - goto yy999; - } - } -yy1160: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1162; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1162; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1162; - goto yy999; - } - } -yy1161: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1163; - if (yych <= '/') goto yy999; - goto yy1164; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1164; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1164; - goto yy999; - } - } -yy1162: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1164; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1164; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1164; - goto yy999; - } - } -yy1163: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1165; - if (yych <= '/') goto yy999; - goto yy1166; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1166; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1166; - goto yy999; - } - } -yy1164: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1166; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1166; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1166; - goto yy999; - } - } -yy1165: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1167; - if (yych <= '/') goto yy999; - goto yy1168; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1168; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1168; - goto yy999; - } - } -yy1166: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1168; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1168; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1168; - goto yy999; - } - } -yy1167: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1169; - if (yych <= '/') goto yy999; - goto yy1170; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1170; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1170; - goto yy999; - } - } -yy1168: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1170; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1170; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1170; - goto yy999; - } - } -yy1169: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1171; - if (yych <= '/') goto yy999; - goto yy1172; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1172; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1172; - goto yy999; - } - } -yy1170: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1172; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1172; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1172; - goto yy999; - } - } -yy1171: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1173; - if (yych <= '/') goto yy999; - goto yy1174; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1174; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1174; - goto yy999; - } - } -yy1172: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1174; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1174; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1174; - goto yy999; - } - } -yy1173: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1175; - if (yych <= '/') goto yy999; - goto yy1176; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1176; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1176; - goto yy999; - } - } -yy1174: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1176; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1176; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1176; - goto yy999; - } - } -yy1175: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1177; - if (yych <= '/') goto yy999; - goto yy1178; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1178; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1178; - goto yy999; - } - } -yy1176: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1178; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1178; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1178; - goto yy999; - } - } -yy1177: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1179; - if (yych <= '/') goto yy999; - goto yy1180; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1180; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1180; - goto yy999; - } - } -yy1178: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1180; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1180; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1180; - goto yy999; - } - } -yy1179: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1181; - if (yych <= '/') goto yy999; - goto yy1182; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1182; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1182; - goto yy999; - } - } -yy1180: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1182; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1182; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1182; - goto yy999; - } - } -yy1181: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1183; - if (yych <= '/') goto yy999; - goto yy1184; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1184; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1184; - goto yy999; - } - } -yy1182: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1184; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1184; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1184; - goto yy999; - } - } -yy1183: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1185; - if (yych <= '/') goto yy999; - goto yy1186; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1186; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1186; - goto yy999; - } - } -yy1184: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1186; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1186; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1186; - goto yy999; - } - } -yy1185: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1187; - if (yych <= '/') goto yy999; - goto yy1188; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1188; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1188; - goto yy999; - } - } -yy1186: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1188; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1188; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1188; - goto yy999; - } - } -yy1187: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1189; - if (yych <= '/') goto yy999; - goto yy1190; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1190; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1190; - goto yy999; - } - } -yy1188: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1190; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1190; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1190; - goto yy999; - } - } -yy1189: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1191; - if (yych <= '/') goto yy999; - goto yy1192; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1192; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1192; - goto yy999; - } - } -yy1190: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1192; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1192; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1192; - goto yy999; - } - } -yy1191: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1193; - if (yych <= '/') goto yy999; - goto yy1194; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1194; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1194; - goto yy999; - } - } -yy1192: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1194; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1194; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1194; - goto yy999; - } - } -yy1193: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1195; - if (yych <= '/') goto yy999; - goto yy1196; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1196; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1196; - goto yy999; - } - } -yy1194: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1196; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1196; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1196; - goto yy999; - } - } -yy1195: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1197; - if (yych <= '/') goto yy999; - goto yy1198; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1198; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1198; - goto yy999; - } - } -yy1196: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1198; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1198; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1198; - goto yy999; - } - } -yy1197: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1199; - if (yych <= '/') goto yy999; - goto yy1200; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1200; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1200; - goto yy999; - } - } -yy1198: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1200; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1200; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1200; - goto yy999; - } - } -yy1199: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1201; - if (yych <= '/') goto yy999; - goto yy1202; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1202; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1202; - goto yy999; - } - } -yy1200: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1202; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1202; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1202; - goto yy999; - } - } -yy1201: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1203; - if (yych <= '/') goto yy999; - goto yy1204; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1204; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1204; - goto yy999; - } - } -yy1202: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1204; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1204; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1204; - goto yy999; - } - } -yy1203: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1205; - if (yych <= '/') goto yy999; - goto yy1206; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1206; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1206; - goto yy999; - } - } -yy1204: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1206; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1206; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1206; - goto yy999; - } - } -yy1205: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1207; - if (yych <= '/') goto yy999; - goto yy1208; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1208; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1208; - goto yy999; - } - } -yy1206: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1208; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1208; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1208; - goto yy999; - } - } -yy1207: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1209; - if (yych <= '/') goto yy999; - goto yy1210; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1210; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1210; - goto yy999; - } - } -yy1208: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1210; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1210; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1210; - goto yy999; - } - } -yy1209: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1211; - if (yych <= '/') goto yy999; - goto yy1212; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1212; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1212; - goto yy999; - } - } -yy1210: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1212; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1212; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1212; - goto yy999; - } - } -yy1211: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1213; - if (yych <= '/') goto yy999; - goto yy1214; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1214; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1214; - goto yy999; - } - } -yy1212: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1214; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1214; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1214; - goto yy999; - } - } -yy1213: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1215; - if (yych <= '/') goto yy999; - goto yy1216; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1216; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1216; - goto yy999; - } - } -yy1214: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1216; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1216; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1216; - goto yy999; - } - } -yy1215: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1217; - if (yych <= '/') goto yy999; - goto yy1218; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1218; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1218; - goto yy999; - } - } -yy1216: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1218; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1218; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1218; - goto yy999; - } - } -yy1217: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1219; - if (yych <= '/') goto yy999; - goto yy1220; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1220; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1220; - goto yy999; - } - } -yy1218: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1220; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1220; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1220; - goto yy999; - } - } -yy1219: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1221; - if (yych <= '/') goto yy999; - goto yy1222; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1222; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1222; - goto yy999; - } - } -yy1220: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1222; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1222; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1222; - goto yy999; - } - } -yy1221: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1223; - if (yych <= '/') goto yy999; - goto yy1224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1224; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1224; - goto yy999; - } - } -yy1222: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1224; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1224; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1224; - goto yy999; - } - } -yy1223: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1225; - if (yych <= '/') goto yy999; - goto yy1226; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1226; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1226; - goto yy999; - } - } -yy1224: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1226; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1226; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1226; - goto yy999; - } - } -yy1225: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1227; - if (yych <= '/') goto yy999; - goto yy1228; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1228; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1228; - goto yy999; - } - } -yy1226: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1228; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1228; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1228; - goto yy999; - } - } -yy1227: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1229; - if (yych <= '/') goto yy999; - goto yy1230; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1230; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1230; - goto yy999; - } - } -yy1228: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1230; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1230; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1230; - goto yy999; - } - } -yy1229: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1231; - if (yych <= '/') goto yy999; - goto yy1232; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1232; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1232; - goto yy999; - } - } -yy1230: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1232; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1232; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1232; - goto yy999; - } - } -yy1231: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1233; - if (yych <= '/') goto yy999; - goto yy1234; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1234; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1234; - goto yy999; - } - } -yy1232: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1234; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1234; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1234; - goto yy999; - } - } -yy1233: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1235; - if (yych <= '/') goto yy999; - goto yy1236; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1236; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1236; - goto yy999; - } - } -yy1234: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1236; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1236; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1236; - goto yy999; - } - } -yy1235: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1237; - if (yych <= '/') goto yy999; - goto yy1238; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1238; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1238; - goto yy999; - } - } -yy1236: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1238; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1238; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1238; - goto yy999; - } - } -yy1237: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1239; - if (yych <= '/') goto yy999; - goto yy1240; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1240; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1240; - goto yy999; - } - } -yy1238: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1240; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1240; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1240; - goto yy999; - } - } -yy1239: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1241; - if (yych <= '/') goto yy999; - goto yy1242; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1242; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1242; - goto yy999; - } - } -yy1240: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1242; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1242; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1242; - goto yy999; - } - } -yy1241: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1243; - if (yych <= '/') goto yy999; - goto yy1244; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1244; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1244; - goto yy999; - } - } -yy1242: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1244; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1244; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1244; - goto yy999; - } - } -yy1243: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1245; - if (yych <= '/') goto yy999; - goto yy1246; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1246; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1246; - goto yy999; - } - } -yy1244: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1246; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1246; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1246; - goto yy999; - } - } -yy1245: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1247; - if (yych <= '/') goto yy999; - goto yy1248; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1248; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1248; - goto yy999; - } - } -yy1246: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1248; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1248; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1248; - goto yy999; - } - } -yy1247: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1249; - if (yych <= '/') goto yy999; - goto yy1250; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1250; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1250; - goto yy999; - } - } -yy1248: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1250; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1250; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1250; - goto yy999; - } - } -yy1249: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1251; - if (yych <= '/') goto yy999; - goto yy1252; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1252; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1252; - goto yy999; - } - } -yy1250: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1252; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1252; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1252; - goto yy999; - } - } -yy1251: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1253; - if (yych <= '/') goto yy999; - goto yy1254; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1254; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1254; - goto yy999; - } - } -yy1252: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1254; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1254; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1254; - goto yy999; - } - } -yy1253: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1255; - if (yych <= '/') goto yy999; - goto yy1256; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1256; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1256; - goto yy999; - } - } -yy1254: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1256; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1256; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1256; - goto yy999; - } - } -yy1255: - yych = *++p; - if (yych <= '9') { - if (yych == '-') goto yy1257; - if (yych <= '/') goto yy999; - goto yy1258; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy999; - goto yy1258; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1258; - goto yy999; - } - } -yy1256: - yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') goto yy999; - if (yych >= '.') goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1258; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1258; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1258; - goto yy999; - } - } -yy1257: - yych = *++p; - if (yych <= '@') { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1138; - goto yy999; - } else { - if (yych <= 'Z') goto yy1138; - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1138; - goto yy999; - } -yy1258: - ++p; - if ((yych = *p) <= '=') { - if (yych <= '.') { - if (yych <= '-') goto yy999; - goto yy1012; - } else { - if (yych <= '/') goto yy999; - if (yych <= '9') goto yy1138; - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1013; - if (yych <= '@') goto yy999; - goto yy1138; - } else { - if (yych <= '`') goto yy999; - if (yych <= 'z') goto yy1138; - goto yy999; - } - } -} - + { + 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 = *(marker = p); + if (yych <= '?') { + if (yych <= ')') { + if (yych <= ' ') { + if (yych != '\n') + goto yy997; + } else { + if (yych == '"') + goto yy997; + if (yych <= '\'') + goto yy996; + goto yy997; + } + } else { + if (yych <= '9') { + if (yych == ',') + goto yy997; + goto yy996; + } else { + if (yych == '=') + goto yy996; + if (yych <= '>') + goto yy997; + goto yy996; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= ']') { + if (yych <= '@') + goto yy997; + if (yych <= 'Z') + goto yy996; + goto yy997; + } else { + if (yych <= '~') + goto yy996; + if (yych <= 0x7F) + goto yy997; + if (yych >= 0xC2) + goto yy998; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1000; + if (yych == 0xED) + goto yy1005; + goto yy1001; + } else { + if (yych <= 0xF0) + goto yy1002; + if (yych <= 0xF3) + goto yy1003; + if (yych <= 0xF4) + goto yy1004; + } + } + } + yy995 : { return 0; } + yy996: + yych = *(marker = ++p); + if (yych <= ',') { + if (yych <= '"') { + if (yych == '!') + goto yy1008; + goto yy995; + } else { + if (yych <= '\'') + goto yy1008; + if (yych <= ')') + goto yy995; + if (yych <= '+') + goto yy1008; + goto yy995; + } + } else { + if (yych <= '>') { + if (yych <= '9') + goto yy1008; + if (yych == '=') + goto yy1008; + goto yy995; + } else { + if (yych <= 'Z') + goto yy1008; + if (yych <= ']') + goto yy995; + if (yych <= '~') + goto yy1008; + goto yy995; + } + } + yy997: + yych = *++p; + goto yy995; + yy998: + yych = *++p; + if (yych <= 0x7F) + goto yy999; + if (yych <= 0xBF) + goto yy997; + yy999: + p = marker; + goto yy995; + yy1000: + yych = *++p; + if (yych <= 0x9F) + goto yy999; + if (yych <= 0xBF) + goto yy998; + goto yy999; + yy1001: + yych = *++p; + if (yych <= 0x7F) + goto yy999; + if (yych <= 0xBF) + goto yy998; + goto yy999; + yy1002: + yych = *++p; + if (yych <= 0x8F) + goto yy999; + if (yych <= 0xBF) + goto yy1001; + goto yy999; + yy1003: + yych = *++p; + if (yych <= 0x7F) + goto yy999; + if (yych <= 0xBF) + goto yy1001; + goto yy999; + yy1004: + yych = *++p; + if (yych <= 0x7F) + goto yy999; + if (yych <= 0x8F) + goto yy1001; + goto yy999; + yy1005: + yych = *++p; + if (yych <= 0x7F) + goto yy999; + if (yych <= 0x9F) + goto yy998; + goto yy999; + yy1006: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1009; + goto yy999; + } else { + if (yych <= 'Z') + goto yy1009; + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1009; + goto yy999; + } + yy1007: + ++p; + yych = *p; + yy1008: + if (yybm[0 + yych] & 128) { + goto yy1007; + } + if (yych <= '>') + goto yy999; + if (yych <= '@') + goto yy1006; + goto yy999; + yy1009: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1011; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1011; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1011; + goto yy999; + } + } + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1139; + if (yych <= '/') + goto yy999; + goto yy1140; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1140; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1140; + goto yy999; + } + } + yy1011: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych <= '-') + goto yy1139; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1140; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1140; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1140; + goto yy999; + } + } + yy1012: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1015; + goto yy999; + } else { + if (yych <= 'Z') + goto yy1015; + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1015; + goto yy999; + } + yy1013: + ++p; + { return (bufsize_t)(p - start); } + yy1015: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1017; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1017; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1017; + goto yy999; + } + } + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1018; + if (yych <= '/') + goto yy999; + goto yy1019; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1019; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1019; + goto yy999; + } + } + yy1017: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1019; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1019; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1019; + goto yy999; + } + } + yy1018: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1020; + if (yych <= '/') + goto yy999; + goto yy1021; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1021; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1021; + goto yy999; + } + } + yy1019: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1021; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1021; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1021; + goto yy999; + } + } + yy1020: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1022; + if (yych <= '/') + goto yy999; + goto yy1023; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1023; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1023; + goto yy999; + } + } + yy1021: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1023; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1023; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1023; + goto yy999; + } + } + yy1022: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1024; + if (yych <= '/') + goto yy999; + goto yy1025; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1025; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1025; + goto yy999; + } + } + yy1023: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1025; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1025; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1025; + goto yy999; + } + } + yy1024: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1026; + if (yych <= '/') + goto yy999; + goto yy1027; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1027; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1027; + goto yy999; + } + } + yy1025: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1027; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1027; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1027; + goto yy999; + } + } + yy1026: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1028; + if (yych <= '/') + goto yy999; + goto yy1029; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1029; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1029; + goto yy999; + } + } + yy1027: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1029; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1029; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1029; + goto yy999; + } + } + yy1028: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1030; + if (yych <= '/') + goto yy999; + goto yy1031; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1031; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1031; + goto yy999; + } + } + yy1029: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1031; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1031; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1031; + goto yy999; + } + } + yy1030: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1032; + if (yych <= '/') + goto yy999; + goto yy1033; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1033; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1033; + goto yy999; + } + } + yy1031: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1033; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1033; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1033; + goto yy999; + } + } + yy1032: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1034; + if (yych <= '/') + goto yy999; + goto yy1035; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1035; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1035; + goto yy999; + } + } + yy1033: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1035; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1035; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1035; + goto yy999; + } + } + yy1034: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1036; + if (yych <= '/') + goto yy999; + goto yy1037; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1037; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1037; + goto yy999; + } + } + yy1035: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1037; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1037; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1037; + goto yy999; + } + } + yy1036: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1038; + if (yych <= '/') + goto yy999; + goto yy1039; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1039; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1039; + goto yy999; + } + } + yy1037: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1039; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1039; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1039; + goto yy999; + } + } + yy1038: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1040; + if (yych <= '/') + goto yy999; + goto yy1041; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1041; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1041; + goto yy999; + } + } + yy1039: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1041; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1041; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1041; + goto yy999; + } + } + yy1040: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1042; + if (yych <= '/') + goto yy999; + goto yy1043; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1043; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1043; + goto yy999; + } + } + yy1041: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1043; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1043; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1043; + goto yy999; + } + } + yy1042: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1044; + if (yych <= '/') + goto yy999; + goto yy1045; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1045; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1045; + goto yy999; + } + } + yy1043: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1045; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1045; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1045; + goto yy999; + } + } + yy1044: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1046; + if (yych <= '/') + goto yy999; + goto yy1047; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1047; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1047; + goto yy999; + } + } + yy1045: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1047; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1047; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1047; + goto yy999; + } + } + yy1046: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1048; + if (yych <= '/') + goto yy999; + goto yy1049; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1049; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1049; + goto yy999; + } + } + yy1047: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1049; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1049; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1049; + goto yy999; + } + } + yy1048: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1050; + if (yych <= '/') + goto yy999; + goto yy1051; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1051; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1051; + goto yy999; + } + } + yy1049: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1051; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1051; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1051; + goto yy999; + } + } + yy1050: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1052; + if (yych <= '/') + goto yy999; + goto yy1053; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1053; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1053; + goto yy999; + } + } + yy1051: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1053; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1053; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1053; + goto yy999; + } + } + yy1052: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1054; + if (yych <= '/') + goto yy999; + goto yy1055; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1055; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1055; + goto yy999; + } + } + yy1053: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1055; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1055; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1055; + goto yy999; + } + } + yy1054: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1056; + if (yych <= '/') + goto yy999; + goto yy1057; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1057; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1057; + goto yy999; + } + } + yy1055: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1057; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1057; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1057; + goto yy999; + } + } + yy1056: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1058; + if (yych <= '/') + goto yy999; + goto yy1059; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1059; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1059; + goto yy999; + } + } + yy1057: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1059; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1059; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1059; + goto yy999; + } + } + yy1058: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1060; + if (yych <= '/') + goto yy999; + goto yy1061; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1061; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1061; + goto yy999; + } + } + yy1059: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1061; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1061; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1061; + goto yy999; + } + } + yy1060: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1062; + if (yych <= '/') + goto yy999; + goto yy1063; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1063; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1063; + goto yy999; + } + } + yy1061: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1063; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1063; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1063; + goto yy999; + } + } + yy1062: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1064; + if (yych <= '/') + goto yy999; + goto yy1065; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1065; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1065; + goto yy999; + } + } + yy1063: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1065; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1065; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1065; + goto yy999; + } + } + yy1064: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1066; + if (yych <= '/') + goto yy999; + goto yy1067; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1067; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1067; + goto yy999; + } + } + yy1065: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1067; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1067; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1067; + goto yy999; + } + } + yy1066: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1068; + if (yych <= '/') + goto yy999; + goto yy1069; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1069; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1069; + goto yy999; + } + } + yy1067: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1069; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1069; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1069; + goto yy999; + } + } + yy1068: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1070; + if (yych <= '/') + goto yy999; + goto yy1071; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1071; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1071; + goto yy999; + } + } + yy1069: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1071; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1071; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1071; + goto yy999; + } + } + yy1070: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1072; + if (yych <= '/') + goto yy999; + goto yy1073; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1073; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1073; + goto yy999; + } + } + yy1071: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1073; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1073; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1073; + goto yy999; + } + } + yy1072: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1074; + if (yych <= '/') + goto yy999; + goto yy1075; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1075; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1075; + goto yy999; + } + } + yy1073: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1075; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1075; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1075; + goto yy999; + } + } + yy1074: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1076; + if (yych <= '/') + goto yy999; + goto yy1077; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1077; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1077; + goto yy999; + } + } + yy1075: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1077; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1077; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1077; + goto yy999; + } + } + yy1076: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1078; + if (yych <= '/') + goto yy999; + goto yy1079; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1079; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1079; + goto yy999; + } + } + yy1077: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1079; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1079; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1079; + goto yy999; + } + } + yy1078: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1080; + if (yych <= '/') + goto yy999; + goto yy1081; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1081; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1081; + goto yy999; + } + } + yy1079: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1081; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1081; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1081; + goto yy999; + } + } + yy1080: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1082; + if (yych <= '/') + goto yy999; + goto yy1083; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1083; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1083; + goto yy999; + } + } + yy1081: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1083; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1083; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1083; + goto yy999; + } + } + yy1082: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1084; + if (yych <= '/') + goto yy999; + goto yy1085; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1085; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1085; + goto yy999; + } + } + yy1083: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1085; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1085; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1085; + goto yy999; + } + } + yy1084: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1086; + if (yych <= '/') + goto yy999; + goto yy1087; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1087; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1087; + goto yy999; + } + } + yy1085: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1087; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1087; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1087; + goto yy999; + } + } + yy1086: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1088; + if (yych <= '/') + goto yy999; + goto yy1089; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1089; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1089; + goto yy999; + } + } + yy1087: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1089; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1089; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1089; + goto yy999; + } + } + yy1088: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1090; + if (yych <= '/') + goto yy999; + goto yy1091; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1091; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1091; + goto yy999; + } + } + yy1089: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1091; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1091; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1091; + goto yy999; + } + } + yy1090: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1092; + if (yych <= '/') + goto yy999; + goto yy1093; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1093; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1093; + goto yy999; + } + } + yy1091: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1093; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1093; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1093; + goto yy999; + } + } + yy1092: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1094; + if (yych <= '/') + goto yy999; + goto yy1095; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1095; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1095; + goto yy999; + } + } + yy1093: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1095; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1095; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1095; + goto yy999; + } + } + yy1094: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1096; + if (yych <= '/') + goto yy999; + goto yy1097; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1097; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1097; + goto yy999; + } + } + yy1095: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1097; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1097; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1097; + goto yy999; + } + } + yy1096: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1098; + if (yych <= '/') + goto yy999; + goto yy1099; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1099; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1099; + goto yy999; + } + } + yy1097: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1099; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1099; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1099; + goto yy999; + } + } + yy1098: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1100; + if (yych <= '/') + goto yy999; + goto yy1101; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1101; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1101; + goto yy999; + } + } + yy1099: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1101; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1101; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1101; + goto yy999; + } + } + yy1100: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1102; + if (yych <= '/') + goto yy999; + goto yy1103; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1103; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1103; + goto yy999; + } + } + yy1101: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1103; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1103; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1103; + goto yy999; + } + } + yy1102: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1104; + if (yych <= '/') + goto yy999; + goto yy1105; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1105; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1105; + goto yy999; + } + } + yy1103: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1105; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1105; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1105; + goto yy999; + } + } + yy1104: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1106; + if (yych <= '/') + goto yy999; + goto yy1107; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1107; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1107; + goto yy999; + } + } + yy1105: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1107; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1107; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1107; + goto yy999; + } + } + yy1106: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1108; + if (yych <= '/') + goto yy999; + goto yy1109; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1109; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1109; + goto yy999; + } + } + yy1107: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1109; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1109; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1109; + goto yy999; + } + } + yy1108: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1110; + if (yych <= '/') + goto yy999; + goto yy1111; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1111; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1111; + goto yy999; + } + } + yy1109: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1111; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1111; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1111; + goto yy999; + } + } + yy1110: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1112; + if (yych <= '/') + goto yy999; + goto yy1113; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1113; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1113; + goto yy999; + } + } + yy1111: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1113; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1113; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1113; + goto yy999; + } + } + yy1112: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1114; + if (yych <= '/') + goto yy999; + goto yy1115; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1115; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1115; + goto yy999; + } + } + yy1113: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1115; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1115; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1115; + goto yy999; + } + } + yy1114: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1116; + if (yych <= '/') + goto yy999; + goto yy1117; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1117; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1117; + goto yy999; + } + } + yy1115: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1117; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1117; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1117; + goto yy999; + } + } + yy1116: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1118; + if (yych <= '/') + goto yy999; + goto yy1119; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1119; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1119; + goto yy999; + } + } + yy1117: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1119; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1119; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1119; + goto yy999; + } + } + yy1118: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1120; + if (yych <= '/') + goto yy999; + goto yy1121; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1121; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1121; + goto yy999; + } + } + yy1119: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1121; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1121; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1121; + goto yy999; + } + } + yy1120: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1122; + if (yych <= '/') + goto yy999; + goto yy1123; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1123; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1123; + goto yy999; + } + } + yy1121: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1123; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1123; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1123; + goto yy999; + } + } + yy1122: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1124; + if (yych <= '/') + goto yy999; + goto yy1125; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1125; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1125; + goto yy999; + } + } + yy1123: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1125; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1125; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1125; + goto yy999; + } + } + yy1124: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1126; + if (yych <= '/') + goto yy999; + goto yy1127; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1127; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1127; + goto yy999; + } + } + yy1125: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1127; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1127; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1127; + goto yy999; + } + } + yy1126: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1128; + if (yych <= '/') + goto yy999; + goto yy1129; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1129; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1129; + goto yy999; + } + } + yy1127: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1129; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1129; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1129; + goto yy999; + } + } + yy1128: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1130; + if (yych <= '/') + goto yy999; + goto yy1131; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1131; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1131; + goto yy999; + } + } + yy1129: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1131; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1131; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1131; + goto yy999; + } + } + yy1130: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1132; + if (yych <= '/') + goto yy999; + goto yy1133; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1133; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1133; + goto yy999; + } + } + yy1131: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1133; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1133; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1133; + goto yy999; + } + } + yy1132: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1134; + if (yych <= '/') + goto yy999; + goto yy1135; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1135; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1135; + goto yy999; + } + } + yy1133: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1135; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1135; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1135; + goto yy999; + } + } + yy1134: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy1136; + if (yych <= '/') + goto yy999; + goto yy1137; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1137; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1137; + goto yy999; + } + } + yy1135: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1137; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1137; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1137; + goto yy999; + } + } + yy1136: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1138; + goto yy999; + } else { + if (yych <= 'Z') + goto yy1138; + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1138; + goto yy999; + } + yy1137: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= '-') + goto yy999; + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych >= ':') + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + } else { + if (yych <= '`') + goto yy999; + if (yych >= '{') + goto yy999; + } + } + yy1138: + ++p; + yych = *p; + if (yych == '.') + goto yy1012; + if (yych == '>') + goto yy1013; + goto yy999; + yy1139: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1141; + if (yych <= '/') + goto yy999; + goto yy1142; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1142; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1142; + goto yy999; + } + } + yy1140: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1142; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1142; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1142; + goto yy999; + } + } + yy1141: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1143; + if (yych <= '/') + goto yy999; + goto yy1144; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1144; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1144; + goto yy999; + } + } + yy1142: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1144; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1144; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1144; + goto yy999; + } + } + yy1143: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1145; + if (yych <= '/') + goto yy999; + goto yy1146; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1146; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1146; + goto yy999; + } + } + yy1144: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1146; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1146; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1146; + goto yy999; + } + } + yy1145: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1147; + if (yych <= '/') + goto yy999; + goto yy1148; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1148; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1148; + goto yy999; + } + } + yy1146: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1148; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1148; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1148; + goto yy999; + } + } + yy1147: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1149; + if (yych <= '/') + goto yy999; + goto yy1150; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1150; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1150; + goto yy999; + } + } + yy1148: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1150; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1150; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1150; + goto yy999; + } + } + yy1149: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1151; + if (yych <= '/') + goto yy999; + goto yy1152; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1152; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1152; + goto yy999; + } + } + yy1150: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1152; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1152; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1152; + goto yy999; + } + } + yy1151: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1153; + if (yych <= '/') + goto yy999; + goto yy1154; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1154; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1154; + goto yy999; + } + } + yy1152: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1154; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1154; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1154; + goto yy999; + } + } + yy1153: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1155; + if (yych <= '/') + goto yy999; + goto yy1156; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1156; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1156; + goto yy999; + } + } + yy1154: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1156; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1156; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1156; + goto yy999; + } + } + yy1155: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1157; + if (yych <= '/') + goto yy999; + goto yy1158; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1158; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1158; + goto yy999; + } + } + yy1156: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1158; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1158; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1158; + goto yy999; + } + } + yy1157: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1159; + if (yych <= '/') + goto yy999; + goto yy1160; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1160; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1160; + goto yy999; + } + } + yy1158: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1160; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1160; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1160; + goto yy999; + } + } + yy1159: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1161; + if (yych <= '/') + goto yy999; + goto yy1162; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1162; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1162; + goto yy999; + } + } + yy1160: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1162; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1162; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1162; + goto yy999; + } + } + yy1161: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1163; + if (yych <= '/') + goto yy999; + goto yy1164; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1164; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1164; + goto yy999; + } + } + yy1162: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1164; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1164; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1164; + goto yy999; + } + } + yy1163: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1165; + if (yych <= '/') + goto yy999; + goto yy1166; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1166; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1166; + goto yy999; + } + } + yy1164: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1166; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1166; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1166; + goto yy999; + } + } + yy1165: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1167; + if (yych <= '/') + goto yy999; + goto yy1168; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1168; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1168; + goto yy999; + } + } + yy1166: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1168; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1168; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1168; + goto yy999; + } + } + yy1167: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1169; + if (yych <= '/') + goto yy999; + goto yy1170; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1170; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1170; + goto yy999; + } + } + yy1168: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1170; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1170; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1170; + goto yy999; + } + } + yy1169: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1171; + if (yych <= '/') + goto yy999; + goto yy1172; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1172; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1172; + goto yy999; + } + } + yy1170: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1172; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1172; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1172; + goto yy999; + } + } + yy1171: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1173; + if (yych <= '/') + goto yy999; + goto yy1174; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1174; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1174; + goto yy999; + } + } + yy1172: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1174; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1174; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1174; + goto yy999; + } + } + yy1173: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1175; + if (yych <= '/') + goto yy999; + goto yy1176; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1176; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1176; + goto yy999; + } + } + yy1174: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1176; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1176; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1176; + goto yy999; + } + } + yy1175: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1177; + if (yych <= '/') + goto yy999; + goto yy1178; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1178; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1178; + goto yy999; + } + } + yy1176: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1178; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1178; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1178; + goto yy999; + } + } + yy1177: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1179; + if (yych <= '/') + goto yy999; + goto yy1180; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1180; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1180; + goto yy999; + } + } + yy1178: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1180; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1180; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1180; + goto yy999; + } + } + yy1179: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1181; + if (yych <= '/') + goto yy999; + goto yy1182; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1182; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1182; + goto yy999; + } + } + yy1180: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1182; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1182; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1182; + goto yy999; + } + } + yy1181: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1183; + if (yych <= '/') + goto yy999; + goto yy1184; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1184; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1184; + goto yy999; + } + } + yy1182: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1184; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1184; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1184; + goto yy999; + } + } + yy1183: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1185; + if (yych <= '/') + goto yy999; + goto yy1186; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1186; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1186; + goto yy999; + } + } + yy1184: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1186; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1186; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1186; + goto yy999; + } + } + yy1185: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1187; + if (yych <= '/') + goto yy999; + goto yy1188; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1188; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1188; + goto yy999; + } + } + yy1186: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1188; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1188; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1188; + goto yy999; + } + } + yy1187: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1189; + if (yych <= '/') + goto yy999; + goto yy1190; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1190; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1190; + goto yy999; + } + } + yy1188: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1190; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1190; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1190; + goto yy999; + } + } + yy1189: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1191; + if (yych <= '/') + goto yy999; + goto yy1192; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1192; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1192; + goto yy999; + } + } + yy1190: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1192; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1192; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1192; + goto yy999; + } + } + yy1191: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1193; + if (yych <= '/') + goto yy999; + goto yy1194; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1194; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1194; + goto yy999; + } + } + yy1192: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1194; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1194; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1194; + goto yy999; + } + } + yy1193: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1195; + if (yych <= '/') + goto yy999; + goto yy1196; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1196; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1196; + goto yy999; + } + } + yy1194: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1196; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1196; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1196; + goto yy999; + } + } + yy1195: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1197; + if (yych <= '/') + goto yy999; + goto yy1198; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1198; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1198; + goto yy999; + } + } + yy1196: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1198; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1198; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1198; + goto yy999; + } + } + yy1197: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1199; + if (yych <= '/') + goto yy999; + goto yy1200; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1200; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1200; + goto yy999; + } + } + yy1198: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1200; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1200; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1200; + goto yy999; + } + } + yy1199: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1201; + if (yych <= '/') + goto yy999; + goto yy1202; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1202; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1202; + goto yy999; + } + } + yy1200: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1202; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1202; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1202; + goto yy999; + } + } + yy1201: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1203; + if (yych <= '/') + goto yy999; + goto yy1204; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1204; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1204; + goto yy999; + } + } + yy1202: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1204; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1204; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1204; + goto yy999; + } + } + yy1203: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1205; + if (yych <= '/') + goto yy999; + goto yy1206; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1206; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1206; + goto yy999; + } + } + yy1204: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1206; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1206; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1206; + goto yy999; + } + } + yy1205: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1207; + if (yych <= '/') + goto yy999; + goto yy1208; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1208; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1208; + goto yy999; + } + } + yy1206: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1208; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1208; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1208; + goto yy999; + } + } + yy1207: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1209; + if (yych <= '/') + goto yy999; + goto yy1210; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1210; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1210; + goto yy999; + } + } + yy1208: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1210; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1210; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1210; + goto yy999; + } + } + yy1209: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1211; + if (yych <= '/') + goto yy999; + goto yy1212; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1212; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1212; + goto yy999; + } + } + yy1210: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1212; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1212; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1212; + goto yy999; + } + } + yy1211: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1213; + if (yych <= '/') + goto yy999; + goto yy1214; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1214; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1214; + goto yy999; + } + } + yy1212: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1214; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1214; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1214; + goto yy999; + } + } + yy1213: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1215; + if (yych <= '/') + goto yy999; + goto yy1216; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1216; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1216; + goto yy999; + } + } + yy1214: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1216; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1216; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1216; + goto yy999; + } + } + yy1215: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1217; + if (yych <= '/') + goto yy999; + goto yy1218; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1218; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1218; + goto yy999; + } + } + yy1216: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1218; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1218; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1218; + goto yy999; + } + } + yy1217: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1219; + if (yych <= '/') + goto yy999; + goto yy1220; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1220; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1220; + goto yy999; + } + } + yy1218: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1220; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1220; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1220; + goto yy999; + } + } + yy1219: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1221; + if (yych <= '/') + goto yy999; + goto yy1222; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1222; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1222; + goto yy999; + } + } + yy1220: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1222; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1222; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1222; + goto yy999; + } + } + yy1221: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1223; + if (yych <= '/') + goto yy999; + goto yy1224; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1224; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1224; + goto yy999; + } + } + yy1222: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1224; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1224; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1224; + goto yy999; + } + } + yy1223: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1225; + if (yych <= '/') + goto yy999; + goto yy1226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1226; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1226; + goto yy999; + } + } + yy1224: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1226; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1226; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1226; + goto yy999; + } + } + yy1225: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1227; + if (yych <= '/') + goto yy999; + goto yy1228; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1228; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1228; + goto yy999; + } + } + yy1226: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1228; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1228; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1228; + goto yy999; + } + } + yy1227: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1229; + if (yych <= '/') + goto yy999; + goto yy1230; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1230; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1230; + goto yy999; + } + } + yy1228: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1230; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1230; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1230; + goto yy999; + } + } + yy1229: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1231; + if (yych <= '/') + goto yy999; + goto yy1232; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1232; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1232; + goto yy999; + } + } + yy1230: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1232; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1232; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1232; + goto yy999; + } + } + yy1231: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1233; + if (yych <= '/') + goto yy999; + goto yy1234; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1234; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1234; + goto yy999; + } + } + yy1232: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1234; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1234; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1234; + goto yy999; + } + } + yy1233: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1235; + if (yych <= '/') + goto yy999; + goto yy1236; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1236; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1236; + goto yy999; + } + } + yy1234: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1236; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1236; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1236; + goto yy999; + } + } + yy1235: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1237; + if (yych <= '/') + goto yy999; + goto yy1238; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1238; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1238; + goto yy999; + } + } + yy1236: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1238; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1238; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1238; + goto yy999; + } + } + yy1237: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1239; + if (yych <= '/') + goto yy999; + goto yy1240; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1240; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1240; + goto yy999; + } + } + yy1238: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1240; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1240; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1240; + goto yy999; + } + } + yy1239: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1241; + if (yych <= '/') + goto yy999; + goto yy1242; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1242; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1242; + goto yy999; + } + } + yy1240: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1242; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1242; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1242; + goto yy999; + } + } + yy1241: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1243; + if (yych <= '/') + goto yy999; + goto yy1244; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1244; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1244; + goto yy999; + } + } + yy1242: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1244; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1244; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1244; + goto yy999; + } + } + yy1243: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1245; + if (yych <= '/') + goto yy999; + goto yy1246; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1246; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1246; + goto yy999; + } + } + yy1244: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1246; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1246; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1246; + goto yy999; + } + } + yy1245: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1247; + if (yych <= '/') + goto yy999; + goto yy1248; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1248; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1248; + goto yy999; + } + } + yy1246: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1248; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1248; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1248; + goto yy999; + } + } + yy1247: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1249; + if (yych <= '/') + goto yy999; + goto yy1250; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1250; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1250; + goto yy999; + } + } + yy1248: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1250; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1250; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1250; + goto yy999; + } + } + yy1249: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1251; + if (yych <= '/') + goto yy999; + goto yy1252; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1252; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1252; + goto yy999; + } + } + yy1250: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1252; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1252; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1252; + goto yy999; + } + } + yy1251: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1253; + if (yych <= '/') + goto yy999; + goto yy1254; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1254; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1254; + goto yy999; + } + } + yy1252: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1254; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1254; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1254; + goto yy999; + } + } + yy1253: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1255; + if (yych <= '/') + goto yy999; + goto yy1256; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1256; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1256; + goto yy999; + } + } + yy1254: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1256; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1256; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1256; + goto yy999; + } + } + yy1255: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy1257; + if (yych <= '/') + goto yy999; + goto yy1258; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1258; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1258; + goto yy999; + } + } + yy1256: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy999; + if (yych >= '.') + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1258; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1258; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1258; + goto yy999; + } + } + yy1257: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1138; + goto yy999; + } else { + if (yych <= 'Z') + goto yy1138; + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1138; + goto yy999; + } + yy1258: + ++p; + if ((yych = *p) <= '=') { + if (yych <= '.') { + if (yych <= '-') + goto yy999; + goto yy1012; + } else { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1138; + goto yy999; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1013; + if (yych <= '@') + goto yy999; + goto yy1138; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1138; + goto yy999; + } + } + } } // Try to match an HTML tag after first <, returning num of chars matched. -bufsize_t _scan_html_tag(const unsigned char *p) -{ +bufsize_t _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, 254, 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, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - /* 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, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 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 = *(marker = p); - if (yych <= '`') { - if (yych <= '.') { - if (yych <= '\n') { - if (yych <= '\t') goto yy1266; - } else { - if (yych == '!') goto yy1264; - goto yy1266; - } - } else { - if (yych <= '?') { - if (yych <= '/') goto yy1263; - if (yych <= '>') goto yy1266; - goto yy1265; - } else { - if (yych <= '@') goto yy1266; - if (yych <= 'Z') goto yy1262; - goto yy1266; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 'z') goto yy1262; - if (yych <= 0x7F) goto yy1266; - } else { - if (yych <= 0xDF) goto yy1267; - if (yych <= 0xE0) goto yy1269; - goto yy1270; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1274; - if (yych <= 0xEF) goto yy1270; - goto yy1271; - } else { - if (yych <= 0xF3) goto yy1272; - if (yych <= 0xF4) goto yy1273; - } - } - } -yy1261: - { return 0; } -yy1262: - yych = *(marker = ++p); - if (yych <= '/') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy1261; - if (yych <= '\r') goto yy1366; - if (yych <= 0x1F) goto yy1261; - goto yy1366; - } else { - if (yych == '-') goto yy1364; - if (yych <= '.') goto yy1261; - goto yy1368; - } - } else { - if (yych <= '@') { - if (yych <= '9') goto yy1364; - if (yych == '>') goto yy1285; - goto yy1261; - } else { - if (yych <= 'Z') goto yy1364; - if (yych <= '`') goto yy1261; - if (yych <= 'z') goto yy1364; - goto yy1261; - } - } -yy1263: - yych = *(marker = ++p); - if (yych <= '@') goto yy1261; - if (yych <= 'Z') goto yy1360; - if (yych <= '`') goto yy1261; - if (yych <= 'z') goto yy1360; - goto yy1261; -yy1264: - yych = *(marker = ++p); - if (yybm[256+yych] & 64) { - goto yy1295; - } - if (yych == '-') goto yy1297; - if (yych <= '@') goto yy1261; - if (yych <= '[') goto yy1294; - goto yy1261; -yy1265: - yych = *(marker = ++p); - if (yych <= 0x00) goto yy1261; - if (yych <= 0x7F) goto yy1276; - if (yych <= 0xC1) goto yy1261; - if (yych <= 0xF4) goto yy1276; - goto yy1261; -yy1266: - yych = *++p; - goto yy1261; -yy1267: - yych = *++p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1266; -yy1268: - p = marker; - goto yy1261; -yy1269: - yych = *++p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1267; - goto yy1268; -yy1270: - yych = *++p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1267; - goto yy1268; -yy1271: - yych = *++p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1270; - goto yy1268; -yy1272: - yych = *++p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1270; - goto yy1268; -yy1273: - yych = *++p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1270; - goto yy1268; -yy1274: - yych = *++p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1267; - goto yy1268; -yy1275: - ++p; - yych = *p; -yy1276: - if (yybm[256+yych] & 32) { - goto yy1275; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy1268; - if (yych <= '?') goto yy1284; - goto yy1268; - } else { - if (yych <= 0xDF) goto yy1277; - if (yych <= 0xE0) goto yy1278; - goto yy1279; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1283; - if (yych <= 0xEF) goto yy1279; - goto yy1280; - } else { - if (yych <= 0xF3) goto yy1281; - if (yych <= 0xF4) goto yy1282; - goto yy1268; - } - } -yy1277: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1275; - goto yy1268; -yy1278: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1277; - goto yy1268; -yy1279: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1277; - goto yy1268; -yy1280: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1279; - goto yy1268; -yy1281: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1279; - goto yy1268; -yy1282: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1279; - goto yy1268; -yy1283: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1277; - goto yy1268; -yy1284: - ++p; - yych = *p; - if (yych <= 0xE0) { - if (yych <= '>') { - if (yych <= 0x00) goto yy1268; - if (yych <= '=') goto yy1275; - } else { - if (yych <= 0x7F) goto yy1275; - if (yych <= 0xC1) goto yy1268; - if (yych <= 0xDF) goto yy1287; - goto yy1288; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1293; - goto yy1289; - } else { - if (yych <= 0xF0) goto yy1290; - if (yych <= 0xF3) goto yy1291; - if (yych <= 0xF4) goto yy1292; - goto yy1268; - } - } -yy1285: - ++p; - { return (bufsize_t)(p - start); } -yy1287: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1275; - goto yy1268; -yy1288: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1287; - goto yy1268; -yy1289: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1287; - goto yy1268; -yy1290: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1289; - goto yy1268; -yy1291: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1289; - goto yy1268; -yy1292: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1289; - goto yy1268; -yy1293: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1287; - goto yy1268; -yy1294: - yych = *++p; - if (yych == 'C') goto yy1330; - if (yych == 'c') goto yy1330; - goto yy1268; -yy1295: - ++p; - yych = *p; - if (yybm[0+yych] & 1) { - goto yy1319; - } - if (yych <= '@') goto yy1268; - if (yych <= 'Z') goto yy1295; - goto yy1268; -yy1297: - yych = *++p; - if (yych != '-') goto yy1268; - yych = *++p; - if (yych <= 0xE0) { - if (yych <= '=') { - if (yych != '-') goto yy1301; - } else { - if (yych <= '>') goto yy1268; - if (yych <= 0xC1) goto yy1301; - if (yych <= 0xDF) goto yy1302; - goto yy1303; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1308; - goto yy1304; - } else { - if (yych <= 0xF0) goto yy1305; - if (yych <= 0xF3) goto yy1306; - if (yych <= 0xF4) goto yy1307; - goto yy1301; - } - } - yych = *++p; - if (yych <= 0xE0) { - if (yych <= '=') { - if (yych == '-') goto yy1318; - goto yy1301; - } else { - if (yych <= '>') goto yy1268; - if (yych <= 0xC1) goto yy1301; - if (yych <= 0xDF) goto yy1302; - goto yy1303; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1308; - goto yy1304; - } else { - if (yych <= 0xF0) goto yy1305; - if (yych <= 0xF3) goto yy1306; - if (yych <= 0xF4) goto yy1307; - goto yy1301; - } - } -yy1300: - ++p; - yych = *p; -yy1301: - if (yybm[256+yych] & 128) { - goto yy1300; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy1268; - if (yych <= '-') goto yy1309; - goto yy1268; - } else { - if (yych <= 0xDF) goto yy1310; - if (yych <= 0xE0) goto yy1311; - goto yy1312; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1316; - if (yych <= 0xEF) goto yy1312; - goto yy1313; - } else { - if (yych <= 0xF3) goto yy1314; - if (yych <= 0xF4) goto yy1315; - goto yy1268; - } - } -yy1302: - yych = *++p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1300; - goto yy1268; -yy1303: - yych = *++p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1302; - goto yy1268; -yy1304: - yych = *++p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1302; - goto yy1268; -yy1305: - yych = *++p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1304; - goto yy1268; -yy1306: - yych = *++p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1304; - goto yy1268; -yy1307: - yych = *++p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1304; - goto yy1268; -yy1308: - yych = *++p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1302; - goto yy1268; -yy1309: - ++p; - yych = *p; - if (yybm[256+yych] & 128) { - goto yy1300; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy1268; - if (yych <= '-') goto yy1317; - goto yy1268; - } else { - if (yych <= 0xDF) goto yy1310; - if (yych <= 0xE0) goto yy1311; - goto yy1312; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1316; - if (yych <= 0xEF) goto yy1312; - goto yy1313; - } else { - if (yych <= 0xF3) goto yy1314; - if (yych <= 0xF4) goto yy1315; - goto yy1268; - } - } -yy1310: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1300; - goto yy1268; -yy1311: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1310; - goto yy1268; -yy1312: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1310; - goto yy1268; -yy1313: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1312; - goto yy1268; -yy1314: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1312; - goto yy1268; -yy1315: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1312; - goto yy1268; -yy1316: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1310; - goto yy1268; -yy1317: - yych = *++p; - if (yych == '>') goto yy1285; - goto yy1268; -yy1318: - yych = *++p; - if (yych == '>') goto yy1285; - goto yy1268; -yy1319: - ++p; - yych = *p; - if (yybm[0+yych] & 1) { - goto yy1319; - } - if (yych <= 0xE0) { - if (yych <= '>') { - if (yych <= 0x00) goto yy1268; - if (yych >= '>') goto yy1285; - } else { - if (yych <= 0x7F) goto yy1321; - if (yych <= 0xC1) goto yy1268; - if (yych <= 0xDF) goto yy1323; - goto yy1324; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1329; - goto yy1325; - } else { - if (yych <= 0xF0) goto yy1326; - if (yych <= 0xF3) goto yy1327; - if (yych <= 0xF4) goto yy1328; - goto yy1268; - } - } -yy1321: - ++p; - yych = *p; - if (yybm[0+yych] & 2) { - goto yy1321; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy1268; - if (yych <= '>') goto yy1285; - goto yy1268; - } else { - if (yych <= 0xDF) goto yy1323; - if (yych <= 0xE0) goto yy1324; - goto yy1325; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1329; - if (yych <= 0xEF) goto yy1325; - goto yy1326; - } else { - if (yych <= 0xF3) goto yy1327; - if (yych <= 0xF4) goto yy1328; - goto yy1268; - } - } -yy1323: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1321; - goto yy1268; -yy1324: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1323; - goto yy1268; -yy1325: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1323; - goto yy1268; -yy1326: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1325; - goto yy1268; -yy1327: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1325; - goto yy1268; -yy1328: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1325; - goto yy1268; -yy1329: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1323; - goto yy1268; -yy1330: - yych = *++p; - if (yych == 'D') goto yy1331; - if (yych != 'd') goto yy1268; -yy1331: - yych = *++p; - if (yych == 'A') goto yy1332; - if (yych != 'a') goto yy1268; -yy1332: - yych = *++p; - if (yych == 'T') goto yy1333; - if (yych != 't') goto yy1268; -yy1333: - yych = *++p; - if (yych == 'A') goto yy1334; - if (yych != 'a') goto yy1268; -yy1334: - yych = *++p; - if (yych != '[') goto yy1268; -yy1335: - ++p; - yych = *p; - if (yybm[0+yych] & 4) { - goto yy1335; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy1268; - if (yych <= ']') goto yy1344; - goto yy1268; - } else { - if (yych <= 0xDF) goto yy1337; - if (yych <= 0xE0) goto yy1338; - goto yy1339; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1343; - if (yych <= 0xEF) goto yy1339; - goto yy1340; - } else { - if (yych <= 0xF3) goto yy1341; - if (yych <= 0xF4) goto yy1342; - goto yy1268; - } - } -yy1337: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1335; - goto yy1268; -yy1338: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1337; - goto yy1268; -yy1339: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1337; - goto yy1268; -yy1340: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1339; - goto yy1268; -yy1341: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1339; - goto yy1268; -yy1342: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1339; - goto yy1268; -yy1343: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1337; - goto yy1268; -yy1344: - ++p; - yych = *p; - if (yybm[0+yych] & 4) { - goto yy1335; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy1268; - if (yych >= '^') goto yy1268; - } else { - if (yych <= 0xDF) goto yy1346; - if (yych <= 0xE0) goto yy1347; - goto yy1348; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1352; - if (yych <= 0xEF) goto yy1348; - goto yy1349; - } else { - if (yych <= 0xF3) goto yy1350; - if (yych <= 0xF4) goto yy1351; - goto yy1268; - } - } - ++p; - yych = *p; - if (yych <= 0xE0) { - if (yych <= '>') { - if (yych <= 0x00) goto yy1268; - if (yych <= '=') goto yy1335; - goto yy1285; - } else { - if (yych <= 0x7F) goto yy1335; - if (yych <= 0xC1) goto yy1268; - if (yych <= 0xDF) goto yy1353; - goto yy1354; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1359; - goto yy1355; - } else { - if (yych <= 0xF0) goto yy1356; - if (yych <= 0xF3) goto yy1357; - if (yych <= 0xF4) goto yy1358; - goto yy1268; - } - } -yy1346: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1335; - goto yy1268; -yy1347: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1346; - goto yy1268; -yy1348: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1346; - goto yy1268; -yy1349: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1348; - goto yy1268; -yy1350: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1348; - goto yy1268; -yy1351: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1348; - goto yy1268; -yy1352: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1346; - goto yy1268; -yy1353: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1335; - goto yy1268; -yy1354: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1353; - goto yy1268; -yy1355: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1353; - goto yy1268; -yy1356: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1355; - goto yy1268; -yy1357: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1355; - goto yy1268; -yy1358: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1355; - goto yy1268; -yy1359: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1353; - goto yy1268; -yy1360: - ++p; - yych = *p; - if (yybm[0+yych] & 8) { - goto yy1360; - } - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1268; - if (yych >= 0x0E) goto yy1268; - } else { - if (yych <= ' ') goto yy1362; - if (yych == '>') goto yy1285; - goto yy1268; - } -yy1362: - ++p; - yych = *p; - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1268; - if (yych <= '\r') goto yy1362; - goto yy1268; - } else { - if (yych <= ' ') goto yy1362; - if (yych == '>') goto yy1285; - goto yy1268; - } -yy1364: - ++p; - yych = *p; - if (yych <= '/') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy1268; - if (yych <= '\r') goto yy1366; - if (yych <= 0x1F) goto yy1268; - } else { - if (yych == '-') goto yy1364; - if (yych <= '.') goto yy1268; - goto yy1368; - } - } else { - if (yych <= '@') { - if (yych <= '9') goto yy1364; - if (yych == '>') goto yy1285; - goto yy1268; - } else { - if (yych <= 'Z') goto yy1364; - if (yych <= '`') goto yy1268; - if (yych <= 'z') goto yy1364; - goto yy1268; - } - } -yy1366: - ++p; - yych = *p; - if (yych <= ':') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy1268; - if (yych <= '\r') goto yy1366; - if (yych <= 0x1F) goto yy1268; - goto yy1366; - } else { - if (yych == '/') goto yy1368; - if (yych <= '9') goto yy1268; - goto yy1369; - } - } else { - if (yych <= 'Z') { - if (yych == '>') goto yy1285; - if (yych <= '@') goto yy1268; - goto yy1369; - } else { - if (yych <= '_') { - if (yych <= '^') goto yy1268; - goto yy1369; - } else { - if (yych <= '`') goto yy1268; - if (yych <= 'z') goto yy1369; - goto yy1268; - } - } - } -yy1368: - yych = *++p; - if (yych == '>') goto yy1285; - goto yy1268; -yy1369: - ++p; - yych = *p; - if (yybm[0+yych] & 16) { - goto yy1369; - } - if (yych <= ',') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy1268; - } else { - if (yych != ' ') goto yy1268; - } - } else { - if (yych <= '<') { - if (yych <= '/') goto yy1368; - goto yy1268; - } else { - if (yych <= '=') goto yy1373; - if (yych <= '>') goto yy1285; - goto yy1268; - } - } -yy1371: - ++p; - yych = *p; - if (yych <= '<') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy1268; - if (yych <= '\r') goto yy1371; - if (yych <= 0x1F) goto yy1268; - goto yy1371; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy1268; - goto yy1368; - } else { - if (yych == ':') goto yy1369; - goto yy1268; - } - } - } else { - if (yych <= 'Z') { - if (yych <= '=') goto yy1373; - if (yych <= '>') goto yy1285; - if (yych <= '@') goto yy1268; - goto yy1369; - } else { - if (yych <= '_') { - if (yych <= '^') goto yy1268; - goto yy1369; - } else { - if (yych <= '`') goto yy1268; - if (yych <= 'z') goto yy1369; - goto yy1268; - } - } - } -yy1373: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1375; - } - if (yych <= 0xE0) { - if (yych <= '"') { - if (yych <= 0x00) goto yy1268; - if (yych >= '!') goto yy1386; - } else { - if (yych <= '\'') goto yy1384; - if (yych <= 0xC1) goto yy1268; - if (yych <= 0xDF) goto yy1377; - goto yy1378; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1383; - goto yy1379; - } else { - if (yych <= 0xF0) goto yy1380; - if (yych <= 0xF3) goto yy1381; - if (yych <= 0xF4) goto yy1382; - goto yy1268; - } - } - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1375; - } - if (yych <= 0xDF) { - if (yych <= '\'') { - if (yych <= 0x00) goto yy1268; - if (yych <= ' ') goto yy1409; - if (yych <= '"') goto yy1386; - goto yy1384; - } else { - if (yych == '>') goto yy1285; - if (yych <= 0xC1) goto yy1268; - goto yy1377; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1378; - if (yych == 0xED) goto yy1383; - goto yy1379; - } else { - if (yych <= 0xF0) goto yy1380; - if (yych <= 0xF3) goto yy1381; - if (yych <= 0xF4) goto yy1382; - goto yy1268; - } - } -yy1375: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1375; - } - if (yych <= 0xE0) { - if (yych <= '=') { - if (yych <= 0x00) goto yy1268; - if (yych <= ' ') goto yy1403; - goto yy1268; - } else { - if (yych <= '>') goto yy1285; - if (yych <= 0xC1) goto yy1268; - if (yych >= 0xE0) goto yy1378; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1383; - goto yy1379; - } else { - if (yych <= 0xF0) goto yy1380; - if (yych <= 0xF3) goto yy1381; - if (yych <= 0xF4) goto yy1382; - goto yy1268; - } - } -yy1377: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1375; - goto yy1268; -yy1378: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1377; - goto yy1268; -yy1379: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1377; - goto yy1268; -yy1380: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1379; - goto yy1268; -yy1381: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1379; - goto yy1268; -yy1382: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1379; - goto yy1268; -yy1383: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1377; - goto yy1268; -yy1384: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1384; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy1268; - if (yych <= '\'') goto yy1395; - goto yy1268; - } else { - if (yych <= 0xDF) goto yy1396; - if (yych <= 0xE0) goto yy1397; - goto yy1398; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1402; - if (yych <= 0xEF) goto yy1398; - goto yy1399; - } else { - if (yych <= 0xF3) goto yy1400; - if (yych <= 0xF4) goto yy1401; - goto yy1268; - } - } -yy1386: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1386; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy1268; - if (yych <= '"') goto yy1395; - goto yy1268; - } else { - if (yych <= 0xDF) goto yy1388; - if (yych <= 0xE0) goto yy1389; - goto yy1390; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1394; - if (yych <= 0xEF) goto yy1390; - goto yy1391; - } else { - if (yych <= 0xF3) goto yy1392; - if (yych <= 0xF4) goto yy1393; - goto yy1268; - } - } -yy1388: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1386; - goto yy1268; -yy1389: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1388; - goto yy1268; -yy1390: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1388; - goto yy1268; -yy1391: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1390; - goto yy1268; -yy1392: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1390; - goto yy1268; -yy1393: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1390; - goto yy1268; -yy1394: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1388; - goto yy1268; -yy1395: - ++p; - yych = *p; - if (yych <= ' ') { - if (yych <= 0x08) goto yy1268; - if (yych <= '\r') goto yy1366; - if (yych <= 0x1F) goto yy1268; - goto yy1366; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy1268; - goto yy1368; - } else { - if (yych == '>') goto yy1285; - goto yy1268; - } - } -yy1396: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1384; - goto yy1268; -yy1397: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1268; - if (yych <= 0xBF) goto yy1396; - goto yy1268; -yy1398: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1396; - goto yy1268; -yy1399: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1268; - if (yych <= 0xBF) goto yy1398; - goto yy1268; -yy1400: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0xBF) goto yy1398; - goto yy1268; -yy1401: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x8F) goto yy1398; - goto yy1268; -yy1402: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1268; - if (yych <= 0x9F) goto yy1396; - goto yy1268; -yy1403: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '"') { - if (yych <= '\r') { - if (yych <= 0x00) goto yy1268; - if (yych <= 0x08) goto yy1375; - goto yy1403; - } else { - if (yych == ' ') goto yy1403; - if (yych <= '!') goto yy1375; - goto yy1268; - } - } else { - if (yych <= ':') { - if (yych == '\'') goto yy1268; - if (yych <= '9') goto yy1375; - } else { - if (yych <= ';') goto yy1375; - if (yych <= '=') goto yy1268; - if (yych <= '>') goto yy1285; - goto yy1375; - } - } - } else { - if (yych <= 0xDF) { - if (yych <= '`') { - if (yych <= 'Z') goto yy1405; - if (yych <= '^') goto yy1375; - if (yych >= '`') goto yy1268; - } else { - if (yych <= 'z') goto yy1405; - if (yych <= 0x7F) goto yy1375; - if (yych <= 0xC1) goto yy1268; - goto yy1377; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1378; - if (yych == 0xED) goto yy1383; - goto yy1379; - } else { - if (yych <= 0xF0) goto yy1380; - if (yych <= 0xF3) goto yy1381; - if (yych <= 0xF4) goto yy1382; - goto yy1268; - } - } - } -yy1405: - ++p; - yych = *p; - if (yych <= '>') { - if (yych <= '&') { - if (yych <= 0x1F) { - if (yych <= 0x00) goto yy1268; - if (yych <= 0x08) goto yy1375; - if (yych >= 0x0E) goto yy1375; - } else { - if (yych <= ' ') goto yy1407; - if (yych == '"') goto yy1268; - goto yy1375; - } - } else { - if (yych <= '/') { - if (yych <= '\'') goto yy1268; - if (yych <= ',') goto yy1375; - if (yych <= '.') goto yy1405; - goto yy1375; - } else { - if (yych <= ';') { - if (yych <= ':') goto yy1405; - goto yy1375; - } else { - if (yych <= '<') goto yy1268; - if (yych <= '=') goto yy1373; - goto yy1285; - } - } - } - } else { - if (yych <= 0xC1) { - if (yych <= '_') { - if (yych <= '@') goto yy1375; - if (yych <= 'Z') goto yy1405; - if (yych <= '^') goto yy1375; - goto yy1405; - } else { - if (yych <= '`') goto yy1268; - if (yych <= 'z') goto yy1405; - if (yych <= 0x7F) goto yy1375; - goto yy1268; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1377; - if (yych <= 0xE0) goto yy1378; - if (yych <= 0xEC) goto yy1379; - goto yy1383; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1379; - goto yy1380; - } else { - if (yych <= 0xF3) goto yy1381; - if (yych <= 0xF4) goto yy1382; - goto yy1268; - } - } - } - } -yy1407: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '&') { - if (yych <= 0x1F) { - if (yych <= 0x00) goto yy1268; - if (yych <= 0x08) goto yy1375; - if (yych <= '\r') goto yy1407; - goto yy1375; - } else { - if (yych <= ' ') goto yy1407; - if (yych == '"') goto yy1268; - goto yy1375; - } - } else { - if (yych <= ';') { - if (yych <= '\'') goto yy1268; - if (yych == ':') goto yy1405; - goto yy1375; - } else { - if (yych <= '<') goto yy1268; - if (yych <= '=') goto yy1373; - if (yych <= '>') goto yy1285; - goto yy1375; - } - } - } else { - if (yych <= 0xDF) { - if (yych <= '`') { - if (yych <= 'Z') goto yy1405; - if (yych <= '^') goto yy1375; - if (yych <= '_') goto yy1405; - goto yy1268; - } else { - if (yych <= 'z') goto yy1405; - if (yych <= 0x7F) goto yy1375; - if (yych <= 0xC1) goto yy1268; - goto yy1377; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1378; - if (yych == 0xED) goto yy1383; - goto yy1379; - } else { - if (yych <= 0xF0) goto yy1380; - if (yych <= 0xF3) goto yy1381; - if (yych <= 0xF4) goto yy1382; - goto yy1268; - } - } - } -yy1409: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '"') { - if (yych <= '\r') { - if (yych <= 0x00) goto yy1268; - if (yych <= 0x08) goto yy1375; - goto yy1409; - } else { - if (yych == ' ') goto yy1409; - if (yych <= '!') goto yy1375; - goto yy1386; - } - } else { - if (yych <= ':') { - if (yych == '\'') goto yy1384; - if (yych <= '9') goto yy1375; - goto yy1405; - } else { - if (yych <= ';') goto yy1375; - if (yych <= '=') goto yy1268; - if (yych <= '>') goto yy1285; - goto yy1375; - } - } - } else { - if (yych <= 0xDF) { - if (yych <= '`') { - if (yych <= 'Z') goto yy1405; - if (yych <= '^') goto yy1375; - if (yych <= '_') goto yy1405; - goto yy1268; - } else { - if (yych <= 'z') goto yy1405; - if (yych <= 0x7F) goto yy1375; - if (yych <= 0xC1) goto yy1268; - goto yy1377; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1378; - if (yych == 0xED) goto yy1383; - goto yy1379; - } else { - if (yych <= 0xF0) goto yy1380; - if (yych <= 0xF3) goto yy1381; - if (yych <= 0xF4) goto yy1382; - goto yy1268; - } - } - } -} - + { + 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, 254, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + /* 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); + if (yych <= '`') { + if (yych <= '.') { + if (yych <= '\n') { + if (yych <= '\t') + goto yy1266; + } else { + if (yych == '!') + goto yy1264; + goto yy1266; + } + } else { + if (yych <= '?') { + if (yych <= '/') + goto yy1263; + if (yych <= '>') + goto yy1266; + goto yy1265; + } else { + if (yych <= '@') + goto yy1266; + if (yych <= 'Z') + goto yy1262; + goto yy1266; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 'z') + goto yy1262; + if (yych <= 0x7F) + goto yy1266; + } else { + if (yych <= 0xDF) + goto yy1267; + if (yych <= 0xE0) + goto yy1269; + goto yy1270; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1274; + if (yych <= 0xEF) + goto yy1270; + goto yy1271; + } else { + if (yych <= 0xF3) + goto yy1272; + if (yych <= 0xF4) + goto yy1273; + } + } + } + yy1261 : { return 0; } + yy1262: + yych = *(marker = ++p); + if (yych <= '/') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1261; + if (yych <= '\r') + goto yy1366; + if (yych <= 0x1F) + goto yy1261; + goto yy1366; + } else { + if (yych == '-') + goto yy1364; + if (yych <= '.') + goto yy1261; + goto yy1368; + } + } else { + if (yych <= '@') { + if (yych <= '9') + goto yy1364; + if (yych == '>') + goto yy1285; + goto yy1261; + } else { + if (yych <= 'Z') + goto yy1364; + if (yych <= '`') + goto yy1261; + if (yych <= 'z') + goto yy1364; + goto yy1261; + } + } + yy1263: + yych = *(marker = ++p); + if (yych <= '@') + goto yy1261; + if (yych <= 'Z') + goto yy1360; + if (yych <= '`') + goto yy1261; + if (yych <= 'z') + goto yy1360; + goto yy1261; + yy1264: + yych = *(marker = ++p); + if (yybm[256 + yych] & 64) { + goto yy1295; + } + if (yych == '-') + goto yy1297; + if (yych <= '@') + goto yy1261; + if (yych <= '[') + goto yy1294; + goto yy1261; + yy1265: + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy1261; + if (yych <= 0x7F) + goto yy1276; + if (yych <= 0xC1) + goto yy1261; + if (yych <= 0xF4) + goto yy1276; + goto yy1261; + yy1266: + yych = *++p; + goto yy1261; + yy1267: + yych = *++p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1266; + yy1268: + p = marker; + goto yy1261; + yy1269: + yych = *++p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1267; + goto yy1268; + yy1270: + yych = *++p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1267; + goto yy1268; + yy1271: + yych = *++p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1270; + goto yy1268; + yy1272: + yych = *++p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1270; + goto yy1268; + yy1273: + yych = *++p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1270; + goto yy1268; + yy1274: + yych = *++p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1267; + goto yy1268; + yy1275: + ++p; + yych = *p; + yy1276: + if (yybm[256 + yych] & 32) { + goto yy1275; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy1268; + if (yych <= '?') + goto yy1284; + goto yy1268; + } else { + if (yych <= 0xDF) + goto yy1277; + if (yych <= 0xE0) + goto yy1278; + goto yy1279; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1283; + if (yych <= 0xEF) + goto yy1279; + goto yy1280; + } else { + if (yych <= 0xF3) + goto yy1281; + if (yych <= 0xF4) + goto yy1282; + goto yy1268; + } + } + yy1277: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1275; + goto yy1268; + yy1278: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1277; + goto yy1268; + yy1279: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1277; + goto yy1268; + yy1280: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1279; + goto yy1268; + yy1281: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1279; + goto yy1268; + yy1282: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1279; + goto yy1268; + yy1283: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1277; + goto yy1268; + yy1284: + ++p; + yych = *p; + if (yych <= 0xE0) { + if (yych <= '>') { + if (yych <= 0x00) + goto yy1268; + if (yych <= '=') + goto yy1275; + } else { + if (yych <= 0x7F) + goto yy1275; + if (yych <= 0xC1) + goto yy1268; + if (yych <= 0xDF) + goto yy1287; + goto yy1288; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1293; + goto yy1289; + } else { + if (yych <= 0xF0) + goto yy1290; + if (yych <= 0xF3) + goto yy1291; + if (yych <= 0xF4) + goto yy1292; + goto yy1268; + } + } + yy1285: + ++p; + { return (bufsize_t)(p - start); } + yy1287: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1275; + goto yy1268; + yy1288: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1287; + goto yy1268; + yy1289: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1287; + goto yy1268; + yy1290: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1289; + goto yy1268; + yy1291: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1289; + goto yy1268; + yy1292: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1289; + goto yy1268; + yy1293: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1287; + goto yy1268; + yy1294: + yych = *++p; + if (yych == 'C') + goto yy1330; + if (yych == 'c') + goto yy1330; + goto yy1268; + yy1295: + ++p; + yych = *p; + if (yybm[0 + yych] & 1) { + goto yy1319; + } + if (yych <= '@') + goto yy1268; + if (yych <= 'Z') + goto yy1295; + goto yy1268; + yy1297: + yych = *++p; + if (yych != '-') + goto yy1268; + yych = *++p; + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych != '-') + goto yy1301; + } else { + if (yych <= '>') + goto yy1268; + if (yych <= 0xC1) + goto yy1301; + if (yych <= 0xDF) + goto yy1302; + goto yy1303; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1308; + goto yy1304; + } else { + if (yych <= 0xF0) + goto yy1305; + if (yych <= 0xF3) + goto yy1306; + if (yych <= 0xF4) + goto yy1307; + goto yy1301; + } + } + yych = *++p; + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych == '-') + goto yy1318; + goto yy1301; + } else { + if (yych <= '>') + goto yy1268; + if (yych <= 0xC1) + goto yy1301; + if (yych <= 0xDF) + goto yy1302; + goto yy1303; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1308; + goto yy1304; + } else { + if (yych <= 0xF0) + goto yy1305; + if (yych <= 0xF3) + goto yy1306; + if (yych <= 0xF4) + goto yy1307; + goto yy1301; + } + } + yy1300: + ++p; + yych = *p; + yy1301: + if (yybm[256 + yych] & 128) { + goto yy1300; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy1268; + if (yych <= '-') + goto yy1309; + goto yy1268; + } else { + if (yych <= 0xDF) + goto yy1310; + if (yych <= 0xE0) + goto yy1311; + goto yy1312; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1316; + if (yych <= 0xEF) + goto yy1312; + goto yy1313; + } else { + if (yych <= 0xF3) + goto yy1314; + if (yych <= 0xF4) + goto yy1315; + goto yy1268; + } + } + yy1302: + yych = *++p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1300; + goto yy1268; + yy1303: + yych = *++p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1302; + goto yy1268; + yy1304: + yych = *++p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1302; + goto yy1268; + yy1305: + yych = *++p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1304; + goto yy1268; + yy1306: + yych = *++p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1304; + goto yy1268; + yy1307: + yych = *++p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1304; + goto yy1268; + yy1308: + yych = *++p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1302; + goto yy1268; + yy1309: + ++p; + yych = *p; + if (yybm[256 + yych] & 128) { + goto yy1300; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy1268; + if (yych <= '-') + goto yy1317; + goto yy1268; + } else { + if (yych <= 0xDF) + goto yy1310; + if (yych <= 0xE0) + goto yy1311; + goto yy1312; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1316; + if (yych <= 0xEF) + goto yy1312; + goto yy1313; + } else { + if (yych <= 0xF3) + goto yy1314; + if (yych <= 0xF4) + goto yy1315; + goto yy1268; + } + } + yy1310: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1300; + goto yy1268; + yy1311: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1310; + goto yy1268; + yy1312: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1310; + goto yy1268; + yy1313: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1312; + goto yy1268; + yy1314: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1312; + goto yy1268; + yy1315: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1312; + goto yy1268; + yy1316: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1310; + goto yy1268; + yy1317: + yych = *++p; + if (yych == '>') + goto yy1285; + goto yy1268; + yy1318: + yych = *++p; + if (yych == '>') + goto yy1285; + goto yy1268; + yy1319: + ++p; + yych = *p; + if (yybm[0 + yych] & 1) { + goto yy1319; + } + if (yych <= 0xE0) { + if (yych <= '>') { + if (yych <= 0x00) + goto yy1268; + if (yych >= '>') + goto yy1285; + } else { + if (yych <= 0x7F) + goto yy1321; + if (yych <= 0xC1) + goto yy1268; + if (yych <= 0xDF) + goto yy1323; + goto yy1324; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1329; + goto yy1325; + } else { + if (yych <= 0xF0) + goto yy1326; + if (yych <= 0xF3) + goto yy1327; + if (yych <= 0xF4) + goto yy1328; + goto yy1268; + } + } + yy1321: + ++p; + yych = *p; + if (yybm[0 + yych] & 2) { + goto yy1321; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy1268; + if (yych <= '>') + goto yy1285; + goto yy1268; + } else { + if (yych <= 0xDF) + goto yy1323; + if (yych <= 0xE0) + goto yy1324; + goto yy1325; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1329; + if (yych <= 0xEF) + goto yy1325; + goto yy1326; + } else { + if (yych <= 0xF3) + goto yy1327; + if (yych <= 0xF4) + goto yy1328; + goto yy1268; + } + } + yy1323: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1321; + goto yy1268; + yy1324: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1323; + goto yy1268; + yy1325: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1323; + goto yy1268; + yy1326: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1325; + goto yy1268; + yy1327: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1325; + goto yy1268; + yy1328: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1325; + goto yy1268; + yy1329: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1323; + goto yy1268; + yy1330: + yych = *++p; + if (yych == 'D') + goto yy1331; + if (yych != 'd') + goto yy1268; + yy1331: + yych = *++p; + if (yych == 'A') + goto yy1332; + if (yych != 'a') + goto yy1268; + yy1332: + yych = *++p; + if (yych == 'T') + goto yy1333; + if (yych != 't') + goto yy1268; + yy1333: + yych = *++p; + if (yych == 'A') + goto yy1334; + if (yych != 'a') + goto yy1268; + yy1334: + yych = *++p; + if (yych != '[') + goto yy1268; + yy1335: + ++p; + yych = *p; + if (yybm[0 + yych] & 4) { + goto yy1335; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy1268; + if (yych <= ']') + goto yy1344; + goto yy1268; + } else { + if (yych <= 0xDF) + goto yy1337; + if (yych <= 0xE0) + goto yy1338; + goto yy1339; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1343; + if (yych <= 0xEF) + goto yy1339; + goto yy1340; + } else { + if (yych <= 0xF3) + goto yy1341; + if (yych <= 0xF4) + goto yy1342; + goto yy1268; + } + } + yy1337: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1335; + goto yy1268; + yy1338: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1337; + goto yy1268; + yy1339: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1337; + goto yy1268; + yy1340: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1339; + goto yy1268; + yy1341: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1339; + goto yy1268; + yy1342: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1339; + goto yy1268; + yy1343: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1337; + goto yy1268; + yy1344: + ++p; + yych = *p; + if (yybm[0 + yych] & 4) { + goto yy1335; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy1268; + if (yych >= '^') + goto yy1268; + } else { + if (yych <= 0xDF) + goto yy1346; + if (yych <= 0xE0) + goto yy1347; + goto yy1348; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1352; + if (yych <= 0xEF) + goto yy1348; + goto yy1349; + } else { + if (yych <= 0xF3) + goto yy1350; + if (yych <= 0xF4) + goto yy1351; + goto yy1268; + } + } + ++p; + yych = *p; + if (yych <= 0xE0) { + if (yych <= '>') { + if (yych <= 0x00) + goto yy1268; + if (yych <= '=') + goto yy1335; + goto yy1285; + } else { + if (yych <= 0x7F) + goto yy1335; + if (yych <= 0xC1) + goto yy1268; + if (yych <= 0xDF) + goto yy1353; + goto yy1354; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1359; + goto yy1355; + } else { + if (yych <= 0xF0) + goto yy1356; + if (yych <= 0xF3) + goto yy1357; + if (yych <= 0xF4) + goto yy1358; + goto yy1268; + } + } + yy1346: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1335; + goto yy1268; + yy1347: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1346; + goto yy1268; + yy1348: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1346; + goto yy1268; + yy1349: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1348; + goto yy1268; + yy1350: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1348; + goto yy1268; + yy1351: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1348; + goto yy1268; + yy1352: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1346; + goto yy1268; + yy1353: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1335; + goto yy1268; + yy1354: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1353; + goto yy1268; + yy1355: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1353; + goto yy1268; + yy1356: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1355; + goto yy1268; + yy1357: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1355; + goto yy1268; + yy1358: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1355; + goto yy1268; + yy1359: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1353; + goto yy1268; + yy1360: + ++p; + yych = *p; + if (yybm[0 + yych] & 8) { + goto yy1360; + } + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1268; + if (yych >= 0x0E) + goto yy1268; + } else { + if (yych <= ' ') + goto yy1362; + if (yych == '>') + goto yy1285; + goto yy1268; + } + yy1362: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1268; + if (yych <= '\r') + goto yy1362; + goto yy1268; + } else { + if (yych <= ' ') + goto yy1362; + if (yych == '>') + goto yy1285; + goto yy1268; + } + yy1364: + ++p; + yych = *p; + if (yych <= '/') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1268; + if (yych <= '\r') + goto yy1366; + if (yych <= 0x1F) + goto yy1268; + } else { + if (yych == '-') + goto yy1364; + if (yych <= '.') + goto yy1268; + goto yy1368; + } + } else { + if (yych <= '@') { + if (yych <= '9') + goto yy1364; + if (yych == '>') + goto yy1285; + goto yy1268; + } else { + if (yych <= 'Z') + goto yy1364; + if (yych <= '`') + goto yy1268; + if (yych <= 'z') + goto yy1364; + goto yy1268; + } + } + yy1366: + ++p; + yych = *p; + if (yych <= ':') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1268; + if (yych <= '\r') + goto yy1366; + if (yych <= 0x1F) + goto yy1268; + goto yy1366; + } else { + if (yych == '/') + goto yy1368; + if (yych <= '9') + goto yy1268; + goto yy1369; + } + } else { + if (yych <= 'Z') { + if (yych == '>') + goto yy1285; + if (yych <= '@') + goto yy1268; + goto yy1369; + } else { + if (yych <= '_') { + if (yych <= '^') + goto yy1268; + goto yy1369; + } else { + if (yych <= '`') + goto yy1268; + if (yych <= 'z') + goto yy1369; + goto yy1268; + } + } + } + yy1368: + yych = *++p; + if (yych == '>') + goto yy1285; + goto yy1268; + yy1369: + ++p; + yych = *p; + if (yybm[0 + yych] & 16) { + goto yy1369; + } + if (yych <= ',') { + if (yych <= '\r') { + if (yych <= 0x08) + goto yy1268; + } else { + if (yych != ' ') + goto yy1268; + } + } else { + if (yych <= '<') { + if (yych <= '/') + goto yy1368; + goto yy1268; + } else { + if (yych <= '=') + goto yy1373; + if (yych <= '>') + goto yy1285; + goto yy1268; + } + } + yy1371: + ++p; + yych = *p; + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1268; + if (yych <= '\r') + goto yy1371; + if (yych <= 0x1F) + goto yy1268; + goto yy1371; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy1268; + goto yy1368; + } else { + if (yych == ':') + goto yy1369; + goto yy1268; + } + } + } else { + if (yych <= 'Z') { + if (yych <= '=') + goto yy1373; + if (yych <= '>') + goto yy1285; + if (yych <= '@') + goto yy1268; + goto yy1369; + } else { + if (yych <= '_') { + if (yych <= '^') + goto yy1268; + goto yy1369; + } else { + if (yych <= '`') + goto yy1268; + if (yych <= 'z') + goto yy1369; + goto yy1268; + } + } + } + yy1373: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy1375; + } + if (yych <= 0xE0) { + if (yych <= '"') { + if (yych <= 0x00) + goto yy1268; + if (yych >= '!') + goto yy1386; + } else { + if (yych <= '\'') + goto yy1384; + if (yych <= 0xC1) + goto yy1268; + if (yych <= 0xDF) + goto yy1377; + goto yy1378; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1383; + goto yy1379; + } else { + if (yych <= 0xF0) + goto yy1380; + if (yych <= 0xF3) + goto yy1381; + if (yych <= 0xF4) + goto yy1382; + goto yy1268; + } + } + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy1375; + } + if (yych <= 0xDF) { + if (yych <= '\'') { + if (yych <= 0x00) + goto yy1268; + if (yych <= ' ') + goto yy1409; + if (yych <= '"') + goto yy1386; + goto yy1384; + } else { + if (yych == '>') + goto yy1285; + if (yych <= 0xC1) + goto yy1268; + goto yy1377; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1378; + if (yych == 0xED) + goto yy1383; + goto yy1379; + } else { + if (yych <= 0xF0) + goto yy1380; + if (yych <= 0xF3) + goto yy1381; + if (yych <= 0xF4) + goto yy1382; + goto yy1268; + } + } + yy1375: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy1375; + } + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy1268; + if (yych <= ' ') + goto yy1403; + goto yy1268; + } else { + if (yych <= '>') + goto yy1285; + if (yych <= 0xC1) + goto yy1268; + if (yych >= 0xE0) + goto yy1378; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1383; + goto yy1379; + } else { + if (yych <= 0xF0) + goto yy1380; + if (yych <= 0xF3) + goto yy1381; + if (yych <= 0xF4) + goto yy1382; + goto yy1268; + } + } + yy1377: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1375; + goto yy1268; + yy1378: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1377; + goto yy1268; + yy1379: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1377; + goto yy1268; + yy1380: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1379; + goto yy1268; + yy1381: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1379; + goto yy1268; + yy1382: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1379; + goto yy1268; + yy1383: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1377; + goto yy1268; + yy1384: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1384; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy1268; + if (yych <= '\'') + goto yy1395; + goto yy1268; + } else { + if (yych <= 0xDF) + goto yy1396; + if (yych <= 0xE0) + goto yy1397; + goto yy1398; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1402; + if (yych <= 0xEF) + goto yy1398; + goto yy1399; + } else { + if (yych <= 0xF3) + goto yy1400; + if (yych <= 0xF4) + goto yy1401; + goto yy1268; + } + } + yy1386: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1386; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy1268; + if (yych <= '"') + goto yy1395; + goto yy1268; + } else { + if (yych <= 0xDF) + goto yy1388; + if (yych <= 0xE0) + goto yy1389; + goto yy1390; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1394; + if (yych <= 0xEF) + goto yy1390; + goto yy1391; + } else { + if (yych <= 0xF3) + goto yy1392; + if (yych <= 0xF4) + goto yy1393; + goto yy1268; + } + } + yy1388: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1386; + goto yy1268; + yy1389: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1388; + goto yy1268; + yy1390: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1388; + goto yy1268; + yy1391: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1390; + goto yy1268; + yy1392: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1390; + goto yy1268; + yy1393: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1390; + goto yy1268; + yy1394: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1388; + goto yy1268; + yy1395: + ++p; + yych = *p; + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1268; + if (yych <= '\r') + goto yy1366; + if (yych <= 0x1F) + goto yy1268; + goto yy1366; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy1268; + goto yy1368; + } else { + if (yych == '>') + goto yy1285; + goto yy1268; + } + } + yy1396: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1384; + goto yy1268; + yy1397: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1268; + if (yych <= 0xBF) + goto yy1396; + goto yy1268; + yy1398: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1396; + goto yy1268; + yy1399: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1268; + if (yych <= 0xBF) + goto yy1398; + goto yy1268; + yy1400: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0xBF) + goto yy1398; + goto yy1268; + yy1401: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x8F) + goto yy1398; + goto yy1268; + yy1402: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1268; + if (yych <= 0x9F) + goto yy1396; + goto yy1268; + yy1403: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '"') { + if (yych <= '\r') { + if (yych <= 0x00) + goto yy1268; + if (yych <= 0x08) + goto yy1375; + goto yy1403; + } else { + if (yych == ' ') + goto yy1403; + if (yych <= '!') + goto yy1375; + goto yy1268; + } + } else { + if (yych <= ':') { + if (yych == '\'') + goto yy1268; + if (yych <= '9') + goto yy1375; + } else { + if (yych <= ';') + goto yy1375; + if (yych <= '=') + goto yy1268; + if (yych <= '>') + goto yy1285; + goto yy1375; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') + goto yy1405; + if (yych <= '^') + goto yy1375; + if (yych >= '`') + goto yy1268; + } else { + if (yych <= 'z') + goto yy1405; + if (yych <= 0x7F) + goto yy1375; + if (yych <= 0xC1) + goto yy1268; + goto yy1377; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1378; + if (yych == 0xED) + goto yy1383; + goto yy1379; + } else { + if (yych <= 0xF0) + goto yy1380; + if (yych <= 0xF3) + goto yy1381; + if (yych <= 0xF4) + goto yy1382; + goto yy1268; + } + } + } + yy1405: + ++p; + yych = *p; + if (yych <= '>') { + if (yych <= '&') { + if (yych <= 0x1F) { + if (yych <= 0x00) + goto yy1268; + if (yych <= 0x08) + goto yy1375; + if (yych >= 0x0E) + goto yy1375; + } else { + if (yych <= ' ') + goto yy1407; + if (yych == '"') + goto yy1268; + goto yy1375; + } + } else { + if (yych <= '/') { + if (yych <= '\'') + goto yy1268; + if (yych <= ',') + goto yy1375; + if (yych <= '.') + goto yy1405; + goto yy1375; + } else { + if (yych <= ';') { + if (yych <= ':') + goto yy1405; + goto yy1375; + } else { + if (yych <= '<') + goto yy1268; + if (yych <= '=') + goto yy1373; + goto yy1285; + } + } + } + } else { + if (yych <= 0xC1) { + if (yych <= '_') { + if (yych <= '@') + goto yy1375; + if (yych <= 'Z') + goto yy1405; + if (yych <= '^') + goto yy1375; + goto yy1405; + } else { + if (yych <= '`') + goto yy1268; + if (yych <= 'z') + goto yy1405; + if (yych <= 0x7F) + goto yy1375; + goto yy1268; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1377; + if (yych <= 0xE0) + goto yy1378; + if (yych <= 0xEC) + goto yy1379; + goto yy1383; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1379; + goto yy1380; + } else { + if (yych <= 0xF3) + goto yy1381; + if (yych <= 0xF4) + goto yy1382; + goto yy1268; + } + } + } + } + yy1407: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '&') { + if (yych <= 0x1F) { + if (yych <= 0x00) + goto yy1268; + if (yych <= 0x08) + goto yy1375; + if (yych <= '\r') + goto yy1407; + goto yy1375; + } else { + if (yych <= ' ') + goto yy1407; + if (yych == '"') + goto yy1268; + goto yy1375; + } + } else { + if (yych <= ';') { + if (yych <= '\'') + goto yy1268; + if (yych == ':') + goto yy1405; + goto yy1375; + } else { + if (yych <= '<') + goto yy1268; + if (yych <= '=') + goto yy1373; + if (yych <= '>') + goto yy1285; + goto yy1375; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') + goto yy1405; + if (yych <= '^') + goto yy1375; + if (yych <= '_') + goto yy1405; + goto yy1268; + } else { + if (yych <= 'z') + goto yy1405; + if (yych <= 0x7F) + goto yy1375; + if (yych <= 0xC1) + goto yy1268; + goto yy1377; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1378; + if (yych == 0xED) + goto yy1383; + goto yy1379; + } else { + if (yych <= 0xF0) + goto yy1380; + if (yych <= 0xF3) + goto yy1381; + if (yych <= 0xF4) + goto yy1382; + goto yy1268; + } + } + } + yy1409: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '"') { + if (yych <= '\r') { + if (yych <= 0x00) + goto yy1268; + if (yych <= 0x08) + goto yy1375; + goto yy1409; + } else { + if (yych == ' ') + goto yy1409; + if (yych <= '!') + goto yy1375; + goto yy1386; + } + } else { + if (yych <= ':') { + if (yych == '\'') + goto yy1384; + if (yych <= '9') + goto yy1375; + goto yy1405; + } else { + if (yych <= ';') + goto yy1375; + if (yych <= '=') + goto yy1268; + if (yych <= '>') + goto yy1285; + goto yy1375; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') + goto yy1405; + if (yych <= '^') + goto yy1375; + if (yych <= '_') + goto yy1405; + goto yy1268; + } else { + if (yych <= 'z') + goto yy1405; + if (yych <= 0x7F) + goto yy1375; + if (yych <= 0xC1) + goto yy1268; + goto yy1377; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1378; + if (yych == 0xED) + goto yy1383; + goto yy1379; + } else { + if (yych <= 0xF0) + goto yy1380; + if (yych <= 0xF3) + goto yy1381; + if (yych <= 0xF4) + goto yy1382; + goto yy1268; + } + } + } + } } // Try to match an HTML block tag start line, returning // an integer code for the type of block (1-6, matching the spec). // #7 is handled by a separate function, below. -bufsize_t _scan_html_block_start(const unsigned char *p) -{ +bufsize_t _scan_html_block_start(const unsigned char *p) { const unsigned char *marker = NULL; -{ - unsigned char yych; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= ';') { - if (yych != '\n') goto yy1415; - } else { - if (yych <= '<') goto yy1414; - if (yych <= 0x7F) goto yy1415; - if (yych >= 0xC2) goto yy1416; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1418; - if (yych == 0xED) goto yy1423; - goto yy1419; - } else { - if (yych <= 0xF0) goto yy1420; - if (yych <= 0xF3) goto yy1421; - if (yych <= 0xF4) goto yy1422; - } - } -yy1413: - { return 0; } -yy1414: - yych = *(marker = ++p); - switch (yych) { - case '!': goto yy1439; - case '/': goto yy1424; - case '?': goto yy1440; - case 'A': - case 'a': goto yy1426; - case 'B': - case 'b': goto yy1427; - case 'C': - case 'c': goto yy1428; - case 'D': - case 'd': goto yy1429; - case 'F': - case 'f': goto yy1430; - case 'H': - case 'h': goto yy1431; - case 'L': - case 'l': goto yy1432; - case 'M': - case 'm': goto yy1433; - case 'N': - case 'n': goto yy1434; - case 'O': - case 'o': goto yy1435; - case 'P': - case 'p': goto yy1425; - case 'S': - case 's': goto yy1436; - case 'T': - case 't': goto yy1437; - case 'U': - case 'u': goto yy1438; - default: goto yy1413; - } -yy1415: - yych = *++p; - goto yy1413; -yy1416: - yych = *++p; - if (yych <= 0x7F) goto yy1417; - if (yych <= 0xBF) goto yy1415; -yy1417: - p = marker; - goto yy1413; -yy1418: - yych = *++p; - if (yych <= 0x9F) goto yy1417; - if (yych <= 0xBF) goto yy1416; - goto yy1417; -yy1419: - yych = *++p; - if (yych <= 0x7F) goto yy1417; - if (yych <= 0xBF) goto yy1416; - goto yy1417; -yy1420: - yych = *++p; - if (yych <= 0x8F) goto yy1417; - if (yych <= 0xBF) goto yy1419; - goto yy1417; -yy1421: - yych = *++p; - if (yych <= 0x7F) goto yy1417; - if (yych <= 0xBF) goto yy1419; - goto yy1417; -yy1422: - yych = *++p; - if (yych <= 0x7F) goto yy1417; - if (yych <= 0x8F) goto yy1419; - goto yy1417; -yy1423: - yych = *++p; - if (yych <= 0x7F) goto yy1417; - if (yych <= 0x9F) goto yy1416; - goto yy1417; -yy1424: - yych = *++p; - switch (yych) { - case 'A': - case 'a': goto yy1426; - case 'B': - case 'b': goto yy1427; - case 'C': - case 'c': goto yy1428; - case 'D': - case 'd': goto yy1429; - case 'F': - case 'f': goto yy1430; - case 'H': - case 'h': goto yy1431; - case 'L': - case 'l': goto yy1432; - case 'M': - case 'm': goto yy1433; - case 'N': - case 'n': goto yy1434; - case 'O': - case 'o': goto yy1435; - case 'P': - case 'p': goto yy1622; - case 'S': - case 's': goto yy1623; - case 'T': - case 't': goto yy1437; - case 'U': - case 'u': goto yy1438; - default: goto yy1417; - } -yy1425: - yych = *++p; - if (yych <= '>') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - if (yych <= 0x1F) goto yy1417; - goto yy1456; - } else { - if (yych == '/') goto yy1458; - if (yych <= '=') goto yy1417; - goto yy1456; - } - } else { - if (yych <= 'R') { - if (yych == 'A') goto yy1617; - if (yych <= 'Q') goto yy1417; - goto yy1616; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy1417; - goto yy1617; - } else { - if (yych == 'r') goto yy1616; - goto yy1417; - } - } - } -yy1426: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'D') { - if (yych <= 'C') goto yy1417; - goto yy1605; - } else { - if (yych <= 'Q') goto yy1417; - if (yych <= 'R') goto yy1604; - goto yy1603; - } - } else { - if (yych <= 'q') { - if (yych == 'd') goto yy1605; - goto yy1417; - } else { - if (yych <= 'r') goto yy1604; - if (yych <= 's') goto yy1603; - goto yy1417; - } - } -yy1427: - yych = *++p; - if (yych <= 'O') { - if (yych <= 'K') { - if (yych == 'A') goto yy1589; - goto yy1417; - } else { - if (yych <= 'L') goto yy1588; - if (yych <= 'N') goto yy1417; - goto yy1587; - } - } else { - if (yych <= 'k') { - if (yych == 'a') goto yy1589; - goto yy1417; - } else { - if (yych <= 'l') goto yy1588; - if (yych == 'o') goto yy1587; - goto yy1417; - } - } -yy1428: - yych = *++p; - if (yych <= 'O') { - if (yych <= 'D') { - if (yych == 'A') goto yy1574; - goto yy1417; - } else { - if (yych <= 'E') goto yy1573; - if (yych <= 'N') goto yy1417; - goto yy1572; - } - } else { - if (yych <= 'd') { - if (yych == 'a') goto yy1574; - goto yy1417; - } else { - if (yych <= 'e') goto yy1573; - if (yych == 'o') goto yy1572; - goto yy1417; - } - } -yy1429: - yych = *++p; - switch (yych) { - case 'D': - case 'L': - case 'T': - case 'd': - case 'l': - case 't': goto yy1455; - case 'E': - case 'e': goto yy1564; - case 'I': - case 'i': goto yy1563; - default: goto yy1417; - } -yy1430: - yych = *++p; - if (yych <= 'R') { - if (yych <= 'N') { - if (yych == 'I') goto yy1539; - goto yy1417; - } else { - if (yych <= 'O') goto yy1538; - if (yych <= 'Q') goto yy1417; - goto yy1537; - } - } else { - if (yych <= 'n') { - if (yych == 'i') goto yy1539; - goto yy1417; - } else { - if (yych <= 'o') goto yy1538; - if (yych == 'r') goto yy1537; - goto yy1417; - } - } -yy1431: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'D') { - if (yych == '1') goto yy1455; - goto yy1417; - } else { - if (yych <= 'E') goto yy1532; - if (yych == 'R') goto yy1455; - goto yy1417; - } - } else { - if (yych <= 'q') { - if (yych <= 'T') goto yy1531; - if (yych == 'e') goto yy1532; - goto yy1417; - } else { - if (yych <= 'r') goto yy1455; - if (yych == 't') goto yy1531; - goto yy1417; - } - } -yy1432: - yych = *++p; - if (yych <= 'I') { - if (yych == 'E') goto yy1526; - if (yych <= 'H') goto yy1417; - goto yy1525; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy1417; - goto yy1526; - } else { - if (yych == 'i') goto yy1525; - goto yy1417; - } - } -yy1433: - yych = *++p; - if (yych <= 'E') { - if (yych == 'A') goto yy1517; - if (yych <= 'D') goto yy1417; - goto yy1516; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy1417; - goto yy1517; - } else { - if (yych == 'e') goto yy1516; - goto yy1417; - } - } -yy1434: - yych = *++p; - if (yych <= 'O') { - if (yych == 'A') goto yy1510; - if (yych <= 'N') goto yy1417; - goto yy1509; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy1417; - goto yy1510; - } else { - if (yych == 'o') goto yy1509; - goto yy1417; - } - } -yy1435: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') goto yy1455; - if (yych <= 'O') goto yy1417; - goto yy1501; - } else { - if (yych <= 'l') { - if (yych <= 'k') goto yy1417; - goto yy1455; - } else { - if (yych == 'p') goto yy1501; - goto yy1417; - } - } -yy1436: - yych = *++p; - if (yych <= 'U') { - if (yych <= 'E') { - if (yych == 'C') goto yy1478; - if (yych <= 'D') goto yy1417; - goto yy1481; - } else { - if (yych <= 'O') { - if (yych <= 'N') goto yy1417; - goto yy1480; - } else { - if (yych <= 'S') goto yy1417; - if (yych <= 'T') goto yy1477; - goto yy1479; - } - } - } else { - if (yych <= 'n') { - if (yych <= 'c') { - if (yych <= 'b') goto yy1417; - goto yy1478; - } else { - if (yych == 'e') goto yy1481; - goto yy1417; - } - } else { - if (yych <= 's') { - if (yych <= 'o') goto yy1480; - goto yy1417; - } else { - if (yych <= 't') goto yy1477; - if (yych <= 'u') goto yy1479; - goto yy1417; - } - } - } -yy1437: - yych = *++p; - switch (yych) { - case 'A': - case 'a': goto yy1464; - case 'B': - case 'b': goto yy1463; - case 'D': - case 'd': goto yy1455; - case 'F': - case 'f': goto yy1462; - case 'H': - case 'h': goto yy1461; - case 'I': - case 'i': goto yy1460; - case 'R': - case 'r': goto yy1459; - default: goto yy1417; - } -yy1438: - yych = *++p; - if (yych == 'L') goto yy1455; - if (yych == 'l') goto yy1455; - goto yy1417; -yy1439: - yych = *++p; - if (yych <= '@') { - if (yych == '-') goto yy1442; - goto yy1417; - } else { - if (yych <= 'Z') goto yy1443; - if (yych <= '[') goto yy1445; - goto yy1417; - } -yy1440: - ++p; - { return 3; } -yy1442: - yych = *++p; - if (yych == '-') goto yy1453; - goto yy1417; -yy1443: - ++p; - { return 4; } -yy1445: - yych = *++p; - if (yych == 'C') goto yy1446; - if (yych != 'c') goto yy1417; -yy1446: - yych = *++p; - if (yych == 'D') goto yy1447; - if (yych != 'd') goto yy1417; -yy1447: - yych = *++p; - if (yych == 'A') goto yy1448; - if (yych != 'a') goto yy1417; -yy1448: - yych = *++p; - if (yych == 'T') goto yy1449; - if (yych != 't') goto yy1417; -yy1449: - yych = *++p; - if (yych == 'A') goto yy1450; - if (yych != 'a') goto yy1417; -yy1450: - yych = *++p; - if (yych != '[') goto yy1417; - ++p; - { return 5; } -yy1453: - ++p; - { return 2; } -yy1455: - yych = *++p; - if (yych <= ' ') { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - if (yych <= 0x1F) goto yy1417; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy1417; - goto yy1458; - } else { - if (yych != '>') goto yy1417; - } - } -yy1456: - ++p; - { return 6; } -yy1458: - yych = *++p; - if (yych == '>') goto yy1456; - goto yy1417; -yy1459: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - goto yy1417; - } else { - if (yych <= ' ') goto yy1456; - if (yych <= '.') goto yy1417; - goto yy1458; - } - } else { - if (yych <= '@') { - if (yych == '>') goto yy1456; - goto yy1417; - } else { - if (yych <= 'A') goto yy1475; - if (yych == 'a') goto yy1475; - goto yy1417; - } - } -yy1460: - yych = *++p; - if (yych == 'T') goto yy1473; - if (yych == 't') goto yy1473; - goto yy1417; -yy1461: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - goto yy1417; - } else { - if (yych <= ' ') goto yy1456; - if (yych <= '.') goto yy1417; - goto yy1458; - } - } else { - if (yych <= 'D') { - if (yych == '>') goto yy1456; - goto yy1417; - } else { - if (yych <= 'E') goto yy1471; - if (yych == 'e') goto yy1471; - goto yy1417; - } - } -yy1462: - yych = *++p; - if (yych == 'O') goto yy1469; - if (yych == 'o') goto yy1469; - goto yy1417; -yy1463: - yych = *++p; - if (yych == 'O') goto yy1467; - if (yych == 'o') goto yy1467; - goto yy1417; -yy1464: - yych = *++p; - if (yych == 'B') goto yy1465; - if (yych != 'b') goto yy1417; -yy1465: - yych = *++p; - if (yych == 'L') goto yy1466; - if (yych != 'l') goto yy1417; -yy1466: - yych = *++p; - if (yych == 'E') goto yy1455; - if (yych == 'e') goto yy1455; - goto yy1417; -yy1467: - yych = *++p; - if (yych == 'D') goto yy1468; - if (yych != 'd') goto yy1417; -yy1468: - yych = *++p; - if (yych == 'Y') goto yy1455; - if (yych == 'y') goto yy1455; - goto yy1417; -yy1469: - yych = *++p; - if (yych == 'O') goto yy1470; - if (yych != 'o') goto yy1417; -yy1470: - yych = *++p; - if (yych == 'T') goto yy1455; - if (yych == 't') goto yy1455; - goto yy1417; -yy1471: - yych = *++p; - if (yych == 'A') goto yy1472; - if (yych != 'a') goto yy1417; -yy1472: - yych = *++p; - if (yych == 'D') goto yy1455; - if (yych == 'd') goto yy1455; - goto yy1417; -yy1473: - yych = *++p; - if (yych == 'L') goto yy1474; - if (yych != 'l') goto yy1417; -yy1474: - yych = *++p; - if (yych == 'E') goto yy1455; - if (yych == 'e') goto yy1455; - goto yy1417; -yy1475: - yych = *++p; - if (yych == 'C') goto yy1476; - if (yych != 'c') goto yy1417; -yy1476: - yych = *++p; - if (yych == 'K') goto yy1455; - if (yych == 'k') goto yy1455; - goto yy1417; -yy1477: - yych = *++p; - if (yych == 'Y') goto yy1499; - if (yych == 'y') goto yy1499; - goto yy1417; -yy1478: - yych = *++p; - if (yych == 'R') goto yy1493; - if (yych == 'r') goto yy1493; - goto yy1417; -yy1479: - yych = *++p; - if (yych == 'M') goto yy1489; - if (yych == 'm') goto yy1489; - goto yy1417; -yy1480: - yych = *++p; - if (yych == 'U') goto yy1486; - if (yych == 'u') goto yy1486; - goto yy1417; -yy1481: - yych = *++p; - if (yych == 'C') goto yy1482; - if (yych != 'c') goto yy1417; -yy1482: - yych = *++p; - if (yych == 'T') goto yy1483; - if (yych != 't') goto yy1417; -yy1483: - yych = *++p; - if (yych == 'I') goto yy1484; - if (yych != 'i') goto yy1417; -yy1484: - yych = *++p; - if (yych == 'O') goto yy1485; - if (yych != 'o') goto yy1417; -yy1485: - yych = *++p; - if (yych == 'N') goto yy1455; - if (yych == 'n') goto yy1455; - goto yy1417; -yy1486: - yych = *++p; - if (yych == 'R') goto yy1487; - if (yych != 'r') goto yy1417; -yy1487: - yych = *++p; - if (yych == 'C') goto yy1488; - if (yych != 'c') goto yy1417; -yy1488: - yych = *++p; - if (yych == 'E') goto yy1455; - if (yych == 'e') goto yy1455; - goto yy1417; -yy1489: - yych = *++p; - if (yych == 'M') goto yy1490; - if (yych != 'm') goto yy1417; -yy1490: - yych = *++p; - if (yych == 'A') goto yy1491; - if (yych != 'a') goto yy1417; -yy1491: - yych = *++p; - if (yych == 'R') goto yy1492; - if (yych != 'r') goto yy1417; -yy1492: - yych = *++p; - if (yych == 'Y') goto yy1455; - if (yych == 'y') goto yy1455; - goto yy1417; -yy1493: - yych = *++p; - if (yych == 'I') goto yy1494; - if (yych != 'i') goto yy1417; -yy1494: - yych = *++p; - if (yych == 'P') goto yy1495; - if (yych != 'p') goto yy1417; -yy1495: - yych = *++p; - if (yych == 'T') goto yy1496; - if (yych != 't') goto yy1417; -yy1496: - yych = *++p; - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1417; - if (yych >= 0x0E) goto yy1417; - } else { - if (yych <= ' ') goto yy1497; - if (yych != '>') goto yy1417; - } -yy1497: - ++p; -yy1498: - { return 1; } -yy1499: - yych = *++p; - if (yych == 'L') goto yy1500; - if (yych != 'l') goto yy1417; -yy1500: - yych = *++p; - if (yych == 'E') goto yy1496; - if (yych == 'e') goto yy1496; - goto yy1417; -yy1501: - yych = *++p; - if (yych == 'T') goto yy1502; - if (yych != 't') goto yy1417; -yy1502: - yych = *++p; - if (yych <= 'I') { - if (yych == 'G') goto yy1504; - if (yych <= 'H') goto yy1417; - } else { - if (yych <= 'g') { - if (yych <= 'f') goto yy1417; - goto yy1504; - } else { - if (yych != 'i') goto yy1417; - } - } - yych = *++p; - if (yych == 'O') goto yy1508; - if (yych == 'o') goto yy1508; - goto yy1417; -yy1504: - yych = *++p; - if (yych == 'R') goto yy1505; - if (yych != 'r') goto yy1417; -yy1505: - yych = *++p; - if (yych == 'O') goto yy1506; - if (yych != 'o') goto yy1417; -yy1506: - yych = *++p; - if (yych == 'U') goto yy1507; - if (yych != 'u') goto yy1417; -yy1507: - yych = *++p; - if (yych == 'P') goto yy1455; - if (yych == 'p') goto yy1455; - goto yy1417; -yy1508: - yych = *++p; - if (yych == 'N') goto yy1455; - if (yych == 'n') goto yy1455; - goto yy1417; -yy1509: - yych = *++p; - if (yych == 'F') goto yy1511; - if (yych == 'f') goto yy1511; - goto yy1417; -yy1510: - yych = *++p; - if (yych == 'V') goto yy1455; - if (yych == 'v') goto yy1455; - goto yy1417; -yy1511: - yych = *++p; - if (yych == 'R') goto yy1512; - if (yych != 'r') goto yy1417; -yy1512: - yych = *++p; - if (yych == 'A') goto yy1513; - if (yych != 'a') goto yy1417; -yy1513: - yych = *++p; - if (yych == 'M') goto yy1514; - if (yych != 'm') goto yy1417; -yy1514: - yych = *++p; - if (yych == 'E') goto yy1515; - if (yych != 'e') goto yy1417; -yy1515: - yych = *++p; - if (yych == 'S') goto yy1455; - if (yych == 's') goto yy1455; - goto yy1417; -yy1516: - yych = *++p; - if (yych <= 'T') { - if (yych == 'N') goto yy1519; - if (yych <= 'S') goto yy1417; - goto yy1520; - } else { - if (yych <= 'n') { - if (yych <= 'm') goto yy1417; - goto yy1519; - } else { - if (yych == 't') goto yy1520; - goto yy1417; - } - } -yy1517: - yych = *++p; - if (yych == 'I') goto yy1518; - if (yych != 'i') goto yy1417; -yy1518: - yych = *++p; - if (yych == 'N') goto yy1455; - if (yych == 'n') goto yy1455; - goto yy1417; -yy1519: - yych = *++p; - if (yych == 'U') goto yy1521; - if (yych == 'u') goto yy1521; - goto yy1417; -yy1520: - yych = *++p; - if (yych == 'A') goto yy1455; - if (yych == 'a') goto yy1455; - goto yy1417; -yy1521: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - goto yy1417; - } else { - if (yych <= ' ') goto yy1456; - if (yych <= '.') goto yy1417; - goto yy1458; - } - } else { - if (yych <= 'H') { - if (yych == '>') goto yy1456; - goto yy1417; - } else { - if (yych <= 'I') goto yy1522; - if (yych != 'i') goto yy1417; - } - } -yy1522: - yych = *++p; - if (yych == 'T') goto yy1523; - if (yych != 't') goto yy1417; -yy1523: - yych = *++p; - if (yych == 'E') goto yy1524; - if (yych != 'e') goto yy1417; -yy1524: - yych = *++p; - if (yych == 'M') goto yy1455; - if (yych == 'm') goto yy1455; - goto yy1417; -yy1525: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - goto yy1417; - } else { - if (yych <= ' ') goto yy1456; - if (yych <= '.') goto yy1417; - goto yy1458; - } - } else { - if (yych <= 'M') { - if (yych == '>') goto yy1456; - goto yy1417; - } else { - if (yych <= 'N') goto yy1530; - if (yych == 'n') goto yy1530; - goto yy1417; - } - } -yy1526: - yych = *++p; - if (yych == 'G') goto yy1527; - if (yych != 'g') goto yy1417; -yy1527: - yych = *++p; - if (yych == 'E') goto yy1528; - if (yych != 'e') goto yy1417; -yy1528: - yych = *++p; - if (yych == 'N') goto yy1529; - if (yych != 'n') goto yy1417; -yy1529: - yych = *++p; - if (yych == 'D') goto yy1455; - if (yych == 'd') goto yy1455; - goto yy1417; -yy1530: - yych = *++p; - if (yych == 'K') goto yy1455; - if (yych == 'k') goto yy1455; - goto yy1417; -yy1531: - yych = *++p; - if (yych == 'M') goto yy1536; - if (yych == 'm') goto yy1536; - goto yy1417; -yy1532: - yych = *++p; - if (yych == 'A') goto yy1533; - if (yych != 'a') goto yy1417; -yy1533: - yych = *++p; - if (yych == 'D') goto yy1534; - if (yych != 'd') goto yy1417; -yy1534: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - goto yy1417; - } else { - if (yych <= ' ') goto yy1456; - if (yych <= '.') goto yy1417; - goto yy1458; - } - } else { - if (yych <= 'D') { - if (yych == '>') goto yy1456; - goto yy1417; - } else { - if (yych <= 'E') goto yy1535; - if (yych != 'e') goto yy1417; - } - } -yy1535: - yych = *++p; - if (yych == 'R') goto yy1455; - if (yych == 'r') goto yy1455; - goto yy1417; -yy1536: - yych = *++p; - if (yych == 'L') goto yy1455; - if (yych == 'l') goto yy1455; - goto yy1417; -yy1537: - yych = *++p; - if (yych == 'A') goto yy1558; - if (yych == 'a') goto yy1558; - goto yy1417; -yy1538: - yych = *++p; - if (yych <= 'R') { - if (yych == 'O') goto yy1554; - if (yych <= 'Q') goto yy1417; - goto yy1555; - } else { - if (yych <= 'o') { - if (yych <= 'n') goto yy1417; - goto yy1554; - } else { - if (yych == 'r') goto yy1555; - goto yy1417; - } - } -yy1539: - yych = *++p; - if (yych <= 'G') { - if (yych == 'E') goto yy1540; - if (yych <= 'F') goto yy1417; - goto yy1541; - } else { - if (yych <= 'e') { - if (yych <= 'd') goto yy1417; - } else { - if (yych == 'g') goto yy1541; - goto yy1417; - } - } -yy1540: - yych = *++p; - if (yych == 'L') goto yy1550; - if (yych == 'l') goto yy1550; - goto yy1417; -yy1541: - yych = *++p; - if (yych <= 'U') { - if (yych == 'C') goto yy1543; - if (yych <= 'T') goto yy1417; - } else { - if (yych <= 'c') { - if (yych <= 'b') goto yy1417; - goto yy1543; - } else { - if (yych != 'u') goto yy1417; - } - } - yych = *++p; - if (yych == 'R') goto yy1549; - if (yych == 'r') goto yy1549; - goto yy1417; -yy1543: - yych = *++p; - if (yych == 'A') goto yy1544; - if (yych != 'a') goto yy1417; -yy1544: - yych = *++p; - if (yych == 'P') goto yy1545; - if (yych != 'p') goto yy1417; -yy1545: - yych = *++p; - if (yych == 'T') goto yy1546; - if (yych != 't') goto yy1417; -yy1546: - yych = *++p; - if (yych == 'I') goto yy1547; - if (yych != 'i') goto yy1417; -yy1547: - yych = *++p; - if (yych == 'O') goto yy1548; - if (yych != 'o') goto yy1417; -yy1548: - yych = *++p; - if (yych == 'N') goto yy1455; - if (yych == 'n') goto yy1455; - goto yy1417; -yy1549: - yych = *++p; - if (yych == 'E') goto yy1455; - if (yych == 'e') goto yy1455; - goto yy1417; -yy1550: - yych = *++p; - if (yych == 'D') goto yy1551; - if (yych != 'd') goto yy1417; -yy1551: - yych = *++p; - if (yych == 'S') goto yy1552; - if (yych != 's') goto yy1417; -yy1552: - yych = *++p; - if (yych == 'E') goto yy1553; - if (yych != 'e') goto yy1417; -yy1553: - yych = *++p; - if (yych == 'T') goto yy1455; - if (yych == 't') goto yy1455; - goto yy1417; -yy1554: - yych = *++p; - if (yych == 'T') goto yy1556; - if (yych == 't') goto yy1556; - goto yy1417; -yy1555: - yych = *++p; - if (yych == 'M') goto yy1455; - if (yych == 'm') goto yy1455; - goto yy1417; -yy1556: - yych = *++p; - if (yych == 'E') goto yy1557; - if (yych != 'e') goto yy1417; -yy1557: - yych = *++p; - if (yych == 'R') goto yy1455; - if (yych == 'r') goto yy1455; - goto yy1417; -yy1558: - yych = *++p; - if (yych == 'M') goto yy1559; - if (yych != 'm') goto yy1417; -yy1559: - yych = *++p; - if (yych == 'E') goto yy1560; - if (yych != 'e') goto yy1417; -yy1560: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - goto yy1417; - } else { - if (yych <= ' ') goto yy1456; - if (yych <= '.') goto yy1417; - goto yy1458; - } - } else { - if (yych <= 'R') { - if (yych == '>') goto yy1456; - goto yy1417; - } else { - if (yych <= 'S') goto yy1561; - if (yych != 's') goto yy1417; - } - } -yy1561: - yych = *++p; - if (yych == 'E') goto yy1562; - if (yych != 'e') goto yy1417; -yy1562: - yych = *++p; - if (yych == 'T') goto yy1455; - if (yych == 't') goto yy1455; - goto yy1417; -yy1563: - yych = *++p; - if (yych <= 'V') { - if (yych <= 'Q') { - if (yych == 'A') goto yy1569; - goto yy1417; - } else { - if (yych <= 'R') goto yy1455; - if (yych <= 'U') goto yy1417; - goto yy1455; - } - } else { - if (yych <= 'q') { - if (yych == 'a') goto yy1569; - goto yy1417; - } else { - if (yych <= 'r') goto yy1455; - if (yych == 'v') goto yy1455; - goto yy1417; - } - } -yy1564: - yych = *++p; - if (yych == 'T') goto yy1565; - if (yych != 't') goto yy1417; -yy1565: - yych = *++p; - if (yych == 'A') goto yy1566; - if (yych != 'a') goto yy1417; -yy1566: - yych = *++p; - if (yych == 'I') goto yy1567; - if (yych != 'i') goto yy1417; -yy1567: - yych = *++p; - if (yych == 'L') goto yy1568; - if (yych != 'l') goto yy1417; -yy1568: - yych = *++p; - if (yych == 'S') goto yy1455; - if (yych == 's') goto yy1455; - goto yy1417; -yy1569: - yych = *++p; - if (yych == 'L') goto yy1570; - if (yych != 'l') goto yy1417; -yy1570: - yych = *++p; - if (yych == 'O') goto yy1571; - if (yych != 'o') goto yy1417; -yy1571: - yych = *++p; - if (yych == 'G') goto yy1455; - if (yych == 'g') goto yy1455; - goto yy1417; -yy1572: - yych = *++p; - if (yych == 'L') goto yy1582; - if (yych == 'l') goto yy1582; - goto yy1417; -yy1573: - yych = *++p; - if (yych == 'N') goto yy1579; - if (yych == 'n') goto yy1579; - goto yy1417; -yy1574: - yych = *++p; - if (yych == 'P') goto yy1575; - if (yych != 'p') goto yy1417; -yy1575: - yych = *++p; - if (yych == 'T') goto yy1576; - if (yych != 't') goto yy1417; -yy1576: - yych = *++p; - if (yych == 'I') goto yy1577; - if (yych != 'i') goto yy1417; -yy1577: - yych = *++p; - if (yych == 'O') goto yy1578; - if (yych != 'o') goto yy1417; -yy1578: - yych = *++p; - if (yych == 'N') goto yy1455; - if (yych == 'n') goto yy1455; - goto yy1417; -yy1579: - yych = *++p; - if (yych == 'T') goto yy1580; - if (yych != 't') goto yy1417; -yy1580: - yych = *++p; - if (yych == 'E') goto yy1581; - if (yych != 'e') goto yy1417; -yy1581: - yych = *++p; - if (yych == 'R') goto yy1455; - if (yych == 'r') goto yy1455; - goto yy1417; -yy1582: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - goto yy1417; - } else { - if (yych <= ' ') goto yy1456; - if (yych <= '.') goto yy1417; - goto yy1458; - } - } else { - if (yych <= 'F') { - if (yych == '>') goto yy1456; - goto yy1417; - } else { - if (yych <= 'G') goto yy1583; - if (yych != 'g') goto yy1417; - } - } -yy1583: - yych = *++p; - if (yych == 'R') goto yy1584; - if (yych != 'r') goto yy1417; -yy1584: - yych = *++p; - if (yych == 'O') goto yy1585; - if (yych != 'o') goto yy1417; -yy1585: - yych = *++p; - if (yych == 'U') goto yy1586; - if (yych != 'u') goto yy1417; -yy1586: - yych = *++p; - if (yych == 'P') goto yy1455; - if (yych == 'p') goto yy1455; - goto yy1417; -yy1587: - yych = *++p; - if (yych == 'D') goto yy1602; - if (yych == 'd') goto yy1602; - goto yy1417; -yy1588: - yych = *++p; - if (yych == 'O') goto yy1595; - if (yych == 'o') goto yy1595; - goto yy1417; -yy1589: - yych = *++p; - if (yych == 'S') goto yy1590; - if (yych != 's') goto yy1417; -yy1590: - yych = *++p; - if (yych == 'E') goto yy1591; - if (yych != 'e') goto yy1417; -yy1591: - yych = *++p; - if (yych <= '/') { - if (yych <= 0x1F) { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - goto yy1417; - } else { - if (yych <= ' ') goto yy1456; - if (yych <= '.') goto yy1417; - goto yy1458; - } - } else { - if (yych <= 'E') { - if (yych == '>') goto yy1456; - goto yy1417; - } else { - if (yych <= 'F') goto yy1592; - if (yych != 'f') goto yy1417; - } - } -yy1592: - yych = *++p; - if (yych == 'O') goto yy1593; - if (yych != 'o') goto yy1417; -yy1593: - yych = *++p; - if (yych == 'N') goto yy1594; - if (yych != 'n') goto yy1417; -yy1594: - yych = *++p; - if (yych == 'T') goto yy1455; - if (yych == 't') goto yy1455; - goto yy1417; -yy1595: - yych = *++p; - if (yych == 'C') goto yy1596; - if (yych != 'c') goto yy1417; -yy1596: - yych = *++p; - if (yych == 'K') goto yy1597; - if (yych != 'k') goto yy1417; -yy1597: - yych = *++p; - if (yych == 'Q') goto yy1598; - if (yych != 'q') goto yy1417; -yy1598: - yych = *++p; - if (yych == 'U') goto yy1599; - if (yych != 'u') goto yy1417; -yy1599: - yych = *++p; - if (yych == 'O') goto yy1600; - if (yych != 'o') goto yy1417; -yy1600: - yych = *++p; - if (yych == 'T') goto yy1601; - if (yych != 't') goto yy1417; -yy1601: - yych = *++p; - if (yych == 'E') goto yy1455; - if (yych == 'e') goto yy1455; - goto yy1417; -yy1602: - yych = *++p; - if (yych == 'Y') goto yy1455; - if (yych == 'y') goto yy1455; - goto yy1417; -yy1603: - yych = *++p; - if (yych == 'I') goto yy1614; - if (yych == 'i') goto yy1614; - goto yy1417; -yy1604: - yych = *++p; - if (yych == 'T') goto yy1610; - if (yych == 't') goto yy1610; - goto yy1417; -yy1605: - yych = *++p; - if (yych == 'D') goto yy1606; - if (yych != 'd') goto yy1417; -yy1606: - yych = *++p; - if (yych == 'R') goto yy1607; - if (yych != 'r') goto yy1417; -yy1607: - yych = *++p; - if (yych == 'E') goto yy1608; - if (yych != 'e') goto yy1417; -yy1608: - yych = *++p; - if (yych == 'S') goto yy1609; - if (yych != 's') goto yy1417; -yy1609: - yych = *++p; - if (yych == 'S') goto yy1455; - if (yych == 's') goto yy1455; - goto yy1417; -yy1610: - yych = *++p; - if (yych == 'I') goto yy1611; - if (yych != 'i') goto yy1417; -yy1611: - yych = *++p; - if (yych == 'C') goto yy1612; - if (yych != 'c') goto yy1417; -yy1612: - yych = *++p; - if (yych == 'L') goto yy1613; - if (yych != 'l') goto yy1417; -yy1613: - yych = *++p; - if (yych == 'E') goto yy1455; - if (yych == 'e') goto yy1455; - goto yy1417; -yy1614: - yych = *++p; - if (yych == 'D') goto yy1615; - if (yych != 'd') goto yy1417; -yy1615: - yych = *++p; - if (yych == 'E') goto yy1455; - if (yych == 'e') goto yy1455; - goto yy1417; -yy1616: - yych = *++p; - if (yych == 'E') goto yy1620; - if (yych == 'e') goto yy1620; - goto yy1417; -yy1617: - yych = *++p; - if (yych == 'R') goto yy1618; - if (yych != 'r') goto yy1417; -yy1618: - yych = *++p; - if (yych == 'A') goto yy1619; - if (yych != 'a') goto yy1417; -yy1619: - yych = *++p; - if (yych == 'M') goto yy1455; - if (yych == 'm') goto yy1455; - goto yy1417; -yy1620: - yych = *++p; - if (yych <= ' ') { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1621; - if (yych <= 0x1F) goto yy1417; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy1417; - goto yy1458; - } else { - if (yych != '>') goto yy1417; - } - } -yy1621: - yych = *++p; - goto yy1498; -yy1622: - yych = *++p; - if (yych <= '>') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy1417; - if (yych <= '\r') goto yy1456; - if (yych <= 0x1F) goto yy1417; - goto yy1456; - } else { - if (yych == '/') goto yy1458; - if (yych <= '=') goto yy1417; - goto yy1456; - } - } else { - if (yych <= 'R') { - if (yych == 'A') goto yy1617; - if (yych <= 'Q') goto yy1417; - goto yy1624; - } else { - if (yych <= 'a') { - if (yych <= '`') goto yy1417; - goto yy1617; - } else { - if (yych == 'r') goto yy1624; - goto yy1417; - } - } - } -yy1623: - yych = *++p; - if (yych <= 'U') { - if (yych <= 'N') { - if (yych == 'E') goto yy1481; - goto yy1417; - } else { - if (yych <= 'O') goto yy1480; - if (yych <= 'T') goto yy1417; - goto yy1479; - } - } else { - if (yych <= 'n') { - if (yych == 'e') goto yy1481; - goto yy1417; - } else { - if (yych <= 'o') goto yy1480; - if (yych == 'u') goto yy1479; - goto yy1417; - } - } -yy1624: - ++p; - if ((yych = *p) == 'E') goto yy1455; - if (yych == 'e') goto yy1455; - goto yy1417; -} - + { + unsigned char yych; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= ';') { + if (yych != '\n') + goto yy1415; + } else { + if (yych <= '<') + goto yy1414; + if (yych <= 0x7F) + goto yy1415; + if (yych >= 0xC2) + goto yy1416; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1418; + if (yych == 0xED) + goto yy1423; + goto yy1419; + } else { + if (yych <= 0xF0) + goto yy1420; + if (yych <= 0xF3) + goto yy1421; + if (yych <= 0xF4) + goto yy1422; + } + } + yy1413 : { return 0; } + yy1414: + yych = *(marker = ++p); + switch (yych) { + case '!': + goto yy1440; + case '/': + goto yy1424; + case '?': + goto yy1441; + case 'A': + case 'a': + goto yy1426; + case 'B': + case 'b': + goto yy1427; + case 'C': + case 'c': + goto yy1428; + case 'D': + case 'd': + goto yy1429; + case 'F': + case 'f': + goto yy1430; + case 'H': + case 'h': + goto yy1431; + case 'I': + case 'i': + goto yy1432; + case 'L': + case 'l': + goto yy1433; + case 'M': + case 'm': + goto yy1434; + case 'N': + case 'n': + goto yy1435; + case 'O': + case 'o': + goto yy1436; + case 'P': + case 'p': + goto yy1425; + case 'S': + case 's': + goto yy1437; + case 'T': + case 't': + goto yy1438; + case 'U': + case 'u': + goto yy1439; + default: + goto yy1413; + } + yy1415: + yych = *++p; + goto yy1413; + yy1416: + yych = *++p; + if (yych <= 0x7F) + goto yy1417; + if (yych <= 0xBF) + goto yy1415; + yy1417: + p = marker; + goto yy1413; + yy1418: + yych = *++p; + if (yych <= 0x9F) + goto yy1417; + if (yych <= 0xBF) + goto yy1416; + goto yy1417; + yy1419: + yych = *++p; + if (yych <= 0x7F) + goto yy1417; + if (yych <= 0xBF) + goto yy1416; + goto yy1417; + yy1420: + yych = *++p; + if (yych <= 0x8F) + goto yy1417; + if (yych <= 0xBF) + goto yy1419; + goto yy1417; + yy1421: + yych = *++p; + if (yych <= 0x7F) + goto yy1417; + if (yych <= 0xBF) + goto yy1419; + goto yy1417; + yy1422: + yych = *++p; + if (yych <= 0x7F) + goto yy1417; + if (yych <= 0x8F) + goto yy1419; + goto yy1417; + yy1423: + yych = *++p; + if (yych <= 0x7F) + goto yy1417; + if (yych <= 0x9F) + goto yy1416; + goto yy1417; + yy1424: + yych = *++p; + switch (yych) { + case 'A': + case 'a': + goto yy1426; + case 'B': + case 'b': + goto yy1427; + case 'C': + case 'c': + goto yy1428; + case 'D': + case 'd': + goto yy1429; + case 'F': + case 'f': + goto yy1430; + case 'H': + case 'h': + goto yy1431; + case 'I': + case 'i': + goto yy1432; + case 'L': + case 'l': + goto yy1433; + case 'M': + case 'm': + goto yy1434; + case 'N': + case 'n': + goto yy1435; + case 'O': + case 'o': + goto yy1436; + case 'P': + case 'p': + goto yy1625; + case 'S': + case 's': + goto yy1626; + case 'T': + case 't': + goto yy1438; + case 'U': + case 'u': + goto yy1439; + default: + goto yy1417; + } + yy1425: + yych = *++p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + if (yych <= 0x1F) + goto yy1417; + goto yy1457; + } else { + if (yych == '/') + goto yy1459; + if (yych <= '=') + goto yy1417; + goto yy1457; + } + } else { + if (yych <= 'R') { + if (yych == 'A') + goto yy1622; + if (yych <= 'Q') + goto yy1417; + goto yy1621; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy1417; + goto yy1622; + } else { + if (yych == 'r') + goto yy1621; + goto yy1417; + } + } + } + yy1426: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'D') { + if (yych <= 'C') + goto yy1417; + goto yy1610; + } else { + if (yych <= 'Q') + goto yy1417; + if (yych <= 'R') + goto yy1609; + goto yy1608; + } + } else { + if (yych <= 'q') { + if (yych == 'd') + goto yy1610; + goto yy1417; + } else { + if (yych <= 'r') + goto yy1609; + if (yych <= 's') + goto yy1608; + goto yy1417; + } + } + yy1427: + yych = *++p; + if (yych <= 'O') { + if (yych <= 'K') { + if (yych == 'A') + goto yy1594; + goto yy1417; + } else { + if (yych <= 'L') + goto yy1593; + if (yych <= 'N') + goto yy1417; + goto yy1592; + } + } else { + if (yych <= 'k') { + if (yych == 'a') + goto yy1594; + goto yy1417; + } else { + if (yych <= 'l') + goto yy1593; + if (yych == 'o') + goto yy1592; + goto yy1417; + } + } + yy1428: + yych = *++p; + if (yych <= 'O') { + if (yych <= 'D') { + if (yych == 'A') + goto yy1579; + goto yy1417; + } else { + if (yych <= 'E') + goto yy1578; + if (yych <= 'N') + goto yy1417; + goto yy1577; + } + } else { + if (yych <= 'd') { + if (yych == 'a') + goto yy1579; + goto yy1417; + } else { + if (yych <= 'e') + goto yy1578; + if (yych == 'o') + goto yy1577; + goto yy1417; + } + } + yy1429: + yych = *++p; + switch (yych) { + case 'D': + case 'L': + case 'T': + case 'd': + case 'l': + case 't': + goto yy1456; + case 'E': + case 'e': + goto yy1569; + case 'I': + case 'i': + goto yy1568; + default: + goto yy1417; + } + yy1430: + yych = *++p; + if (yych <= 'R') { + if (yych <= 'N') { + if (yych == 'I') + goto yy1544; + goto yy1417; + } else { + if (yych <= 'O') + goto yy1543; + if (yych <= 'Q') + goto yy1417; + goto yy1542; + } + } else { + if (yych <= 'n') { + if (yych == 'i') + goto yy1544; + goto yy1417; + } else { + if (yych <= 'o') + goto yy1543; + if (yych == 'r') + goto yy1542; + goto yy1417; + } + } + yy1431: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'D') { + if (yych == '1') + goto yy1456; + goto yy1417; + } else { + if (yych <= 'E') + goto yy1537; + if (yych == 'R') + goto yy1456; + goto yy1417; + } + } else { + if (yych <= 'q') { + if (yych <= 'T') + goto yy1536; + if (yych == 'e') + goto yy1537; + goto yy1417; + } else { + if (yych <= 'r') + goto yy1456; + if (yych == 't') + goto yy1536; + goto yy1417; + } + } + yy1432: + yych = *++p; + if (yych == 'F') + goto yy1532; + if (yych == 'f') + goto yy1532; + goto yy1417; + yy1433: + yych = *++p; + if (yych <= 'I') { + if (yych == 'E') + goto yy1527; + if (yych <= 'H') + goto yy1417; + goto yy1526; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy1417; + goto yy1527; + } else { + if (yych == 'i') + goto yy1526; + goto yy1417; + } + } + yy1434: + yych = *++p; + if (yych <= 'E') { + if (yych == 'A') + goto yy1518; + if (yych <= 'D') + goto yy1417; + goto yy1517; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy1417; + goto yy1518; + } else { + if (yych == 'e') + goto yy1517; + goto yy1417; + } + } + yy1435: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') + goto yy1511; + if (yych <= 'N') + goto yy1417; + goto yy1510; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy1417; + goto yy1511; + } else { + if (yych == 'o') + goto yy1510; + goto yy1417; + } + } + yy1436: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') + goto yy1456; + if (yych <= 'O') + goto yy1417; + goto yy1502; + } else { + if (yych <= 'l') { + if (yych <= 'k') + goto yy1417; + goto yy1456; + } else { + if (yych == 'p') + goto yy1502; + goto yy1417; + } + } + yy1437: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'E') { + if (yych == 'C') + goto yy1479; + if (yych <= 'D') + goto yy1417; + goto yy1482; + } else { + if (yych <= 'O') { + if (yych <= 'N') + goto yy1417; + goto yy1481; + } else { + if (yych <= 'S') + goto yy1417; + if (yych <= 'T') + goto yy1478; + goto yy1480; + } + } + } else { + if (yych <= 'n') { + if (yych <= 'c') { + if (yych <= 'b') + goto yy1417; + goto yy1479; + } else { + if (yych == 'e') + goto yy1482; + goto yy1417; + } + } else { + if (yych <= 's') { + if (yych <= 'o') + goto yy1481; + goto yy1417; + } else { + if (yych <= 't') + goto yy1478; + if (yych <= 'u') + goto yy1480; + goto yy1417; + } + } + } + yy1438: + yych = *++p; + switch (yych) { + case 'A': + case 'a': + goto yy1465; + case 'B': + case 'b': + goto yy1464; + case 'D': + case 'd': + goto yy1456; + case 'F': + case 'f': + goto yy1463; + case 'H': + case 'h': + goto yy1462; + case 'I': + case 'i': + goto yy1461; + case 'R': + case 'r': + goto yy1460; + default: + goto yy1417; + } + yy1439: + yych = *++p; + if (yych == 'L') + goto yy1456; + if (yych == 'l') + goto yy1456; + goto yy1417; + yy1440: + yych = *++p; + if (yych <= '@') { + if (yych == '-') + goto yy1443; + goto yy1417; + } else { + if (yych <= 'Z') + goto yy1444; + if (yych <= '[') + goto yy1446; + goto yy1417; + } + yy1441: + ++p; + { return 3; } + yy1443: + yych = *++p; + if (yych == '-') + goto yy1454; + goto yy1417; + yy1444: + ++p; + { return 4; } + yy1446: + yych = *++p; + if (yych == 'C') + goto yy1447; + if (yych != 'c') + goto yy1417; + yy1447: + yych = *++p; + if (yych == 'D') + goto yy1448; + if (yych != 'd') + goto yy1417; + yy1448: + yych = *++p; + if (yych == 'A') + goto yy1449; + if (yych != 'a') + goto yy1417; + yy1449: + yych = *++p; + if (yych == 'T') + goto yy1450; + if (yych != 't') + goto yy1417; + yy1450: + yych = *++p; + if (yych == 'A') + goto yy1451; + if (yych != 'a') + goto yy1417; + yy1451: + yych = *++p; + if (yych != '[') + goto yy1417; + ++p; + { return 5; } + yy1454: + ++p; + { return 2; } + yy1456: + yych = *++p; + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + if (yych <= 0x1F) + goto yy1417; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy1417; + goto yy1459; + } else { + if (yych != '>') + goto yy1417; + } + } + yy1457: + ++p; + { return 6; } + yy1459: + yych = *++p; + if (yych == '>') + goto yy1457; + goto yy1417; + yy1460: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + goto yy1417; + } else { + if (yych <= ' ') + goto yy1457; + if (yych <= '.') + goto yy1417; + goto yy1459; + } + } else { + if (yych <= '@') { + if (yych == '>') + goto yy1457; + goto yy1417; + } else { + if (yych <= 'A') + goto yy1476; + if (yych == 'a') + goto yy1476; + goto yy1417; + } + } + yy1461: + yych = *++p; + if (yych == 'T') + goto yy1474; + if (yych == 't') + goto yy1474; + goto yy1417; + yy1462: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + goto yy1417; + } else { + if (yych <= ' ') + goto yy1457; + if (yych <= '.') + goto yy1417; + goto yy1459; + } + } else { + if (yych <= 'D') { + if (yych == '>') + goto yy1457; + goto yy1417; + } else { + if (yych <= 'E') + goto yy1472; + if (yych == 'e') + goto yy1472; + goto yy1417; + } + } + yy1463: + yych = *++p; + if (yych == 'O') + goto yy1470; + if (yych == 'o') + goto yy1470; + goto yy1417; + yy1464: + yych = *++p; + if (yych == 'O') + goto yy1468; + if (yych == 'o') + goto yy1468; + goto yy1417; + yy1465: + yych = *++p; + if (yych == 'B') + goto yy1466; + if (yych != 'b') + goto yy1417; + yy1466: + yych = *++p; + if (yych == 'L') + goto yy1467; + if (yych != 'l') + goto yy1417; + yy1467: + yych = *++p; + if (yych == 'E') + goto yy1456; + if (yych == 'e') + goto yy1456; + goto yy1417; + yy1468: + yych = *++p; + if (yych == 'D') + goto yy1469; + if (yych != 'd') + goto yy1417; + yy1469: + yych = *++p; + if (yych == 'Y') + goto yy1456; + if (yych == 'y') + goto yy1456; + goto yy1417; + yy1470: + yych = *++p; + if (yych == 'O') + goto yy1471; + if (yych != 'o') + goto yy1417; + yy1471: + yych = *++p; + if (yych == 'T') + goto yy1456; + if (yych == 't') + goto yy1456; + goto yy1417; + yy1472: + yych = *++p; + if (yych == 'A') + goto yy1473; + if (yych != 'a') + goto yy1417; + yy1473: + yych = *++p; + if (yych == 'D') + goto yy1456; + if (yych == 'd') + goto yy1456; + goto yy1417; + yy1474: + yych = *++p; + if (yych == 'L') + goto yy1475; + if (yych != 'l') + goto yy1417; + yy1475: + yych = *++p; + if (yych == 'E') + goto yy1456; + if (yych == 'e') + goto yy1456; + goto yy1417; + yy1476: + yych = *++p; + if (yych == 'C') + goto yy1477; + if (yych != 'c') + goto yy1417; + yy1477: + yych = *++p; + if (yych == 'K') + goto yy1456; + if (yych == 'k') + goto yy1456; + goto yy1417; + yy1478: + yych = *++p; + if (yych == 'Y') + goto yy1500; + if (yych == 'y') + goto yy1500; + goto yy1417; + yy1479: + yych = *++p; + if (yych == 'R') + goto yy1494; + if (yych == 'r') + goto yy1494; + goto yy1417; + yy1480: + yych = *++p; + if (yych == 'M') + goto yy1490; + if (yych == 'm') + goto yy1490; + goto yy1417; + yy1481: + yych = *++p; + if (yych == 'U') + goto yy1487; + if (yych == 'u') + goto yy1487; + goto yy1417; + yy1482: + yych = *++p; + if (yych == 'C') + goto yy1483; + if (yych != 'c') + goto yy1417; + yy1483: + yych = *++p; + if (yych == 'T') + goto yy1484; + if (yych != 't') + goto yy1417; + yy1484: + yych = *++p; + if (yych == 'I') + goto yy1485; + if (yych != 'i') + goto yy1417; + yy1485: + yych = *++p; + if (yych == 'O') + goto yy1486; + if (yych != 'o') + goto yy1417; + yy1486: + yych = *++p; + if (yych == 'N') + goto yy1456; + if (yych == 'n') + goto yy1456; + goto yy1417; + yy1487: + yych = *++p; + if (yych == 'R') + goto yy1488; + if (yych != 'r') + goto yy1417; + yy1488: + yych = *++p; + if (yych == 'C') + goto yy1489; + if (yych != 'c') + goto yy1417; + yy1489: + yych = *++p; + if (yych == 'E') + goto yy1456; + if (yych == 'e') + goto yy1456; + goto yy1417; + yy1490: + yych = *++p; + if (yych == 'M') + goto yy1491; + if (yych != 'm') + goto yy1417; + yy1491: + yych = *++p; + if (yych == 'A') + goto yy1492; + if (yych != 'a') + goto yy1417; + yy1492: + yych = *++p; + if (yych == 'R') + goto yy1493; + if (yych != 'r') + goto yy1417; + yy1493: + yych = *++p; + if (yych == 'Y') + goto yy1456; + if (yych == 'y') + goto yy1456; + goto yy1417; + yy1494: + yych = *++p; + if (yych == 'I') + goto yy1495; + if (yych != 'i') + goto yy1417; + yy1495: + yych = *++p; + if (yych == 'P') + goto yy1496; + if (yych != 'p') + goto yy1417; + yy1496: + yych = *++p; + if (yych == 'T') + goto yy1497; + if (yych != 't') + goto yy1417; + yy1497: + yych = *++p; + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1417; + if (yych >= 0x0E) + goto yy1417; + } else { + if (yych <= ' ') + goto yy1498; + if (yych != '>') + goto yy1417; + } + yy1498: + ++p; + { return 1; } + yy1500: + yych = *++p; + if (yych == 'L') + goto yy1501; + if (yych != 'l') + goto yy1417; + yy1501: + yych = *++p; + if (yych == 'E') + goto yy1497; + if (yych == 'e') + goto yy1497; + goto yy1417; + yy1502: + yych = *++p; + if (yych == 'T') + goto yy1503; + if (yych != 't') + goto yy1417; + yy1503: + yych = *++p; + if (yych <= 'I') { + if (yych == 'G') + goto yy1505; + if (yych <= 'H') + goto yy1417; + } else { + if (yych <= 'g') { + if (yych <= 'f') + goto yy1417; + goto yy1505; + } else { + if (yych != 'i') + goto yy1417; + } + } + yych = *++p; + if (yych == 'O') + goto yy1509; + if (yych == 'o') + goto yy1509; + goto yy1417; + yy1505: + yych = *++p; + if (yych == 'R') + goto yy1506; + if (yych != 'r') + goto yy1417; + yy1506: + yych = *++p; + if (yych == 'O') + goto yy1507; + if (yych != 'o') + goto yy1417; + yy1507: + yych = *++p; + if (yych == 'U') + goto yy1508; + if (yych != 'u') + goto yy1417; + yy1508: + yych = *++p; + if (yych == 'P') + goto yy1456; + if (yych == 'p') + goto yy1456; + goto yy1417; + yy1509: + yych = *++p; + if (yych == 'N') + goto yy1456; + if (yych == 'n') + goto yy1456; + goto yy1417; + yy1510: + yych = *++p; + if (yych == 'F') + goto yy1512; + if (yych == 'f') + goto yy1512; + goto yy1417; + yy1511: + yych = *++p; + if (yych == 'V') + goto yy1456; + if (yych == 'v') + goto yy1456; + goto yy1417; + yy1512: + yych = *++p; + if (yych == 'R') + goto yy1513; + if (yych != 'r') + goto yy1417; + yy1513: + yych = *++p; + if (yych == 'A') + goto yy1514; + if (yych != 'a') + goto yy1417; + yy1514: + yych = *++p; + if (yych == 'M') + goto yy1515; + if (yych != 'm') + goto yy1417; + yy1515: + yych = *++p; + if (yych == 'E') + goto yy1516; + if (yych != 'e') + goto yy1417; + yy1516: + yych = *++p; + if (yych == 'S') + goto yy1456; + if (yych == 's') + goto yy1456; + goto yy1417; + yy1517: + yych = *++p; + if (yych <= 'T') { + if (yych == 'N') + goto yy1520; + if (yych <= 'S') + goto yy1417; + goto yy1521; + } else { + if (yych <= 'n') { + if (yych <= 'm') + goto yy1417; + goto yy1520; + } else { + if (yych == 't') + goto yy1521; + goto yy1417; + } + } + yy1518: + yych = *++p; + if (yych == 'I') + goto yy1519; + if (yych != 'i') + goto yy1417; + yy1519: + yych = *++p; + if (yych == 'N') + goto yy1456; + if (yych == 'n') + goto yy1456; + goto yy1417; + yy1520: + yych = *++p; + if (yych == 'U') + goto yy1522; + if (yych == 'u') + goto yy1522; + goto yy1417; + yy1521: + yych = *++p; + if (yych == 'A') + goto yy1456; + if (yych == 'a') + goto yy1456; + goto yy1417; + yy1522: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + goto yy1417; + } else { + if (yych <= ' ') + goto yy1457; + if (yych <= '.') + goto yy1417; + goto yy1459; + } + } else { + if (yych <= 'H') { + if (yych == '>') + goto yy1457; + goto yy1417; + } else { + if (yych <= 'I') + goto yy1523; + if (yych != 'i') + goto yy1417; + } + } + yy1523: + yych = *++p; + if (yych == 'T') + goto yy1524; + if (yych != 't') + goto yy1417; + yy1524: + yych = *++p; + if (yych == 'E') + goto yy1525; + if (yych != 'e') + goto yy1417; + yy1525: + yych = *++p; + if (yych == 'M') + goto yy1456; + if (yych == 'm') + goto yy1456; + goto yy1417; + yy1526: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + goto yy1417; + } else { + if (yych <= ' ') + goto yy1457; + if (yych <= '.') + goto yy1417; + goto yy1459; + } + } else { + if (yych <= 'M') { + if (yych == '>') + goto yy1457; + goto yy1417; + } else { + if (yych <= 'N') + goto yy1531; + if (yych == 'n') + goto yy1531; + goto yy1417; + } + } + yy1527: + yych = *++p; + if (yych == 'G') + goto yy1528; + if (yych != 'g') + goto yy1417; + yy1528: + yych = *++p; + if (yych == 'E') + goto yy1529; + if (yych != 'e') + goto yy1417; + yy1529: + yych = *++p; + if (yych == 'N') + goto yy1530; + if (yych != 'n') + goto yy1417; + yy1530: + yych = *++p; + if (yych == 'D') + goto yy1456; + if (yych == 'd') + goto yy1456; + goto yy1417; + yy1531: + yych = *++p; + if (yych == 'K') + goto yy1456; + if (yych == 'k') + goto yy1456; + goto yy1417; + yy1532: + yych = *++p; + if (yych == 'R') + goto yy1533; + if (yych != 'r') + goto yy1417; + yy1533: + yych = *++p; + if (yych == 'A') + goto yy1534; + if (yych != 'a') + goto yy1417; + yy1534: + yych = *++p; + if (yych == 'M') + goto yy1535; + if (yych != 'm') + goto yy1417; + yy1535: + yych = *++p; + if (yych == 'E') + goto yy1456; + if (yych == 'e') + goto yy1456; + goto yy1417; + yy1536: + yych = *++p; + if (yych == 'M') + goto yy1541; + if (yych == 'm') + goto yy1541; + goto yy1417; + yy1537: + yych = *++p; + if (yych == 'A') + goto yy1538; + if (yych != 'a') + goto yy1417; + yy1538: + yych = *++p; + if (yych == 'D') + goto yy1539; + if (yych != 'd') + goto yy1417; + yy1539: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + goto yy1417; + } else { + if (yych <= ' ') + goto yy1457; + if (yych <= '.') + goto yy1417; + goto yy1459; + } + } else { + if (yych <= 'D') { + if (yych == '>') + goto yy1457; + goto yy1417; + } else { + if (yych <= 'E') + goto yy1540; + if (yych != 'e') + goto yy1417; + } + } + yy1540: + yych = *++p; + if (yych == 'R') + goto yy1456; + if (yych == 'r') + goto yy1456; + goto yy1417; + yy1541: + yych = *++p; + if (yych == 'L') + goto yy1456; + if (yych == 'l') + goto yy1456; + goto yy1417; + yy1542: + yych = *++p; + if (yych == 'A') + goto yy1563; + if (yych == 'a') + goto yy1563; + goto yy1417; + yy1543: + yych = *++p; + if (yych <= 'R') { + if (yych == 'O') + goto yy1559; + if (yych <= 'Q') + goto yy1417; + goto yy1560; + } else { + if (yych <= 'o') { + if (yych <= 'n') + goto yy1417; + goto yy1559; + } else { + if (yych == 'r') + goto yy1560; + goto yy1417; + } + } + yy1544: + yych = *++p; + if (yych <= 'G') { + if (yych == 'E') + goto yy1545; + if (yych <= 'F') + goto yy1417; + goto yy1546; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy1417; + } else { + if (yych == 'g') + goto yy1546; + goto yy1417; + } + } + yy1545: + yych = *++p; + if (yych == 'L') + goto yy1555; + if (yych == 'l') + goto yy1555; + goto yy1417; + yy1546: + yych = *++p; + if (yych <= 'U') { + if (yych == 'C') + goto yy1548; + if (yych <= 'T') + goto yy1417; + } else { + if (yych <= 'c') { + if (yych <= 'b') + goto yy1417; + goto yy1548; + } else { + if (yych != 'u') + goto yy1417; + } + } + yych = *++p; + if (yych == 'R') + goto yy1554; + if (yych == 'r') + goto yy1554; + goto yy1417; + yy1548: + yych = *++p; + if (yych == 'A') + goto yy1549; + if (yych != 'a') + goto yy1417; + yy1549: + yych = *++p; + if (yych == 'P') + goto yy1550; + if (yych != 'p') + goto yy1417; + yy1550: + yych = *++p; + if (yych == 'T') + goto yy1551; + if (yych != 't') + goto yy1417; + yy1551: + yych = *++p; + if (yych == 'I') + goto yy1552; + if (yych != 'i') + goto yy1417; + yy1552: + yych = *++p; + if (yych == 'O') + goto yy1553; + if (yych != 'o') + goto yy1417; + yy1553: + yych = *++p; + if (yych == 'N') + goto yy1456; + if (yych == 'n') + goto yy1456; + goto yy1417; + yy1554: + yych = *++p; + if (yych == 'E') + goto yy1456; + if (yych == 'e') + goto yy1456; + goto yy1417; + yy1555: + yych = *++p; + if (yych == 'D') + goto yy1556; + if (yych != 'd') + goto yy1417; + yy1556: + yych = *++p; + if (yych == 'S') + goto yy1557; + if (yych != 's') + goto yy1417; + yy1557: + yych = *++p; + if (yych == 'E') + goto yy1558; + if (yych != 'e') + goto yy1417; + yy1558: + yych = *++p; + if (yych == 'T') + goto yy1456; + if (yych == 't') + goto yy1456; + goto yy1417; + yy1559: + yych = *++p; + if (yych == 'T') + goto yy1561; + if (yych == 't') + goto yy1561; + goto yy1417; + yy1560: + yych = *++p; + if (yych == 'M') + goto yy1456; + if (yych == 'm') + goto yy1456; + goto yy1417; + yy1561: + yych = *++p; + if (yych == 'E') + goto yy1562; + if (yych != 'e') + goto yy1417; + yy1562: + yych = *++p; + if (yych == 'R') + goto yy1456; + if (yych == 'r') + goto yy1456; + goto yy1417; + yy1563: + yych = *++p; + if (yych == 'M') + goto yy1564; + if (yych != 'm') + goto yy1417; + yy1564: + yych = *++p; + if (yych == 'E') + goto yy1565; + if (yych != 'e') + goto yy1417; + yy1565: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + goto yy1417; + } else { + if (yych <= ' ') + goto yy1457; + if (yych <= '.') + goto yy1417; + goto yy1459; + } + } else { + if (yych <= 'R') { + if (yych == '>') + goto yy1457; + goto yy1417; + } else { + if (yych <= 'S') + goto yy1566; + if (yych != 's') + goto yy1417; + } + } + yy1566: + yych = *++p; + if (yych == 'E') + goto yy1567; + if (yych != 'e') + goto yy1417; + yy1567: + yych = *++p; + if (yych == 'T') + goto yy1456; + if (yych == 't') + goto yy1456; + goto yy1417; + yy1568: + yych = *++p; + if (yych <= 'V') { + if (yych <= 'Q') { + if (yych == 'A') + goto yy1574; + goto yy1417; + } else { + if (yych <= 'R') + goto yy1456; + if (yych <= 'U') + goto yy1417; + goto yy1456; + } + } else { + if (yych <= 'q') { + if (yych == 'a') + goto yy1574; + goto yy1417; + } else { + if (yych <= 'r') + goto yy1456; + if (yych == 'v') + goto yy1456; + goto yy1417; + } + } + yy1569: + yych = *++p; + if (yych == 'T') + goto yy1570; + if (yych != 't') + goto yy1417; + yy1570: + yych = *++p; + if (yych == 'A') + goto yy1571; + if (yych != 'a') + goto yy1417; + yy1571: + yych = *++p; + if (yych == 'I') + goto yy1572; + if (yych != 'i') + goto yy1417; + yy1572: + yych = *++p; + if (yych == 'L') + goto yy1573; + if (yych != 'l') + goto yy1417; + yy1573: + yych = *++p; + if (yych == 'S') + goto yy1456; + if (yych == 's') + goto yy1456; + goto yy1417; + yy1574: + yych = *++p; + if (yych == 'L') + goto yy1575; + if (yych != 'l') + goto yy1417; + yy1575: + yych = *++p; + if (yych == 'O') + goto yy1576; + if (yych != 'o') + goto yy1417; + yy1576: + yych = *++p; + if (yych == 'G') + goto yy1456; + if (yych == 'g') + goto yy1456; + goto yy1417; + yy1577: + yych = *++p; + if (yych == 'L') + goto yy1587; + if (yych == 'l') + goto yy1587; + goto yy1417; + yy1578: + yych = *++p; + if (yych == 'N') + goto yy1584; + if (yych == 'n') + goto yy1584; + goto yy1417; + yy1579: + yych = *++p; + if (yych == 'P') + goto yy1580; + if (yych != 'p') + goto yy1417; + yy1580: + yych = *++p; + if (yych == 'T') + goto yy1581; + if (yych != 't') + goto yy1417; + yy1581: + yych = *++p; + if (yych == 'I') + goto yy1582; + if (yych != 'i') + goto yy1417; + yy1582: + yych = *++p; + if (yych == 'O') + goto yy1583; + if (yych != 'o') + goto yy1417; + yy1583: + yych = *++p; + if (yych == 'N') + goto yy1456; + if (yych == 'n') + goto yy1456; + goto yy1417; + yy1584: + yych = *++p; + if (yych == 'T') + goto yy1585; + if (yych != 't') + goto yy1417; + yy1585: + yych = *++p; + if (yych == 'E') + goto yy1586; + if (yych != 'e') + goto yy1417; + yy1586: + yych = *++p; + if (yych == 'R') + goto yy1456; + if (yych == 'r') + goto yy1456; + goto yy1417; + yy1587: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + goto yy1417; + } else { + if (yych <= ' ') + goto yy1457; + if (yych <= '.') + goto yy1417; + goto yy1459; + } + } else { + if (yych <= 'F') { + if (yych == '>') + goto yy1457; + goto yy1417; + } else { + if (yych <= 'G') + goto yy1588; + if (yych != 'g') + goto yy1417; + } + } + yy1588: + yych = *++p; + if (yych == 'R') + goto yy1589; + if (yych != 'r') + goto yy1417; + yy1589: + yych = *++p; + if (yych == 'O') + goto yy1590; + if (yych != 'o') + goto yy1417; + yy1590: + yych = *++p; + if (yych == 'U') + goto yy1591; + if (yych != 'u') + goto yy1417; + yy1591: + yych = *++p; + if (yych == 'P') + goto yy1456; + if (yych == 'p') + goto yy1456; + goto yy1417; + yy1592: + yych = *++p; + if (yych == 'D') + goto yy1607; + if (yych == 'd') + goto yy1607; + goto yy1417; + yy1593: + yych = *++p; + if (yych == 'O') + goto yy1600; + if (yych == 'o') + goto yy1600; + goto yy1417; + yy1594: + yych = *++p; + if (yych == 'S') + goto yy1595; + if (yych != 's') + goto yy1417; + yy1595: + yych = *++p; + if (yych == 'E') + goto yy1596; + if (yych != 'e') + goto yy1417; + yy1596: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + goto yy1417; + } else { + if (yych <= ' ') + goto yy1457; + if (yych <= '.') + goto yy1417; + goto yy1459; + } + } else { + if (yych <= 'E') { + if (yych == '>') + goto yy1457; + goto yy1417; + } else { + if (yych <= 'F') + goto yy1597; + if (yych != 'f') + goto yy1417; + } + } + yy1597: + yych = *++p; + if (yych == 'O') + goto yy1598; + if (yych != 'o') + goto yy1417; + yy1598: + yych = *++p; + if (yych == 'N') + goto yy1599; + if (yych != 'n') + goto yy1417; + yy1599: + yych = *++p; + if (yych == 'T') + goto yy1456; + if (yych == 't') + goto yy1456; + goto yy1417; + yy1600: + yych = *++p; + if (yych == 'C') + goto yy1601; + if (yych != 'c') + goto yy1417; + yy1601: + yych = *++p; + if (yych == 'K') + goto yy1602; + if (yych != 'k') + goto yy1417; + yy1602: + yych = *++p; + if (yych == 'Q') + goto yy1603; + if (yych != 'q') + goto yy1417; + yy1603: + yych = *++p; + if (yych == 'U') + goto yy1604; + if (yych != 'u') + goto yy1417; + yy1604: + yych = *++p; + if (yych == 'O') + goto yy1605; + if (yych != 'o') + goto yy1417; + yy1605: + yych = *++p; + if (yych == 'T') + goto yy1606; + if (yych != 't') + goto yy1417; + yy1606: + yych = *++p; + if (yych == 'E') + goto yy1456; + if (yych == 'e') + goto yy1456; + goto yy1417; + yy1607: + yych = *++p; + if (yych == 'Y') + goto yy1456; + if (yych == 'y') + goto yy1456; + goto yy1417; + yy1608: + yych = *++p; + if (yych == 'I') + goto yy1619; + if (yych == 'i') + goto yy1619; + goto yy1417; + yy1609: + yych = *++p; + if (yych == 'T') + goto yy1615; + if (yych == 't') + goto yy1615; + goto yy1417; + yy1610: + yych = *++p; + if (yych == 'D') + goto yy1611; + if (yych != 'd') + goto yy1417; + yy1611: + yych = *++p; + if (yych == 'R') + goto yy1612; + if (yych != 'r') + goto yy1417; + yy1612: + yych = *++p; + if (yych == 'E') + goto yy1613; + if (yych != 'e') + goto yy1417; + yy1613: + yych = *++p; + if (yych == 'S') + goto yy1614; + if (yych != 's') + goto yy1417; + yy1614: + yych = *++p; + if (yych == 'S') + goto yy1456; + if (yych == 's') + goto yy1456; + goto yy1417; + yy1615: + yych = *++p; + if (yych == 'I') + goto yy1616; + if (yych != 'i') + goto yy1417; + yy1616: + yych = *++p; + if (yych == 'C') + goto yy1617; + if (yych != 'c') + goto yy1417; + yy1617: + yych = *++p; + if (yych == 'L') + goto yy1618; + if (yych != 'l') + goto yy1417; + yy1618: + yych = *++p; + if (yych == 'E') + goto yy1456; + if (yych == 'e') + goto yy1456; + goto yy1417; + yy1619: + yych = *++p; + if (yych == 'D') + goto yy1620; + if (yych != 'd') + goto yy1417; + yy1620: + yych = *++p; + if (yych == 'E') + goto yy1456; + if (yych == 'e') + goto yy1456; + goto yy1417; + yy1621: + yych = *++p; + if (yych == 'E') + goto yy1497; + if (yych == 'e') + goto yy1497; + goto yy1417; + yy1622: + yych = *++p; + if (yych == 'R') + goto yy1623; + if (yych != 'r') + goto yy1417; + yy1623: + yych = *++p; + if (yych == 'A') + goto yy1624; + if (yych != 'a') + goto yy1417; + yy1624: + yych = *++p; + if (yych == 'M') + goto yy1456; + if (yych == 'm') + goto yy1456; + goto yy1417; + yy1625: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy1417; + if (yych <= '\r') + goto yy1457; + goto yy1417; + } else { + if (yych <= ' ') + goto yy1457; + if (yych <= '.') + goto yy1417; + goto yy1459; + } + } else { + if (yych <= '@') { + if (yych == '>') + goto yy1457; + goto yy1417; + } else { + if (yych <= 'A') + goto yy1622; + if (yych == 'a') + goto yy1622; + goto yy1417; + } + } + yy1626: + ++p; + if ((yych = *p) <= 'U') { + if (yych <= 'N') { + if (yych == 'E') + goto yy1482; + goto yy1417; + } else { + if (yych <= 'O') + goto yy1481; + if (yych <= 'T') + goto yy1417; + goto yy1480; + } + } else { + if (yych <= 'n') { + if (yych == 'e') + goto yy1482; + goto yy1417; + } else { + if (yych <= 'o') + goto yy1481; + if (yych == 'u') + goto yy1480; + goto yy1417; + } + } + } } // Try to match an HTML block tag start line of type 7, returning // 7 if successful, 0 if not. -bufsize_t _scan_html_block_start_7(const unsigned char *p) -{ +bufsize_t _scan_html_block_start_7(const unsigned char *p) { const unsigned char *marker = NULL; -{ - unsigned char yych; - unsigned int yyaccept = 0; - static const unsigned char yybm[] = { - 0, 224, 224, 224, 224, 224, 224, 224, - 224, 198, 202, 194, 198, 194, 224, 224, - 224, 224, 224, 224, 224, 224, 224, 224, - 224, 224, 224, 224, 224, 224, 224, 224, - 198, 224, 64, 224, 224, 224, 224, 128, - 224, 224, 224, 224, 224, 241, 240, 224, - 241, 241, 241, 241, 241, 241, 241, 241, - 241, 241, 240, 224, 192, 192, 192, 224, - 224, 241, 241, 241, 241, 241, 241, 241, - 241, 241, 241, 241, 241, 241, 241, 241, - 241, 241, 241, 241, 241, 241, 241, 241, - 241, 241, 241, 224, 224, 224, 224, 240, - 192, 241, 241, 241, 241, 241, 241, 241, - 241, 241, 241, 241, 241, 241, 241, 241, - 241, 241, 241, 241, 241, 241, 241, 241, - 241, 241, 241, 224, 224, 224, 224, 224, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 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 = *(marker = p); - if (yych <= 0xDF) { - if (yych <= ';') { - if (yych != '\n') goto yy1629; - } else { - if (yych <= '<') goto yy1628; - if (yych <= 0x7F) goto yy1629; - if (yych >= 0xC2) goto yy1630; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1632; - if (yych == 0xED) goto yy1637; - goto yy1633; - } else { - if (yych <= 0xF0) goto yy1634; - if (yych <= 0xF3) goto yy1635; - if (yych <= 0xF4) goto yy1636; - } - } -yy1627: - { return 0; } -yy1628: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= '@') { - if (yych == '/') goto yy1640; - goto yy1627; - } else { - if (yych <= 'Z') goto yy1638; - if (yych <= '`') goto yy1627; - if (yych <= 'z') goto yy1638; - goto yy1627; - } -yy1629: - yych = *++p; - goto yy1627; -yy1630: - yych = *++p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1629; -yy1631: - p = marker; - if (yyaccept == 0) { - goto yy1627; - } else { - goto yy1649; - } -yy1632: - yych = *++p; - if (yych <= 0x9F) goto yy1631; - if (yych <= 0xBF) goto yy1630; - goto yy1631; -yy1633: - yych = *++p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1630; - goto yy1631; -yy1634: - yych = *++p; - if (yych <= 0x8F) goto yy1631; - if (yych <= 0xBF) goto yy1633; - goto yy1631; -yy1635: - yych = *++p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1633; - goto yy1631; -yy1636: - yych = *++p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0x8F) goto yy1633; - goto yy1631; -yy1637: - yych = *++p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0x9F) goto yy1630; - goto yy1631; -yy1638: - ++p; - yych = *p; - if (yybm[0+yych] & 1) { - goto yy1638; - } - if (yych <= ' ') { - if (yych <= 0x08) goto yy1631; - if (yych <= '\r') goto yy1651; - if (yych <= 0x1F) goto yy1631; - goto yy1651; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy1631; - goto yy1653; - } else { - if (yych == '>') goto yy1645; - goto yy1631; - } - } -yy1640: - yych = *++p; - if (yych <= '@') goto yy1631; - if (yych <= 'Z') goto yy1641; - if (yych <= '`') goto yy1631; - if (yych >= '{') goto yy1631; -yy1641: - ++p; - yych = *p; - if (yybm[0+yych] & 2) { - goto yy1643; - } - if (yych <= '=') { - if (yych <= '-') { - if (yych <= ',') goto yy1631; - goto yy1641; - } else { - if (yych <= '/') goto yy1631; - if (yych <= '9') goto yy1641; - goto yy1631; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') goto yy1645; - if (yych <= '@') goto yy1631; - goto yy1641; - } else { - if (yych <= '`') goto yy1631; - if (yych <= 'z') goto yy1641; - goto yy1631; - } - } -yy1643: - ++p; - yych = *p; - if (yybm[0+yych] & 2) { - goto yy1643; - } - if (yych != '>') goto yy1631; -yy1645: - ++p; - yych = *p; - if (yybm[0+yych] & 4) { - goto yy1645; - } - if (yych <= 0x08) goto yy1631; - if (yych <= '\n') goto yy1647; - if (yych <= '\v') goto yy1631; - if (yych <= '\r') goto yy1650; - goto yy1631; -yy1647: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 4) { - goto yy1645; - } - if (yych <= 0x08) goto yy1649; - if (yych <= '\n') goto yy1647; - if (yych <= '\v') goto yy1649; - if (yych <= '\r') goto yy1650; -yy1649: - { return 7; } -yy1650: - yych = *++p; - goto yy1649; -yy1651: - ++p; - yych = *p; - if (yych <= ':') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy1631; - if (yych <= '\r') goto yy1651; - if (yych <= 0x1F) goto yy1631; - goto yy1651; - } else { - if (yych == '/') goto yy1653; - if (yych <= '9') goto yy1631; - goto yy1654; - } - } else { - if (yych <= 'Z') { - if (yych == '>') goto yy1645; - if (yych <= '@') goto yy1631; - goto yy1654; - } else { - if (yych <= '_') { - if (yych <= '^') goto yy1631; - goto yy1654; - } else { - if (yych <= '`') goto yy1631; - if (yych <= 'z') goto yy1654; - goto yy1631; - } - } - } -yy1653: - yych = *++p; - if (yych == '>') goto yy1645; - goto yy1631; -yy1654: - ++p; - yych = *p; - if (yybm[0+yych] & 16) { - goto yy1654; - } - if (yych <= ',') { - if (yych <= '\r') { - if (yych <= 0x08) goto yy1631; - } else { - if (yych != ' ') goto yy1631; - } - } else { - if (yych <= '<') { - if (yych <= '/') goto yy1653; - goto yy1631; - } else { - if (yych <= '=') goto yy1658; - if (yych <= '>') goto yy1645; - goto yy1631; - } - } -yy1656: - ++p; - yych = *p; - if (yych <= '<') { - if (yych <= ' ') { - if (yych <= 0x08) goto yy1631; - if (yych <= '\r') goto yy1656; - if (yych <= 0x1F) goto yy1631; - goto yy1656; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy1631; - goto yy1653; - } else { - if (yych == ':') goto yy1654; - goto yy1631; - } - } - } else { - if (yych <= 'Z') { - if (yych <= '=') goto yy1658; - if (yych <= '>') goto yy1645; - if (yych <= '@') goto yy1631; - goto yy1654; - } else { - if (yych <= '_') { - if (yych <= '^') goto yy1631; - goto yy1654; - } else { - if (yych <= '`') goto yy1631; - if (yych <= 'z') goto yy1654; - goto yy1631; - } - } - } -yy1658: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1660; - } - if (yych <= 0xE0) { - if (yych <= '"') { - if (yych <= 0x00) goto yy1631; - if (yych >= '!') goto yy1671; - } else { - if (yych <= '\'') goto yy1669; - if (yych <= 0xC1) goto yy1631; - if (yych <= 0xDF) goto yy1662; - goto yy1663; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1668; - goto yy1664; - } else { - if (yych <= 0xF0) goto yy1665; - if (yych <= 0xF3) goto yy1666; - if (yych <= 0xF4) goto yy1667; - goto yy1631; - } - } - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1660; - } - if (yych <= 0xDF) { - if (yych <= '\'') { - if (yych <= 0x00) goto yy1631; - if (yych <= ' ') goto yy1694; - if (yych <= '"') goto yy1671; - goto yy1669; - } else { - if (yych == '>') goto yy1645; - if (yych <= 0xC1) goto yy1631; - goto yy1662; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1663; - if (yych == 0xED) goto yy1668; - goto yy1664; - } else { - if (yych <= 0xF0) goto yy1665; - if (yych <= 0xF3) goto yy1666; - if (yych <= 0xF4) goto yy1667; - goto yy1631; - } - } -yy1660: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1660; - } - if (yych <= 0xE0) { - if (yych <= '=') { - if (yych <= 0x00) goto yy1631; - if (yych <= ' ') goto yy1688; - goto yy1631; - } else { - if (yych <= '>') goto yy1645; - if (yych <= 0xC1) goto yy1631; - if (yych >= 0xE0) goto yy1663; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1668; - goto yy1664; - } else { - if (yych <= 0xF0) goto yy1665; - if (yych <= 0xF3) goto yy1666; - if (yych <= 0xF4) goto yy1667; - goto yy1631; - } - } -yy1662: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1660; - goto yy1631; -yy1663: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1631; - if (yych <= 0xBF) goto yy1662; - goto yy1631; -yy1664: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1662; - goto yy1631; -yy1665: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1631; - if (yych <= 0xBF) goto yy1664; - goto yy1631; -yy1666: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1664; - goto yy1631; -yy1667: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0x8F) goto yy1664; - goto yy1631; -yy1668: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0x9F) goto yy1662; - goto yy1631; -yy1669: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1669; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy1631; - if (yych <= '\'') goto yy1680; - goto yy1631; - } else { - if (yych <= 0xDF) goto yy1681; - if (yych <= 0xE0) goto yy1682; - goto yy1683; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1687; - if (yych <= 0xEF) goto yy1683; - goto yy1684; - } else { - if (yych <= 0xF3) goto yy1685; - if (yych <= 0xF4) goto yy1686; - goto yy1631; - } - } -yy1671: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1671; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy1631; - if (yych <= '"') goto yy1680; - goto yy1631; - } else { - if (yych <= 0xDF) goto yy1673; - if (yych <= 0xE0) goto yy1674; - goto yy1675; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1679; - if (yych <= 0xEF) goto yy1675; - goto yy1676; - } else { - if (yych <= 0xF3) goto yy1677; - if (yych <= 0xF4) goto yy1678; - goto yy1631; - } - } -yy1673: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1671; - goto yy1631; -yy1674: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1631; - if (yych <= 0xBF) goto yy1673; - goto yy1631; -yy1675: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1673; - goto yy1631; -yy1676: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1631; - if (yych <= 0xBF) goto yy1675; - goto yy1631; -yy1677: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1675; - goto yy1631; -yy1678: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0x8F) goto yy1675; - goto yy1631; -yy1679: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0x9F) goto yy1673; - goto yy1631; -yy1680: - ++p; - yych = *p; - if (yych <= ' ') { - if (yych <= 0x08) goto yy1631; - if (yych <= '\r') goto yy1651; - if (yych <= 0x1F) goto yy1631; - goto yy1651; - } else { - if (yych <= '/') { - if (yych <= '.') goto yy1631; - goto yy1653; - } else { - if (yych == '>') goto yy1645; - goto yy1631; - } - } -yy1681: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1669; - goto yy1631; -yy1682: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1631; - if (yych <= 0xBF) goto yy1681; - goto yy1631; -yy1683: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1681; - goto yy1631; -yy1684: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1631; - if (yych <= 0xBF) goto yy1683; - goto yy1631; -yy1685: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0xBF) goto yy1683; - goto yy1631; -yy1686: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0x8F) goto yy1683; - goto yy1631; -yy1687: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1631; - if (yych <= 0x9F) goto yy1681; - goto yy1631; -yy1688: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '"') { - if (yych <= '\r') { - if (yych <= 0x00) goto yy1631; - if (yych <= 0x08) goto yy1660; - goto yy1688; - } else { - if (yych == ' ') goto yy1688; - if (yych <= '!') goto yy1660; - goto yy1631; - } - } else { - if (yych <= ':') { - if (yych == '\'') goto yy1631; - if (yych <= '9') goto yy1660; - } else { - if (yych <= ';') goto yy1660; - if (yych <= '=') goto yy1631; - if (yych <= '>') goto yy1645; - goto yy1660; - } - } - } else { - if (yych <= 0xDF) { - if (yych <= '`') { - if (yych <= 'Z') goto yy1690; - if (yych <= '^') goto yy1660; - if (yych >= '`') goto yy1631; - } else { - if (yych <= 'z') goto yy1690; - if (yych <= 0x7F) goto yy1660; - if (yych <= 0xC1) goto yy1631; - goto yy1662; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1663; - if (yych == 0xED) goto yy1668; - goto yy1664; - } else { - if (yych <= 0xF0) goto yy1665; - if (yych <= 0xF3) goto yy1666; - if (yych <= 0xF4) goto yy1667; - goto yy1631; - } - } - } -yy1690: - ++p; - yych = *p; - if (yych <= '>') { - if (yych <= '&') { - if (yych <= 0x1F) { - if (yych <= 0x00) goto yy1631; - if (yych <= 0x08) goto yy1660; - if (yych >= 0x0E) goto yy1660; - } else { - if (yych <= ' ') goto yy1692; - if (yych == '"') goto yy1631; - goto yy1660; - } - } else { - if (yych <= '/') { - if (yych <= '\'') goto yy1631; - if (yych <= ',') goto yy1660; - if (yych <= '.') goto yy1690; - goto yy1660; - } else { - if (yych <= ';') { - if (yych <= ':') goto yy1690; - goto yy1660; - } else { - if (yych <= '<') goto yy1631; - if (yych <= '=') goto yy1658; - goto yy1645; - } - } - } - } else { - if (yych <= 0xC1) { - if (yych <= '_') { - if (yych <= '@') goto yy1660; - if (yych <= 'Z') goto yy1690; - if (yych <= '^') goto yy1660; - goto yy1690; - } else { - if (yych <= '`') goto yy1631; - if (yych <= 'z') goto yy1690; - if (yych <= 0x7F) goto yy1660; - goto yy1631; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1662; - if (yych <= 0xE0) goto yy1663; - if (yych <= 0xEC) goto yy1664; - goto yy1668; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1664; - goto yy1665; - } else { - if (yych <= 0xF3) goto yy1666; - if (yych <= 0xF4) goto yy1667; - goto yy1631; - } - } - } - } -yy1692: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '&') { - if (yych <= 0x1F) { - if (yych <= 0x00) goto yy1631; - if (yych <= 0x08) goto yy1660; - if (yych <= '\r') goto yy1692; - goto yy1660; - } else { - if (yych <= ' ') goto yy1692; - if (yych == '"') goto yy1631; - goto yy1660; - } - } else { - if (yych <= ';') { - if (yych <= '\'') goto yy1631; - if (yych == ':') goto yy1690; - goto yy1660; - } else { - if (yych <= '<') goto yy1631; - if (yych <= '=') goto yy1658; - if (yych <= '>') goto yy1645; - goto yy1660; - } - } - } else { - if (yych <= 0xDF) { - if (yych <= '`') { - if (yych <= 'Z') goto yy1690; - if (yych <= '^') goto yy1660; - if (yych <= '_') goto yy1690; - goto yy1631; - } else { - if (yych <= 'z') goto yy1690; - if (yych <= 0x7F) goto yy1660; - if (yych <= 0xC1) goto yy1631; - goto yy1662; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1663; - if (yych == 0xED) goto yy1668; - goto yy1664; - } else { - if (yych <= 0xF0) goto yy1665; - if (yych <= 0xF3) goto yy1666; - if (yych <= 0xF4) goto yy1667; - goto yy1631; - } - } - } -yy1694: - ++p; - yych = *p; - if (yych <= '@') { - if (yych <= '"') { - if (yych <= '\r') { - if (yych <= 0x00) goto yy1631; - if (yych <= 0x08) goto yy1660; - goto yy1694; - } else { - if (yych == ' ') goto yy1694; - if (yych <= '!') goto yy1660; - goto yy1671; - } - } else { - if (yych <= ':') { - if (yych == '\'') goto yy1669; - if (yych <= '9') goto yy1660; - goto yy1690; - } else { - if (yych <= ';') goto yy1660; - if (yych <= '=') goto yy1631; - if (yych <= '>') goto yy1645; - goto yy1660; - } - } - } else { - if (yych <= 0xDF) { - if (yych <= '`') { - if (yych <= 'Z') goto yy1690; - if (yych <= '^') goto yy1660; - if (yych <= '_') goto yy1690; - goto yy1631; - } else { - if (yych <= 'z') goto yy1690; - if (yych <= 0x7F) goto yy1660; - if (yych <= 0xC1) goto yy1631; - goto yy1662; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1663; - if (yych == 0xED) goto yy1668; - goto yy1664; - } else { - if (yych <= 0xF0) goto yy1665; - if (yych <= 0xF3) goto yy1666; - if (yych <= 0xF4) goto yy1667; - goto yy1631; - } - } - } -} - + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 224, 224, 224, 224, 224, 224, 224, 224, 198, 202, 194, 198, 194, + 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 198, 224, 64, 224, 224, 224, 224, 128, 224, 224, + 224, 224, 224, 241, 240, 224, 241, 241, 241, 241, 241, 241, 241, 241, + 241, 241, 240, 224, 192, 192, 192, 224, 224, 241, 241, 241, 241, 241, + 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, + 241, 241, 241, 241, 241, 241, 241, 224, 224, 224, 224, 240, 192, 241, + 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, + 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 224, 224, 224, + 224, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); + if (yych <= 0xDF) { + if (yych <= ';') { + if (yych != '\n') + goto yy1631; + } else { + if (yych <= '<') + goto yy1630; + if (yych <= 0x7F) + goto yy1631; + if (yych >= 0xC2) + goto yy1632; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1634; + if (yych == 0xED) + goto yy1639; + goto yy1635; + } else { + if (yych <= 0xF0) + goto yy1636; + if (yych <= 0xF3) + goto yy1637; + if (yych <= 0xF4) + goto yy1638; + } + } + yy1629 : { return 0; } + yy1630: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '@') { + if (yych == '/') + goto yy1642; + goto yy1629; + } else { + if (yych <= 'Z') + goto yy1640; + if (yych <= '`') + goto yy1629; + if (yych <= 'z') + goto yy1640; + goto yy1629; + } + yy1631: + yych = *++p; + goto yy1629; + yy1632: + yych = *++p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1631; + yy1633: + p = marker; + if (yyaccept == 0) { + goto yy1629; + } else { + goto yy1651; + } + yy1634: + yych = *++p; + if (yych <= 0x9F) + goto yy1633; + if (yych <= 0xBF) + goto yy1632; + goto yy1633; + yy1635: + yych = *++p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1632; + goto yy1633; + yy1636: + yych = *++p; + if (yych <= 0x8F) + goto yy1633; + if (yych <= 0xBF) + goto yy1635; + goto yy1633; + yy1637: + yych = *++p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1635; + goto yy1633; + yy1638: + yych = *++p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0x8F) + goto yy1635; + goto yy1633; + yy1639: + yych = *++p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0x9F) + goto yy1632; + goto yy1633; + yy1640: + ++p; + yych = *p; + if (yybm[0 + yych] & 1) { + goto yy1640; + } + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1633; + if (yych <= '\r') + goto yy1653; + if (yych <= 0x1F) + goto yy1633; + goto yy1653; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy1633; + goto yy1655; + } else { + if (yych == '>') + goto yy1647; + goto yy1633; + } + } + yy1642: + yych = *++p; + if (yych <= '@') + goto yy1633; + if (yych <= 'Z') + goto yy1643; + if (yych <= '`') + goto yy1633; + if (yych >= '{') + goto yy1633; + yy1643: + ++p; + yych = *p; + if (yybm[0 + yych] & 2) { + goto yy1645; + } + if (yych <= '=') { + if (yych <= '-') { + if (yych <= ',') + goto yy1633; + goto yy1643; + } else { + if (yych <= '/') + goto yy1633; + if (yych <= '9') + goto yy1643; + goto yy1633; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy1647; + if (yych <= '@') + goto yy1633; + goto yy1643; + } else { + if (yych <= '`') + goto yy1633; + if (yych <= 'z') + goto yy1643; + goto yy1633; + } + } + yy1645: + ++p; + yych = *p; + if (yybm[0 + yych] & 2) { + goto yy1645; + } + if (yych != '>') + goto yy1633; + yy1647: + ++p; + yych = *p; + if (yybm[0 + yych] & 4) { + goto yy1647; + } + if (yych <= 0x08) + goto yy1633; + if (yych <= '\n') + goto yy1649; + if (yych <= '\v') + goto yy1633; + if (yych <= '\r') + goto yy1652; + goto yy1633; + yy1649: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 4) { + goto yy1647; + } + if (yych <= 0x08) + goto yy1651; + if (yych <= '\n') + goto yy1649; + if (yych <= '\v') + goto yy1651; + if (yych <= '\r') + goto yy1652; + yy1651 : { return 7; } + yy1652: + yych = *++p; + goto yy1651; + yy1653: + ++p; + yych = *p; + if (yych <= ':') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1633; + if (yych <= '\r') + goto yy1653; + if (yych <= 0x1F) + goto yy1633; + goto yy1653; + } else { + if (yych == '/') + goto yy1655; + if (yych <= '9') + goto yy1633; + goto yy1656; + } + } else { + if (yych <= 'Z') { + if (yych == '>') + goto yy1647; + if (yych <= '@') + goto yy1633; + goto yy1656; + } else { + if (yych <= '_') { + if (yych <= '^') + goto yy1633; + goto yy1656; + } else { + if (yych <= '`') + goto yy1633; + if (yych <= 'z') + goto yy1656; + goto yy1633; + } + } + } + yy1655: + yych = *++p; + if (yych == '>') + goto yy1647; + goto yy1633; + yy1656: + ++p; + yych = *p; + if (yybm[0 + yych] & 16) { + goto yy1656; + } + if (yych <= ',') { + if (yych <= '\r') { + if (yych <= 0x08) + goto yy1633; + } else { + if (yych != ' ') + goto yy1633; + } + } else { + if (yych <= '<') { + if (yych <= '/') + goto yy1655; + goto yy1633; + } else { + if (yych <= '=') + goto yy1660; + if (yych <= '>') + goto yy1647; + goto yy1633; + } + } + yy1658: + ++p; + yych = *p; + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1633; + if (yych <= '\r') + goto yy1658; + if (yych <= 0x1F) + goto yy1633; + goto yy1658; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy1633; + goto yy1655; + } else { + if (yych == ':') + goto yy1656; + goto yy1633; + } + } + } else { + if (yych <= 'Z') { + if (yych <= '=') + goto yy1660; + if (yych <= '>') + goto yy1647; + if (yych <= '@') + goto yy1633; + goto yy1656; + } else { + if (yych <= '_') { + if (yych <= '^') + goto yy1633; + goto yy1656; + } else { + if (yych <= '`') + goto yy1633; + if (yych <= 'z') + goto yy1656; + goto yy1633; + } + } + } + yy1660: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy1662; + } + if (yych <= 0xE0) { + if (yych <= '"') { + if (yych <= 0x00) + goto yy1633; + if (yych >= '!') + goto yy1673; + } else { + if (yych <= '\'') + goto yy1671; + if (yych <= 0xC1) + goto yy1633; + if (yych <= 0xDF) + goto yy1664; + goto yy1665; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1670; + goto yy1666; + } else { + if (yych <= 0xF0) + goto yy1667; + if (yych <= 0xF3) + goto yy1668; + if (yych <= 0xF4) + goto yy1669; + goto yy1633; + } + } + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy1662; + } + if (yych <= 0xDF) { + if (yych <= '\'') { + if (yych <= 0x00) + goto yy1633; + if (yych <= ' ') + goto yy1696; + if (yych <= '"') + goto yy1673; + goto yy1671; + } else { + if (yych == '>') + goto yy1647; + if (yych <= 0xC1) + goto yy1633; + goto yy1664; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1665; + if (yych == 0xED) + goto yy1670; + goto yy1666; + } else { + if (yych <= 0xF0) + goto yy1667; + if (yych <= 0xF3) + goto yy1668; + if (yych <= 0xF4) + goto yy1669; + goto yy1633; + } + } + yy1662: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy1662; + } + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy1633; + if (yych <= ' ') + goto yy1690; + goto yy1633; + } else { + if (yych <= '>') + goto yy1647; + if (yych <= 0xC1) + goto yy1633; + if (yych >= 0xE0) + goto yy1665; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1670; + goto yy1666; + } else { + if (yych <= 0xF0) + goto yy1667; + if (yych <= 0xF3) + goto yy1668; + if (yych <= 0xF4) + goto yy1669; + goto yy1633; + } + } + yy1664: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1662; + goto yy1633; + yy1665: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1633; + if (yych <= 0xBF) + goto yy1664; + goto yy1633; + yy1666: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1664; + goto yy1633; + yy1667: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1633; + if (yych <= 0xBF) + goto yy1666; + goto yy1633; + yy1668: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1666; + goto yy1633; + yy1669: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0x8F) + goto yy1666; + goto yy1633; + yy1670: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0x9F) + goto yy1664; + goto yy1633; + yy1671: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1671; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy1633; + if (yych <= '\'') + goto yy1682; + goto yy1633; + } else { + if (yych <= 0xDF) + goto yy1683; + if (yych <= 0xE0) + goto yy1684; + goto yy1685; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1689; + if (yych <= 0xEF) + goto yy1685; + goto yy1686; + } else { + if (yych <= 0xF3) + goto yy1687; + if (yych <= 0xF4) + goto yy1688; + goto yy1633; + } + } + yy1673: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1673; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy1633; + if (yych <= '"') + goto yy1682; + goto yy1633; + } else { + if (yych <= 0xDF) + goto yy1675; + if (yych <= 0xE0) + goto yy1676; + goto yy1677; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1681; + if (yych <= 0xEF) + goto yy1677; + goto yy1678; + } else { + if (yych <= 0xF3) + goto yy1679; + if (yych <= 0xF4) + goto yy1680; + goto yy1633; + } + } + yy1675: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1673; + goto yy1633; + yy1676: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1633; + if (yych <= 0xBF) + goto yy1675; + goto yy1633; + yy1677: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1675; + goto yy1633; + yy1678: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1633; + if (yych <= 0xBF) + goto yy1677; + goto yy1633; + yy1679: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1677; + goto yy1633; + yy1680: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0x8F) + goto yy1677; + goto yy1633; + yy1681: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0x9F) + goto yy1675; + goto yy1633; + yy1682: + ++p; + yych = *p; + if (yych <= ' ') { + if (yych <= 0x08) + goto yy1633; + if (yych <= '\r') + goto yy1653; + if (yych <= 0x1F) + goto yy1633; + goto yy1653; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy1633; + goto yy1655; + } else { + if (yych == '>') + goto yy1647; + goto yy1633; + } + } + yy1683: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1671; + goto yy1633; + yy1684: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1633; + if (yych <= 0xBF) + goto yy1683; + goto yy1633; + yy1685: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1683; + goto yy1633; + yy1686: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1633; + if (yych <= 0xBF) + goto yy1685; + goto yy1633; + yy1687: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0xBF) + goto yy1685; + goto yy1633; + yy1688: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0x8F) + goto yy1685; + goto yy1633; + yy1689: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1633; + if (yych <= 0x9F) + goto yy1683; + goto yy1633; + yy1690: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '"') { + if (yych <= '\r') { + if (yych <= 0x00) + goto yy1633; + if (yych <= 0x08) + goto yy1662; + goto yy1690; + } else { + if (yych == ' ') + goto yy1690; + if (yych <= '!') + goto yy1662; + goto yy1633; + } + } else { + if (yych <= ':') { + if (yych == '\'') + goto yy1633; + if (yych <= '9') + goto yy1662; + } else { + if (yych <= ';') + goto yy1662; + if (yych <= '=') + goto yy1633; + if (yych <= '>') + goto yy1647; + goto yy1662; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') + goto yy1692; + if (yych <= '^') + goto yy1662; + if (yych >= '`') + goto yy1633; + } else { + if (yych <= 'z') + goto yy1692; + if (yych <= 0x7F) + goto yy1662; + if (yych <= 0xC1) + goto yy1633; + goto yy1664; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1665; + if (yych == 0xED) + goto yy1670; + goto yy1666; + } else { + if (yych <= 0xF0) + goto yy1667; + if (yych <= 0xF3) + goto yy1668; + if (yych <= 0xF4) + goto yy1669; + goto yy1633; + } + } + } + yy1692: + ++p; + yych = *p; + if (yych <= '>') { + if (yych <= '&') { + if (yych <= 0x1F) { + if (yych <= 0x00) + goto yy1633; + if (yych <= 0x08) + goto yy1662; + if (yych >= 0x0E) + goto yy1662; + } else { + if (yych <= ' ') + goto yy1694; + if (yych == '"') + goto yy1633; + goto yy1662; + } + } else { + if (yych <= '/') { + if (yych <= '\'') + goto yy1633; + if (yych <= ',') + goto yy1662; + if (yych <= '.') + goto yy1692; + goto yy1662; + } else { + if (yych <= ';') { + if (yych <= ':') + goto yy1692; + goto yy1662; + } else { + if (yych <= '<') + goto yy1633; + if (yych <= '=') + goto yy1660; + goto yy1647; + } + } + } + } else { + if (yych <= 0xC1) { + if (yych <= '_') { + if (yych <= '@') + goto yy1662; + if (yych <= 'Z') + goto yy1692; + if (yych <= '^') + goto yy1662; + goto yy1692; + } else { + if (yych <= '`') + goto yy1633; + if (yych <= 'z') + goto yy1692; + if (yych <= 0x7F) + goto yy1662; + goto yy1633; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1664; + if (yych <= 0xE0) + goto yy1665; + if (yych <= 0xEC) + goto yy1666; + goto yy1670; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1666; + goto yy1667; + } else { + if (yych <= 0xF3) + goto yy1668; + if (yych <= 0xF4) + goto yy1669; + goto yy1633; + } + } + } + } + yy1694: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '&') { + if (yych <= 0x1F) { + if (yych <= 0x00) + goto yy1633; + if (yych <= 0x08) + goto yy1662; + if (yych <= '\r') + goto yy1694; + goto yy1662; + } else { + if (yych <= ' ') + goto yy1694; + if (yych == '"') + goto yy1633; + goto yy1662; + } + } else { + if (yych <= ';') { + if (yych <= '\'') + goto yy1633; + if (yych == ':') + goto yy1692; + goto yy1662; + } else { + if (yych <= '<') + goto yy1633; + if (yych <= '=') + goto yy1660; + if (yych <= '>') + goto yy1647; + goto yy1662; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') + goto yy1692; + if (yych <= '^') + goto yy1662; + if (yych <= '_') + goto yy1692; + goto yy1633; + } else { + if (yych <= 'z') + goto yy1692; + if (yych <= 0x7F) + goto yy1662; + if (yych <= 0xC1) + goto yy1633; + goto yy1664; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1665; + if (yych == 0xED) + goto yy1670; + goto yy1666; + } else { + if (yych <= 0xF0) + goto yy1667; + if (yych <= 0xF3) + goto yy1668; + if (yych <= 0xF4) + goto yy1669; + goto yy1633; + } + } + } + yy1696: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '"') { + if (yych <= '\r') { + if (yych <= 0x00) + goto yy1633; + if (yych <= 0x08) + goto yy1662; + goto yy1696; + } else { + if (yych == ' ') + goto yy1696; + if (yych <= '!') + goto yy1662; + goto yy1673; + } + } else { + if (yych <= ':') { + if (yych == '\'') + goto yy1671; + if (yych <= '9') + goto yy1662; + goto yy1692; + } else { + if (yych <= ';') + goto yy1662; + if (yych <= '=') + goto yy1633; + if (yych <= '>') + goto yy1647; + goto yy1662; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') + goto yy1692; + if (yych <= '^') + goto yy1662; + if (yych <= '_') + goto yy1692; + goto yy1633; + } else { + if (yych <= 'z') + goto yy1692; + if (yych <= 0x7F) + goto yy1662; + if (yych <= 0xC1) + goto yy1633; + goto yy1664; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1665; + if (yych == 0xED) + goto yy1670; + goto yy1666; + } else { + if (yych <= 0xF0) + goto yy1667; + if (yych <= 0xF3) + goto yy1668; + if (yych <= 0xF4) + goto yy1669; + goto yy1633; + } + } + } + } } // Try to match an HTML block end line of type 1 -bufsize_t _scan_html_block_end_1(const unsigned char *p) -{ +bufsize_t _scan_html_block_end_1(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[] = { - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 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, 64, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 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, - }; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= ';') { - if (yych != '\n') goto yy1699; - } else { - if (yych <= '<') goto yy1700; - if (yych <= 0x7F) goto yy1699; - if (yych >= 0xC2) goto yy1701; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1703; - if (yych == 0xED) goto yy1708; - goto yy1704; - } else { - if (yych <= 0xF0) goto yy1705; - if (yych <= 0xF3) goto yy1706; - if (yych <= 0xF4) goto yy1707; - } - } -yy1698: - { return 0; } -yy1699: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych == '\n') goto yy1698; - goto yy1713; - } else { - if (yych <= 0xC1) goto yy1698; - if (yych <= 0xF4) goto yy1713; - goto yy1698; - } -yy1700: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= '/') { - if (yych == '\n') goto yy1698; - if (yych <= '.') goto yy1713; - goto yy1709; - } else { - if (yych <= 0x7F) goto yy1713; - if (yych <= 0xC1) goto yy1698; - if (yych <= 0xF4) goto yy1713; - goto yy1698; - } -yy1701: - yych = *++p; - if (yych <= 0x7F) goto yy1702; - if (yych <= 0xBF) goto yy1699; -yy1702: - p = marker; - if (yyaccept == 0) { - goto yy1698; - } else { - goto yy1730; - } -yy1703: - yych = *++p; - if (yych <= 0x9F) goto yy1702; - if (yych <= 0xBF) goto yy1701; - goto yy1702; -yy1704: - yych = *++p; - if (yych <= 0x7F) goto yy1702; - if (yych <= 0xBF) goto yy1701; - goto yy1702; -yy1705: - yych = *++p; - if (yych <= 0x8F) goto yy1702; - if (yych <= 0xBF) goto yy1704; - goto yy1702; -yy1706: - yych = *++p; - if (yych <= 0x7F) goto yy1702; - if (yych <= 0xBF) goto yy1704; - goto yy1702; -yy1707: - yych = *++p; - if (yych <= 0x7F) goto yy1702; - if (yych <= 0x8F) goto yy1704; - goto yy1702; -yy1708: - yych = *++p; - if (yych <= 0x7F) goto yy1702; - if (yych <= 0x9F) goto yy1701; - goto yy1702; -yy1709: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 's') { - if (yych <= 'R') { - if (yych <= '\n') { - if (yych <= '\t') goto yy1712; - goto yy1702; - } else { - if (yych == 'P') goto yy1721; - goto yy1712; - } - } else { - if (yych <= 'o') { - if (yych <= 'S') goto yy1722; - goto yy1712; - } else { - if (yych <= 'p') goto yy1721; - if (yych <= 'r') goto yy1712; - goto yy1722; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } else { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - goto yy1716; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1720; - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } -yy1710: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xDF) { - if (yych <= '.') { - if (yych == '\n') goto yy1702; - } else { - if (yych <= '/') goto yy1709; - if (yych <= 0x7F) goto yy1712; - if (yych <= 0xC1) goto yy1702; - goto yy1714; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1715; - if (yych == 0xED) goto yy1720; - goto yy1716; - } else { - if (yych <= 0xF0) goto yy1717; - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } -yy1712: - ++p; - yych = *p; -yy1713: - if (yybm[0+yych] & 128) { - goto yy1712; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1702; - if (yych <= '<') goto yy1710; - goto yy1702; - } else { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - goto yy1716; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1720; - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } -yy1714: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1702; - if (yych <= 0xBF) goto yy1712; - goto yy1702; -yy1715: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1702; - if (yych <= 0xBF) goto yy1714; - goto yy1702; -yy1716: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1702; - if (yych <= 0xBF) goto yy1714; - goto yy1702; -yy1717: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1702; - if (yych <= 0xBF) goto yy1716; - goto yy1702; -yy1718: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1702; - if (yych <= 0xBF) goto yy1716; - goto yy1702; -yy1719: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1702; - if (yych <= 0x8F) goto yy1716; - goto yy1702; -yy1720: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1702; - if (yych <= 0x9F) goto yy1714; - goto yy1702; -yy1721: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xC1) { - if (yych <= 'R') { - if (yych == '\n') goto yy1702; - if (yych <= 'Q') goto yy1712; - goto yy1733; - } else { - if (yych == 'r') goto yy1733; - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - if (yych <= 0xEC) goto yy1716; - goto yy1720; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } -yy1722: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 't') { - if (yych <= 'S') { - if (yych <= '\n') { - if (yych <= '\t') goto yy1712; - goto yy1702; - } else { - if (yych == 'C') goto yy1724; - goto yy1712; - } - } else { - if (yych <= 'b') { - if (yych >= 'U') goto yy1712; - } else { - if (yych <= 'c') goto yy1724; - if (yych <= 's') goto yy1712; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } else { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - goto yy1716; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1720; - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xC1) { - if (yych <= 'Y') { - if (yych == '\n') goto yy1702; - if (yych <= 'X') goto yy1712; - goto yy1731; - } else { - if (yych == 'y') goto yy1731; - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - if (yych <= 0xEC) goto yy1716; - goto yy1720; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } -yy1724: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xC1) { - if (yych <= 'R') { - if (yych == '\n') goto yy1702; - if (yych <= 'Q') goto yy1712; - } else { - if (yych == 'r') goto yy1725; - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - if (yych <= 0xEC) goto yy1716; - goto yy1720; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } -yy1725: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xC1) { - if (yych <= 'I') { - if (yych == '\n') goto yy1702; - if (yych <= 'H') goto yy1712; - } else { - if (yych == 'i') goto yy1726; - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - if (yych <= 0xEC) goto yy1716; - goto yy1720; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } -yy1726: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xC1) { - if (yych <= 'P') { - if (yych == '\n') goto yy1702; - if (yych <= 'O') goto yy1712; - } else { - if (yych == 'p') goto yy1727; - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - if (yych <= 0xEC) goto yy1716; - goto yy1720; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } -yy1727: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xC1) { - if (yych <= 'T') { - if (yych == '\n') goto yy1702; - if (yych <= 'S') goto yy1712; - } else { - if (yych == 't') goto yy1728; - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - if (yych <= 0xEC) goto yy1716; - goto yy1720; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } -yy1728: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xDF) { - if (yych <= '=') { - if (yych == '\n') goto yy1702; - goto yy1712; - } else { - if (yych <= '>') goto yy1729; - if (yych <= 0x7F) goto yy1712; - if (yych <= 0xC1) goto yy1702; - goto yy1714; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1715; - if (yych == 0xED) goto yy1720; - goto yy1716; - } else { - if (yych <= 0xF0) goto yy1717; - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } -yy1729: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1712; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1730; - if (yych <= '<') goto yy1710; - } else { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - goto yy1716; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1720; - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - } - } -yy1730: - { return (bufsize_t)(p - start); } -yy1731: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xC1) { - if (yych <= 'L') { - if (yych == '\n') goto yy1702; - if (yych <= 'K') goto yy1712; - } else { - if (yych == 'l') goto yy1732; - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - if (yych <= 0xEC) goto yy1716; - goto yy1720; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } -yy1732: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xC1) { - if (yych <= 'E') { - if (yych == '\n') goto yy1702; - if (yych <= 'D') goto yy1712; - goto yy1728; - } else { - if (yych == 'e') goto yy1728; - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - if (yych <= 0xEC) goto yy1716; - goto yy1720; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } -yy1733: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1710; - } - if (yych <= 0xC1) { - if (yych <= 'E') { - if (yych == '\n') goto yy1702; - if (yych <= 'D') goto yy1712; - goto yy1728; - } else { - if (yych == 'e') goto yy1728; - if (yych <= 0x7F) goto yy1712; - goto yy1702; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1714; - if (yych <= 0xE0) goto yy1715; - if (yych <= 0xEC) goto yy1716; - goto yy1720; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1716; - goto yy1717; - } else { - if (yych <= 0xF3) goto yy1718; - if (yych <= 0xF4) goto yy1719; - goto yy1702; - } - } - } -} - + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 64, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 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, + }; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= ';') { + if (yych != '\n') + goto yy1701; + } else { + if (yych <= '<') + goto yy1702; + if (yych <= 0x7F) + goto yy1701; + if (yych >= 0xC2) + goto yy1703; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1705; + if (yych == 0xED) + goto yy1710; + goto yy1706; + } else { + if (yych <= 0xF0) + goto yy1707; + if (yych <= 0xF3) + goto yy1708; + if (yych <= 0xF4) + goto yy1709; + } + } + yy1700 : { return 0; } + yy1701: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych == '\n') + goto yy1700; + goto yy1715; + } else { + if (yych <= 0xC1) + goto yy1700; + if (yych <= 0xF4) + goto yy1715; + goto yy1700; + } + yy1702: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '/') { + if (yych == '\n') + goto yy1700; + if (yych <= '.') + goto yy1715; + goto yy1711; + } else { + if (yych <= 0x7F) + goto yy1715; + if (yych <= 0xC1) + goto yy1700; + if (yych <= 0xF4) + goto yy1715; + goto yy1700; + } + yy1703: + yych = *++p; + if (yych <= 0x7F) + goto yy1704; + if (yych <= 0xBF) + goto yy1701; + yy1704: + p = marker; + if (yyaccept == 0) { + goto yy1700; + } else { + goto yy1732; + } + yy1705: + yych = *++p; + if (yych <= 0x9F) + goto yy1704; + if (yych <= 0xBF) + goto yy1703; + goto yy1704; + yy1706: + yych = *++p; + if (yych <= 0x7F) + goto yy1704; + if (yych <= 0xBF) + goto yy1703; + goto yy1704; + yy1707: + yych = *++p; + if (yych <= 0x8F) + goto yy1704; + if (yych <= 0xBF) + goto yy1706; + goto yy1704; + yy1708: + yych = *++p; + if (yych <= 0x7F) + goto yy1704; + if (yych <= 0xBF) + goto yy1706; + goto yy1704; + yy1709: + yych = *++p; + if (yych <= 0x7F) + goto yy1704; + if (yych <= 0x8F) + goto yy1706; + goto yy1704; + yy1710: + yych = *++p; + if (yych <= 0x7F) + goto yy1704; + if (yych <= 0x9F) + goto yy1703; + goto yy1704; + yy1711: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 's') { + if (yych <= 'R') { + if (yych <= '\n') { + if (yych <= '\t') + goto yy1714; + goto yy1704; + } else { + if (yych == 'P') + goto yy1723; + goto yy1714; + } + } else { + if (yych <= 'o') { + if (yych <= 'S') + goto yy1724; + goto yy1714; + } else { + if (yych <= 'p') + goto yy1723; + if (yych <= 'r') + goto yy1714; + goto yy1724; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } else { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + goto yy1718; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1722; + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + yy1712: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xDF) { + if (yych <= '.') { + if (yych == '\n') + goto yy1704; + } else { + if (yych <= '/') + goto yy1711; + if (yych <= 0x7F) + goto yy1714; + if (yych <= 0xC1) + goto yy1704; + goto yy1716; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1717; + if (yych == 0xED) + goto yy1722; + goto yy1718; + } else { + if (yych <= 0xF0) + goto yy1719; + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + yy1714: + ++p; + yych = *p; + yy1715: + if (yybm[0 + yych] & 128) { + goto yy1714; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1704; + if (yych <= '<') + goto yy1712; + goto yy1704; + } else { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + goto yy1718; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1722; + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + yy1716: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1704; + if (yych <= 0xBF) + goto yy1714; + goto yy1704; + yy1717: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1704; + if (yych <= 0xBF) + goto yy1716; + goto yy1704; + yy1718: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1704; + if (yych <= 0xBF) + goto yy1716; + goto yy1704; + yy1719: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1704; + if (yych <= 0xBF) + goto yy1718; + goto yy1704; + yy1720: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1704; + if (yych <= 0xBF) + goto yy1718; + goto yy1704; + yy1721: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1704; + if (yych <= 0x8F) + goto yy1718; + goto yy1704; + yy1722: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1704; + if (yych <= 0x9F) + goto yy1716; + goto yy1704; + yy1723: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xC1) { + if (yych <= 'R') { + if (yych == '\n') + goto yy1704; + if (yych <= 'Q') + goto yy1714; + goto yy1735; + } else { + if (yych == 'r') + goto yy1735; + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + if (yych <= 0xEC) + goto yy1718; + goto yy1722; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + yy1724: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 't') { + if (yych <= 'S') { + if (yych <= '\n') { + if (yych <= '\t') + goto yy1714; + goto yy1704; + } else { + if (yych == 'C') + goto yy1726; + goto yy1714; + } + } else { + if (yych <= 'b') { + if (yych >= 'U') + goto yy1714; + } else { + if (yych <= 'c') + goto yy1726; + if (yych <= 's') + goto yy1714; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } else { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + goto yy1718; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1722; + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xC1) { + if (yych <= 'Y') { + if (yych == '\n') + goto yy1704; + if (yych <= 'X') + goto yy1714; + goto yy1733; + } else { + if (yych == 'y') + goto yy1733; + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + if (yych <= 0xEC) + goto yy1718; + goto yy1722; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + yy1726: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xC1) { + if (yych <= 'R') { + if (yych == '\n') + goto yy1704; + if (yych <= 'Q') + goto yy1714; + } else { + if (yych == 'r') + goto yy1727; + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + if (yych <= 0xEC) + goto yy1718; + goto yy1722; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + yy1727: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xC1) { + if (yych <= 'I') { + if (yych == '\n') + goto yy1704; + if (yych <= 'H') + goto yy1714; + } else { + if (yych == 'i') + goto yy1728; + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + if (yych <= 0xEC) + goto yy1718; + goto yy1722; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + yy1728: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xC1) { + if (yych <= 'P') { + if (yych == '\n') + goto yy1704; + if (yych <= 'O') + goto yy1714; + } else { + if (yych == 'p') + goto yy1729; + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + if (yych <= 0xEC) + goto yy1718; + goto yy1722; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + yy1729: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xC1) { + if (yych <= 'T') { + if (yych == '\n') + goto yy1704; + if (yych <= 'S') + goto yy1714; + } else { + if (yych == 't') + goto yy1730; + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + if (yych <= 0xEC) + goto yy1718; + goto yy1722; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + yy1730: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych == '\n') + goto yy1704; + goto yy1714; + } else { + if (yych <= '>') + goto yy1731; + if (yych <= 0x7F) + goto yy1714; + if (yych <= 0xC1) + goto yy1704; + goto yy1716; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1717; + if (yych == 0xED) + goto yy1722; + goto yy1718; + } else { + if (yych <= 0xF0) + goto yy1719; + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + yy1731: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1714; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1732; + if (yych <= '<') + goto yy1712; + } else { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + goto yy1718; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1722; + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + } + } + yy1732 : { return (bufsize_t)(p - start); } + yy1733: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xC1) { + if (yych <= 'L') { + if (yych == '\n') + goto yy1704; + if (yych <= 'K') + goto yy1714; + } else { + if (yych == 'l') + goto yy1734; + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + if (yych <= 0xEC) + goto yy1718; + goto yy1722; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + yy1734: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xC1) { + if (yych <= 'E') { + if (yych == '\n') + goto yy1704; + if (yych <= 'D') + goto yy1714; + goto yy1730; + } else { + if (yych == 'e') + goto yy1730; + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + if (yych <= 0xEC) + goto yy1718; + goto yy1722; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + yy1735: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1712; + } + if (yych <= 0xC1) { + if (yych <= 'E') { + if (yych == '\n') + goto yy1704; + if (yych <= 'D') + goto yy1714; + goto yy1730; + } else { + if (yych == 'e') + goto yy1730; + if (yych <= 0x7F) + goto yy1714; + goto yy1704; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1716; + if (yych <= 0xE0) + goto yy1717; + if (yych <= 0xEC) + goto yy1718; + goto yy1722; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1718; + goto yy1719; + } else { + if (yych <= 0xF3) + goto yy1720; + if (yych <= 0xF4) + goto yy1721; + goto yy1704; + } + } + } + } } // Try to match an HTML block end line of type 2 -bufsize_t _scan_html_block_end_2(const unsigned char *p) -{ +bufsize_t _scan_html_block_end_2(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[] = { - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 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, 64, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 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, - }; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= ',') { - if (yych != '\n') goto yy1737; - } else { - if (yych <= '-') goto yy1738; - if (yych <= 0x7F) goto yy1737; - if (yych >= 0xC2) goto yy1739; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1741; - if (yych == 0xED) goto yy1746; - goto yy1742; - } else { - if (yych <= 0xF0) goto yy1743; - if (yych <= 0xF3) goto yy1744; - if (yych <= 0xF4) goto yy1745; - } - } -yy1736: - { return 0; } -yy1737: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych == '\n') goto yy1736; - goto yy1750; - } else { - if (yych <= 0xC1) goto yy1736; - if (yych <= 0xF4) goto yy1750; - goto yy1736; - } -yy1738: - yyaccept = 0; - yych = *(marker = ++p); - if (yybm[0+yych] & 64) { - goto yy1747; - } - if (yych <= 0x7F) { - if (yych == '\n') goto yy1736; - goto yy1750; - } else { - if (yych <= 0xC1) goto yy1736; - if (yych <= 0xF4) goto yy1750; - goto yy1736; - } -yy1739: - yych = *++p; - if (yych <= 0x7F) goto yy1740; - if (yych <= 0xBF) goto yy1737; -yy1740: - p = marker; - if (yyaccept == 0) { - goto yy1736; - } else { - goto yy1760; - } -yy1741: - yych = *++p; - if (yych <= 0x9F) goto yy1740; - if (yych <= 0xBF) goto yy1739; - goto yy1740; -yy1742: - yych = *++p; - if (yych <= 0x7F) goto yy1740; - if (yych <= 0xBF) goto yy1739; - goto yy1740; -yy1743: - yych = *++p; - if (yych <= 0x8F) goto yy1740; - if (yych <= 0xBF) goto yy1742; - goto yy1740; -yy1744: - yych = *++p; - if (yych <= 0x7F) goto yy1740; - if (yych <= 0xBF) goto yy1742; - goto yy1740; -yy1745: - yych = *++p; - if (yych <= 0x7F) goto yy1740; - if (yych <= 0x8F) goto yy1742; - goto yy1740; -yy1746: - yych = *++p; - if (yych <= 0x7F) goto yy1740; - if (yych <= 0x9F) goto yy1739; - goto yy1740; -yy1747: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1747; - } - if (yych <= 0xDF) { - if (yych <= '=') { - if (yych == '\n') goto yy1740; - } else { - if (yych <= '>') goto yy1759; - if (yych <= 0x7F) goto yy1749; - if (yych <= 0xC1) goto yy1740; - goto yy1751; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1752; - if (yych == 0xED) goto yy1757; - goto yy1753; - } else { - if (yych <= 0xF0) goto yy1754; - if (yych <= 0xF3) goto yy1755; - if (yych <= 0xF4) goto yy1756; - goto yy1740; - } - } -yy1749: - ++p; - yych = *p; -yy1750: - if (yybm[0+yych] & 128) { - goto yy1749; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1740; - if (yych <= '-') goto yy1758; - goto yy1740; - } else { - if (yych <= 0xDF) goto yy1751; - if (yych <= 0xE0) goto yy1752; - goto yy1753; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1757; - if (yych <= 0xEF) goto yy1753; - goto yy1754; - } else { - if (yych <= 0xF3) goto yy1755; - if (yych <= 0xF4) goto yy1756; - goto yy1740; - } - } -yy1751: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1740; - if (yych <= 0xBF) goto yy1749; - goto yy1740; -yy1752: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1740; - if (yych <= 0xBF) goto yy1751; - goto yy1740; -yy1753: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1740; - if (yych <= 0xBF) goto yy1751; - goto yy1740; -yy1754: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1740; - if (yych <= 0xBF) goto yy1753; - goto yy1740; -yy1755: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1740; - if (yych <= 0xBF) goto yy1753; - goto yy1740; -yy1756: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1740; - if (yych <= 0x8F) goto yy1753; - goto yy1740; -yy1757: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1740; - if (yych <= 0x9F) goto yy1751; - goto yy1740; -yy1758: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1749; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1740; - if (yych <= '-') goto yy1747; - goto yy1740; - } else { - if (yych <= 0xDF) goto yy1751; - if (yych <= 0xE0) goto yy1752; - goto yy1753; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1757; - if (yych <= 0xEF) goto yy1753; - goto yy1754; - } else { - if (yych <= 0xF3) goto yy1755; - if (yych <= 0xF4) goto yy1756; - goto yy1740; - } - } -yy1759: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1749; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1760; - if (yych <= '-') goto yy1758; - } else { - if (yych <= 0xDF) goto yy1751; - if (yych <= 0xE0) goto yy1752; - goto yy1753; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1757; - if (yych <= 0xEF) goto yy1753; - goto yy1754; - } else { - if (yych <= 0xF3) goto yy1755; - if (yych <= 0xF4) goto yy1756; - } - } -yy1760: - { return (bufsize_t)(p - start); } -} - + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 64, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 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, + }; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= ',') { + if (yych != '\n') + goto yy1739; + } else { + if (yych <= '-') + goto yy1740; + if (yych <= 0x7F) + goto yy1739; + if (yych >= 0xC2) + goto yy1741; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1743; + if (yych == 0xED) + goto yy1748; + goto yy1744; + } else { + if (yych <= 0xF0) + goto yy1745; + if (yych <= 0xF3) + goto yy1746; + if (yych <= 0xF4) + goto yy1747; + } + } + yy1738 : { return 0; } + yy1739: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych == '\n') + goto yy1738; + goto yy1752; + } else { + if (yych <= 0xC1) + goto yy1738; + if (yych <= 0xF4) + goto yy1752; + goto yy1738; + } + yy1740: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy1749; + } + if (yych <= 0x7F) { + if (yych == '\n') + goto yy1738; + goto yy1752; + } else { + if (yych <= 0xC1) + goto yy1738; + if (yych <= 0xF4) + goto yy1752; + goto yy1738; + } + yy1741: + yych = *++p; + if (yych <= 0x7F) + goto yy1742; + if (yych <= 0xBF) + goto yy1739; + yy1742: + p = marker; + if (yyaccept == 0) { + goto yy1738; + } else { + goto yy1762; + } + yy1743: + yych = *++p; + if (yych <= 0x9F) + goto yy1742; + if (yych <= 0xBF) + goto yy1741; + goto yy1742; + yy1744: + yych = *++p; + if (yych <= 0x7F) + goto yy1742; + if (yych <= 0xBF) + goto yy1741; + goto yy1742; + yy1745: + yych = *++p; + if (yych <= 0x8F) + goto yy1742; + if (yych <= 0xBF) + goto yy1744; + goto yy1742; + yy1746: + yych = *++p; + if (yych <= 0x7F) + goto yy1742; + if (yych <= 0xBF) + goto yy1744; + goto yy1742; + yy1747: + yych = *++p; + if (yych <= 0x7F) + goto yy1742; + if (yych <= 0x8F) + goto yy1744; + goto yy1742; + yy1748: + yych = *++p; + if (yych <= 0x7F) + goto yy1742; + if (yych <= 0x9F) + goto yy1741; + goto yy1742; + yy1749: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1749; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych == '\n') + goto yy1742; + } else { + if (yych <= '>') + goto yy1761; + if (yych <= 0x7F) + goto yy1751; + if (yych <= 0xC1) + goto yy1742; + goto yy1753; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1754; + if (yych == 0xED) + goto yy1759; + goto yy1755; + } else { + if (yych <= 0xF0) + goto yy1756; + if (yych <= 0xF3) + goto yy1757; + if (yych <= 0xF4) + goto yy1758; + goto yy1742; + } + } + yy1751: + ++p; + yych = *p; + yy1752: + if (yybm[0 + yych] & 128) { + goto yy1751; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1742; + if (yych <= '-') + goto yy1760; + goto yy1742; + } else { + if (yych <= 0xDF) + goto yy1753; + if (yych <= 0xE0) + goto yy1754; + goto yy1755; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1759; + if (yych <= 0xEF) + goto yy1755; + goto yy1756; + } else { + if (yych <= 0xF3) + goto yy1757; + if (yych <= 0xF4) + goto yy1758; + goto yy1742; + } + } + yy1753: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1742; + if (yych <= 0xBF) + goto yy1751; + goto yy1742; + yy1754: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1742; + if (yych <= 0xBF) + goto yy1753; + goto yy1742; + yy1755: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1742; + if (yych <= 0xBF) + goto yy1753; + goto yy1742; + yy1756: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1742; + if (yych <= 0xBF) + goto yy1755; + goto yy1742; + yy1757: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1742; + if (yych <= 0xBF) + goto yy1755; + goto yy1742; + yy1758: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1742; + if (yych <= 0x8F) + goto yy1755; + goto yy1742; + yy1759: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1742; + if (yych <= 0x9F) + goto yy1753; + goto yy1742; + yy1760: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1751; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1742; + if (yych <= '-') + goto yy1749; + goto yy1742; + } else { + if (yych <= 0xDF) + goto yy1753; + if (yych <= 0xE0) + goto yy1754; + goto yy1755; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1759; + if (yych <= 0xEF) + goto yy1755; + goto yy1756; + } else { + if (yych <= 0xF3) + goto yy1757; + if (yych <= 0xF4) + goto yy1758; + goto yy1742; + } + } + yy1761: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1751; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1762; + if (yych <= '-') + goto yy1760; + } else { + if (yych <= 0xDF) + goto yy1753; + if (yych <= 0xE0) + goto yy1754; + goto yy1755; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1759; + if (yych <= 0xEF) + goto yy1755; + goto yy1756; + } else { + if (yych <= 0xF3) + goto yy1757; + if (yych <= 0xF4) + goto yy1758; + } + } + yy1762 : { return (bufsize_t)(p - start); } + } } // Try to match an HTML block end line of type 3 -bufsize_t _scan_html_block_end_3(const unsigned char *p) -{ +bufsize_t _scan_html_block_end_3(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[] = { - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 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, 64, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 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, - }; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= '>') { - if (yych != '\n') goto yy1764; - } else { - if (yych <= '?') goto yy1765; - if (yych <= 0x7F) goto yy1764; - if (yych >= 0xC2) goto yy1766; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1768; - if (yych == 0xED) goto yy1773; - goto yy1769; - } else { - if (yych <= 0xF0) goto yy1770; - if (yych <= 0xF3) goto yy1771; - if (yych <= 0xF4) goto yy1772; - } - } -yy1763: - { return 0; } -yy1764: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych == '\n') goto yy1763; - goto yy1779; - } else { - if (yych <= 0xC1) goto yy1763; - if (yych <= 0xF4) goto yy1779; - goto yy1763; - } -yy1765: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= '>') { - if (yych == '\n') goto yy1763; - if (yych <= '=') goto yy1779; - goto yy1774; - } else { - if (yych <= 0x7F) goto yy1779; - if (yych <= 0xC1) goto yy1763; - if (yych <= 0xF4) goto yy1779; - goto yy1763; - } -yy1766: - yych = *++p; - if (yych <= 0x7F) goto yy1767; - if (yych <= 0xBF) goto yy1764; -yy1767: - p = marker; - if (yyaccept == 0) { - goto yy1763; - } else { - goto yy1775; - } -yy1768: - yych = *++p; - if (yych <= 0x9F) goto yy1767; - if (yych <= 0xBF) goto yy1766; - goto yy1767; -yy1769: - yych = *++p; - if (yych <= 0x7F) goto yy1767; - if (yych <= 0xBF) goto yy1766; - goto yy1767; -yy1770: - yych = *++p; - if (yych <= 0x8F) goto yy1767; - if (yych <= 0xBF) goto yy1769; - goto yy1767; -yy1771: - yych = *++p; - if (yych <= 0x7F) goto yy1767; - if (yych <= 0xBF) goto yy1769; - goto yy1767; -yy1772: - yych = *++p; - if (yych <= 0x7F) goto yy1767; - if (yych <= 0x8F) goto yy1769; - goto yy1767; -yy1773: - yych = *++p; - if (yych <= 0x7F) goto yy1767; - if (yych <= 0x9F) goto yy1766; - goto yy1767; -yy1774: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1778; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1775; - if (yych <= '?') goto yy1776; - } else { - if (yych <= 0xDF) goto yy1780; - if (yych <= 0xE0) goto yy1781; - goto yy1782; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1786; - if (yych <= 0xEF) goto yy1782; - goto yy1783; - } else { - if (yych <= 0xF3) goto yy1784; - if (yych <= 0xF4) goto yy1785; - } - } -yy1775: - { return (bufsize_t)(p - start); } -yy1776: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1776; - } - if (yych <= 0xDF) { - if (yych <= '=') { - if (yych == '\n') goto yy1767; - } else { - if (yych <= '>') goto yy1774; - if (yych <= 0x7F) goto yy1778; - if (yych <= 0xC1) goto yy1767; - goto yy1780; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1781; - if (yych == 0xED) goto yy1786; - goto yy1782; - } else { - if (yych <= 0xF0) goto yy1783; - if (yych <= 0xF3) goto yy1784; - if (yych <= 0xF4) goto yy1785; - goto yy1767; - } - } -yy1778: - ++p; - yych = *p; -yy1779: - if (yybm[0+yych] & 128) { - goto yy1778; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1767; - if (yych <= '?') goto yy1776; - goto yy1767; - } else { - if (yych <= 0xDF) goto yy1780; - if (yych <= 0xE0) goto yy1781; - goto yy1782; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1786; - if (yych <= 0xEF) goto yy1782; - goto yy1783; - } else { - if (yych <= 0xF3) goto yy1784; - if (yych <= 0xF4) goto yy1785; - goto yy1767; - } - } -yy1780: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1767; - if (yych <= 0xBF) goto yy1778; - goto yy1767; -yy1781: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1767; - if (yych <= 0xBF) goto yy1780; - goto yy1767; -yy1782: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1767; - if (yych <= 0xBF) goto yy1780; - goto yy1767; -yy1783: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1767; - if (yych <= 0xBF) goto yy1782; - goto yy1767; -yy1784: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1767; - if (yych <= 0xBF) goto yy1782; - goto yy1767; -yy1785: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1767; - if (yych <= 0x8F) goto yy1782; - goto yy1767; -yy1786: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1767; - if (yych <= 0x9F) goto yy1780; - goto yy1767; -} - + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 64, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 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, + }; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= '>') { + if (yych != '\n') + goto yy1766; + } else { + if (yych <= '?') + goto yy1767; + if (yych <= 0x7F) + goto yy1766; + if (yych >= 0xC2) + goto yy1768; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1770; + if (yych == 0xED) + goto yy1775; + goto yy1771; + } else { + if (yych <= 0xF0) + goto yy1772; + if (yych <= 0xF3) + goto yy1773; + if (yych <= 0xF4) + goto yy1774; + } + } + yy1765 : { return 0; } + yy1766: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych == '\n') + goto yy1765; + goto yy1781; + } else { + if (yych <= 0xC1) + goto yy1765; + if (yych <= 0xF4) + goto yy1781; + goto yy1765; + } + yy1767: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '>') { + if (yych == '\n') + goto yy1765; + if (yych <= '=') + goto yy1781; + goto yy1776; + } else { + if (yych <= 0x7F) + goto yy1781; + if (yych <= 0xC1) + goto yy1765; + if (yych <= 0xF4) + goto yy1781; + goto yy1765; + } + yy1768: + yych = *++p; + if (yych <= 0x7F) + goto yy1769; + if (yych <= 0xBF) + goto yy1766; + yy1769: + p = marker; + if (yyaccept == 0) { + goto yy1765; + } else { + goto yy1777; + } + yy1770: + yych = *++p; + if (yych <= 0x9F) + goto yy1769; + if (yych <= 0xBF) + goto yy1768; + goto yy1769; + yy1771: + yych = *++p; + if (yych <= 0x7F) + goto yy1769; + if (yych <= 0xBF) + goto yy1768; + goto yy1769; + yy1772: + yych = *++p; + if (yych <= 0x8F) + goto yy1769; + if (yych <= 0xBF) + goto yy1771; + goto yy1769; + yy1773: + yych = *++p; + if (yych <= 0x7F) + goto yy1769; + if (yych <= 0xBF) + goto yy1771; + goto yy1769; + yy1774: + yych = *++p; + if (yych <= 0x7F) + goto yy1769; + if (yych <= 0x8F) + goto yy1771; + goto yy1769; + yy1775: + yych = *++p; + if (yych <= 0x7F) + goto yy1769; + if (yych <= 0x9F) + goto yy1768; + goto yy1769; + yy1776: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1780; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1777; + if (yych <= '?') + goto yy1778; + } else { + if (yych <= 0xDF) + goto yy1782; + if (yych <= 0xE0) + goto yy1783; + goto yy1784; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1788; + if (yych <= 0xEF) + goto yy1784; + goto yy1785; + } else { + if (yych <= 0xF3) + goto yy1786; + if (yych <= 0xF4) + goto yy1787; + } + } + yy1777 : { return (bufsize_t)(p - start); } + yy1778: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1778; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych == '\n') + goto yy1769; + } else { + if (yych <= '>') + goto yy1776; + if (yych <= 0x7F) + goto yy1780; + if (yych <= 0xC1) + goto yy1769; + goto yy1782; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1783; + if (yych == 0xED) + goto yy1788; + goto yy1784; + } else { + if (yych <= 0xF0) + goto yy1785; + if (yych <= 0xF3) + goto yy1786; + if (yych <= 0xF4) + goto yy1787; + goto yy1769; + } + } + yy1780: + ++p; + yych = *p; + yy1781: + if (yybm[0 + yych] & 128) { + goto yy1780; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1769; + if (yych <= '?') + goto yy1778; + goto yy1769; + } else { + if (yych <= 0xDF) + goto yy1782; + if (yych <= 0xE0) + goto yy1783; + goto yy1784; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1788; + if (yych <= 0xEF) + goto yy1784; + goto yy1785; + } else { + if (yych <= 0xF3) + goto yy1786; + if (yych <= 0xF4) + goto yy1787; + goto yy1769; + } + } + yy1782: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1769; + if (yych <= 0xBF) + goto yy1780; + goto yy1769; + yy1783: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1769; + if (yych <= 0xBF) + goto yy1782; + goto yy1769; + yy1784: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1769; + if (yych <= 0xBF) + goto yy1782; + goto yy1769; + yy1785: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1769; + if (yych <= 0xBF) + goto yy1784; + goto yy1769; + yy1786: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1769; + if (yych <= 0xBF) + goto yy1784; + goto yy1769; + yy1787: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1769; + if (yych <= 0x8F) + goto yy1784; + goto yy1769; + yy1788: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1769; + if (yych <= 0x9F) + goto yy1782; + goto yy1769; + } } // Try to match an HTML block end line of type 4 -bufsize_t _scan_html_block_end_4(const unsigned char *p) -{ +bufsize_t _scan_html_block_end_4(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[] = { - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 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, 64, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 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, - }; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= '=') { - if (yych != '\n') goto yy1790; - } else { - if (yych <= '>') goto yy1791; - if (yych <= 0x7F) goto yy1790; - if (yych >= 0xC2) goto yy1793; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1795; - if (yych == 0xED) goto yy1800; - goto yy1796; - } else { - if (yych <= 0xF0) goto yy1797; - if (yych <= 0xF3) goto yy1798; - if (yych <= 0xF4) goto yy1799; - } - } -yy1789: - { return 0; } -yy1790: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych == '\n') goto yy1789; - goto yy1804; - } else { - if (yych <= 0xC1) goto yy1789; - if (yych <= 0xF4) goto yy1804; - goto yy1789; - } -yy1791: - yyaccept = 1; - yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych != '\n') goto yy1804; - } else { - if (yych <= 0xC1) goto yy1792; - if (yych <= 0xF4) goto yy1804; - } -yy1792: - { return (bufsize_t)(p - start); } -yy1793: - yych = *++p; - if (yych <= 0x7F) goto yy1794; - if (yych <= 0xBF) goto yy1790; -yy1794: - p = marker; - if (yyaccept == 0) { - goto yy1789; - } else { - goto yy1792; - } -yy1795: - yych = *++p; - if (yych <= 0x9F) goto yy1794; - if (yych <= 0xBF) goto yy1793; - goto yy1794; -yy1796: - yych = *++p; - if (yych <= 0x7F) goto yy1794; - if (yych <= 0xBF) goto yy1793; - goto yy1794; -yy1797: - yych = *++p; - if (yych <= 0x8F) goto yy1794; - if (yych <= 0xBF) goto yy1796; - goto yy1794; -yy1798: - yych = *++p; - if (yych <= 0x7F) goto yy1794; - if (yych <= 0xBF) goto yy1796; - goto yy1794; -yy1799: - yych = *++p; - if (yych <= 0x7F) goto yy1794; - if (yych <= 0x8F) goto yy1796; - goto yy1794; -yy1800: - yych = *++p; - if (yych <= 0x7F) goto yy1794; - if (yych <= 0x9F) goto yy1793; - goto yy1794; -yy1801: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1803; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1792; - if (yych <= '>') goto yy1801; - goto yy1792; - } else { - if (yych <= 0xDF) goto yy1805; - if (yych <= 0xE0) goto yy1806; - goto yy1807; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1811; - if (yych <= 0xEF) goto yy1807; - goto yy1808; - } else { - if (yych <= 0xF3) goto yy1809; - if (yych <= 0xF4) goto yy1810; - goto yy1792; - } - } -yy1803: - ++p; - yych = *p; -yy1804: - if (yybm[0+yych] & 128) { - goto yy1803; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1794; - if (yych <= '>') goto yy1801; - goto yy1794; - } else { - if (yych <= 0xDF) goto yy1805; - if (yych <= 0xE0) goto yy1806; - goto yy1807; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1811; - if (yych <= 0xEF) goto yy1807; - goto yy1808; - } else { - if (yych <= 0xF3) goto yy1809; - if (yych <= 0xF4) goto yy1810; - goto yy1794; - } - } -yy1805: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1794; - if (yych <= 0xBF) goto yy1803; - goto yy1794; -yy1806: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1794; - if (yych <= 0xBF) goto yy1805; - goto yy1794; -yy1807: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1794; - if (yych <= 0xBF) goto yy1805; - goto yy1794; -yy1808: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1794; - if (yych <= 0xBF) goto yy1807; - goto yy1794; -yy1809: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1794; - if (yych <= 0xBF) goto yy1807; - goto yy1794; -yy1810: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1794; - if (yych <= 0x8F) goto yy1807; - goto yy1794; -yy1811: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1794; - if (yych <= 0x9F) goto yy1805; - goto yy1794; -} - + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 64, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 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, + }; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych != '\n') + goto yy1792; + } else { + if (yych <= '>') + goto yy1793; + if (yych <= 0x7F) + goto yy1792; + if (yych >= 0xC2) + goto yy1795; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1797; + if (yych == 0xED) + goto yy1802; + goto yy1798; + } else { + if (yych <= 0xF0) + goto yy1799; + if (yych <= 0xF3) + goto yy1800; + if (yych <= 0xF4) + goto yy1801; + } + } + yy1791 : { return 0; } + yy1792: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych == '\n') + goto yy1791; + goto yy1806; + } else { + if (yych <= 0xC1) + goto yy1791; + if (yych <= 0xF4) + goto yy1806; + goto yy1791; + } + yy1793: + yyaccept = 1; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych != '\n') + goto yy1806; + } else { + if (yych <= 0xC1) + goto yy1794; + if (yych <= 0xF4) + goto yy1806; + } + yy1794 : { return (bufsize_t)(p - start); } + yy1795: + yych = *++p; + if (yych <= 0x7F) + goto yy1796; + if (yych <= 0xBF) + goto yy1792; + yy1796: + p = marker; + if (yyaccept == 0) { + goto yy1791; + } else { + goto yy1794; + } + yy1797: + yych = *++p; + if (yych <= 0x9F) + goto yy1796; + if (yych <= 0xBF) + goto yy1795; + goto yy1796; + yy1798: + yych = *++p; + if (yych <= 0x7F) + goto yy1796; + if (yych <= 0xBF) + goto yy1795; + goto yy1796; + yy1799: + yych = *++p; + if (yych <= 0x8F) + goto yy1796; + if (yych <= 0xBF) + goto yy1798; + goto yy1796; + yy1800: + yych = *++p; + if (yych <= 0x7F) + goto yy1796; + if (yych <= 0xBF) + goto yy1798; + goto yy1796; + yy1801: + yych = *++p; + if (yych <= 0x7F) + goto yy1796; + if (yych <= 0x8F) + goto yy1798; + goto yy1796; + yy1802: + yych = *++p; + if (yych <= 0x7F) + goto yy1796; + if (yych <= 0x9F) + goto yy1795; + goto yy1796; + yy1803: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1805; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1794; + if (yych <= '>') + goto yy1803; + goto yy1794; + } else { + if (yych <= 0xDF) + goto yy1807; + if (yych <= 0xE0) + goto yy1808; + goto yy1809; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1813; + if (yych <= 0xEF) + goto yy1809; + goto yy1810; + } else { + if (yych <= 0xF3) + goto yy1811; + if (yych <= 0xF4) + goto yy1812; + goto yy1794; + } + } + yy1805: + ++p; + yych = *p; + yy1806: + if (yybm[0 + yych] & 128) { + goto yy1805; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1796; + if (yych <= '>') + goto yy1803; + goto yy1796; + } else { + if (yych <= 0xDF) + goto yy1807; + if (yych <= 0xE0) + goto yy1808; + goto yy1809; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1813; + if (yych <= 0xEF) + goto yy1809; + goto yy1810; + } else { + if (yych <= 0xF3) + goto yy1811; + if (yych <= 0xF4) + goto yy1812; + goto yy1796; + } + } + yy1807: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1796; + if (yych <= 0xBF) + goto yy1805; + goto yy1796; + yy1808: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1796; + if (yych <= 0xBF) + goto yy1807; + goto yy1796; + yy1809: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1796; + if (yych <= 0xBF) + goto yy1807; + goto yy1796; + yy1810: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1796; + if (yych <= 0xBF) + goto yy1809; + goto yy1796; + yy1811: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1796; + if (yych <= 0xBF) + goto yy1809; + goto yy1796; + yy1812: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1796; + if (yych <= 0x8F) + goto yy1809; + goto yy1796; + yy1813: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1796; + if (yych <= 0x9F) + goto yy1807; + goto yy1796; + } } // Try to match an HTML block end line of type 5 -bufsize_t _scan_html_block_end_5(const unsigned char *p) -{ +bufsize_t _scan_html_block_end_5(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[] = { - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 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, 64, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 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, - }; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= '\\') { - if (yych != '\n') goto yy1815; - } else { - if (yych <= ']') goto yy1816; - if (yych <= 0x7F) goto yy1815; - if (yych >= 0xC2) goto yy1817; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1819; - if (yych == 0xED) goto yy1824; - goto yy1820; - } else { - if (yych <= 0xF0) goto yy1821; - if (yych <= 0xF3) goto yy1822; - if (yych <= 0xF4) goto yy1823; - } - } -yy1814: - { return 0; } -yy1815: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych == '\n') goto yy1814; - goto yy1828; - } else { - if (yych <= 0xC1) goto yy1814; - if (yych <= 0xF4) goto yy1828; - goto yy1814; - } -yy1816: - yyaccept = 0; - yych = *(marker = ++p); - if (yybm[0+yych] & 64) { - goto yy1825; - } - if (yych <= 0x7F) { - if (yych == '\n') goto yy1814; - goto yy1828; - } else { - if (yych <= 0xC1) goto yy1814; - if (yych <= 0xF4) goto yy1828; - goto yy1814; - } -yy1817: - yych = *++p; - if (yych <= 0x7F) goto yy1818; - if (yych <= 0xBF) goto yy1815; -yy1818: - p = marker; - if (yyaccept == 0) { - goto yy1814; - } else { - goto yy1838; - } -yy1819: - yych = *++p; - if (yych <= 0x9F) goto yy1818; - if (yych <= 0xBF) goto yy1817; - goto yy1818; -yy1820: - yych = *++p; - if (yych <= 0x7F) goto yy1818; - if (yych <= 0xBF) goto yy1817; - goto yy1818; -yy1821: - yych = *++p; - if (yych <= 0x8F) goto yy1818; - if (yych <= 0xBF) goto yy1820; - goto yy1818; -yy1822: - yych = *++p; - if (yych <= 0x7F) goto yy1818; - if (yych <= 0xBF) goto yy1820; - goto yy1818; -yy1823: - yych = *++p; - if (yych <= 0x7F) goto yy1818; - if (yych <= 0x8F) goto yy1820; - goto yy1818; -yy1824: - yych = *++p; - if (yych <= 0x7F) goto yy1818; - if (yych <= 0x9F) goto yy1817; - goto yy1818; -yy1825: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1825; - } - if (yych <= 0xDF) { - if (yych <= '=') { - if (yych == '\n') goto yy1818; - } else { - if (yych <= '>') goto yy1837; - if (yych <= 0x7F) goto yy1827; - if (yych <= 0xC1) goto yy1818; - goto yy1829; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1830; - if (yych == 0xED) goto yy1835; - goto yy1831; - } else { - if (yych <= 0xF0) goto yy1832; - if (yych <= 0xF3) goto yy1833; - if (yych <= 0xF4) goto yy1834; - goto yy1818; - } - } -yy1827: - ++p; - yych = *p; -yy1828: - if (yybm[0+yych] & 128) { - goto yy1827; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1818; - if (yych <= ']') goto yy1836; - goto yy1818; - } else { - if (yych <= 0xDF) goto yy1829; - if (yych <= 0xE0) goto yy1830; - goto yy1831; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1835; - if (yych <= 0xEF) goto yy1831; - goto yy1832; - } else { - if (yych <= 0xF3) goto yy1833; - if (yych <= 0xF4) goto yy1834; - goto yy1818; - } - } -yy1829: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1818; - if (yych <= 0xBF) goto yy1827; - goto yy1818; -yy1830: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1818; - if (yych <= 0xBF) goto yy1829; - goto yy1818; -yy1831: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1818; - if (yych <= 0xBF) goto yy1829; - goto yy1818; -yy1832: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1818; - if (yych <= 0xBF) goto yy1831; - goto yy1818; -yy1833: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1818; - if (yych <= 0xBF) goto yy1831; - goto yy1818; -yy1834: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1818; - if (yych <= 0x8F) goto yy1831; - goto yy1818; -yy1835: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1818; - if (yych <= 0x9F) goto yy1829; - goto yy1818; -yy1836: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1827; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1818; - if (yych <= ']') goto yy1825; - goto yy1818; - } else { - if (yych <= 0xDF) goto yy1829; - if (yych <= 0xE0) goto yy1830; - goto yy1831; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1835; - if (yych <= 0xEF) goto yy1831; - goto yy1832; - } else { - if (yych <= 0xF3) goto yy1833; - if (yych <= 0xF4) goto yy1834; - goto yy1818; - } - } -yy1837: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1827; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') goto yy1838; - if (yych <= ']') goto yy1836; - } else { - if (yych <= 0xDF) goto yy1829; - if (yych <= 0xE0) goto yy1830; - goto yy1831; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1835; - if (yych <= 0xEF) goto yy1831; - goto yy1832; - } else { - if (yych <= 0xF3) goto yy1833; - if (yych <= 0xF4) goto yy1834; - } - } -yy1838: - { return (bufsize_t)(p - start); } -} - + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 64, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 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, + }; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= '\\') { + if (yych != '\n') + goto yy1817; + } else { + if (yych <= ']') + goto yy1818; + if (yych <= 0x7F) + goto yy1817; + if (yych >= 0xC2) + goto yy1819; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1821; + if (yych == 0xED) + goto yy1826; + goto yy1822; + } else { + if (yych <= 0xF0) + goto yy1823; + if (yych <= 0xF3) + goto yy1824; + if (yych <= 0xF4) + goto yy1825; + } + } + yy1816 : { return 0; } + yy1817: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) { + if (yych == '\n') + goto yy1816; + goto yy1830; + } else { + if (yych <= 0xC1) + goto yy1816; + if (yych <= 0xF4) + goto yy1830; + goto yy1816; + } + yy1818: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy1827; + } + if (yych <= 0x7F) { + if (yych == '\n') + goto yy1816; + goto yy1830; + } else { + if (yych <= 0xC1) + goto yy1816; + if (yych <= 0xF4) + goto yy1830; + goto yy1816; + } + yy1819: + yych = *++p; + if (yych <= 0x7F) + goto yy1820; + if (yych <= 0xBF) + goto yy1817; + yy1820: + p = marker; + if (yyaccept == 0) { + goto yy1816; + } else { + goto yy1840; + } + yy1821: + yych = *++p; + if (yych <= 0x9F) + goto yy1820; + if (yych <= 0xBF) + goto yy1819; + goto yy1820; + yy1822: + yych = *++p; + if (yych <= 0x7F) + goto yy1820; + if (yych <= 0xBF) + goto yy1819; + goto yy1820; + yy1823: + yych = *++p; + if (yych <= 0x8F) + goto yy1820; + if (yych <= 0xBF) + goto yy1822; + goto yy1820; + yy1824: + yych = *++p; + if (yych <= 0x7F) + goto yy1820; + if (yych <= 0xBF) + goto yy1822; + goto yy1820; + yy1825: + yych = *++p; + if (yych <= 0x7F) + goto yy1820; + if (yych <= 0x8F) + goto yy1822; + goto yy1820; + yy1826: + yych = *++p; + if (yych <= 0x7F) + goto yy1820; + if (yych <= 0x9F) + goto yy1819; + goto yy1820; + yy1827: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1827; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych == '\n') + goto yy1820; + } else { + if (yych <= '>') + goto yy1839; + if (yych <= 0x7F) + goto yy1829; + if (yych <= 0xC1) + goto yy1820; + goto yy1831; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1832; + if (yych == 0xED) + goto yy1837; + goto yy1833; + } else { + if (yych <= 0xF0) + goto yy1834; + if (yych <= 0xF3) + goto yy1835; + if (yych <= 0xF4) + goto yy1836; + goto yy1820; + } + } + yy1829: + ++p; + yych = *p; + yy1830: + if (yybm[0 + yych] & 128) { + goto yy1829; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1820; + if (yych <= ']') + goto yy1838; + goto yy1820; + } else { + if (yych <= 0xDF) + goto yy1831; + if (yych <= 0xE0) + goto yy1832; + goto yy1833; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1837; + if (yych <= 0xEF) + goto yy1833; + goto yy1834; + } else { + if (yych <= 0xF3) + goto yy1835; + if (yych <= 0xF4) + goto yy1836; + goto yy1820; + } + } + yy1831: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1820; + if (yych <= 0xBF) + goto yy1829; + goto yy1820; + yy1832: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1820; + if (yych <= 0xBF) + goto yy1831; + goto yy1820; + yy1833: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1820; + if (yych <= 0xBF) + goto yy1831; + goto yy1820; + yy1834: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1820; + if (yych <= 0xBF) + goto yy1833; + goto yy1820; + yy1835: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1820; + if (yych <= 0xBF) + goto yy1833; + goto yy1820; + yy1836: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1820; + if (yych <= 0x8F) + goto yy1833; + goto yy1820; + yy1837: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1820; + if (yych <= 0x9F) + goto yy1831; + goto yy1820; + yy1838: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1829; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1820; + if (yych <= ']') + goto yy1827; + goto yy1820; + } else { + if (yych <= 0xDF) + goto yy1831; + if (yych <= 0xE0) + goto yy1832; + goto yy1833; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1837; + if (yych <= 0xEF) + goto yy1833; + goto yy1834; + } else { + if (yych <= 0xF3) + goto yy1835; + if (yych <= 0xF4) + goto yy1836; + goto yy1820; + } + } + yy1839: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1829; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy1840; + if (yych <= ']') + goto yy1838; + } else { + if (yych <= 0xDF) + goto yy1831; + if (yych <= 0xE0) + goto yy1832; + goto yy1833; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1837; + if (yych <= 0xEF) + goto yy1833; + goto yy1834; + } else { + if (yych <= 0xF3) + goto yy1835; + if (yych <= 0xF4) + goto yy1836; + } + } + yy1840 : { return (bufsize_t)(p - start); } + } } // 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. -bufsize_t _scan_link_url(const unsigned char *p) -{ +bufsize_t _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, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 8, 128, 128, 8, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, - 136, 224, 224, 224, 224, 224, 224, 224, - 128, 128, 224, 224, 224, 224, 224, 224, - 224, 224, 224, 224, 224, 224, 224, 224, - 224, 224, 224, 224, 32, 224, 32, 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, 224, 224, 224, 16, 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, 224, - 224, 224, 224, 224, 224, 224, 224, 224, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 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 = *(marker = p); - if (yych <= '[') { - if (yych <= ' ') { - if (yych <= '\f') { - if (yych == '\n') goto yy1842; - goto yy1858; - } else { - if (yych <= '\r') goto yy1844; - if (yych <= 0x1F) goto yy1858; - goto yy1844; - } - } else { - if (yych <= ')') { - if (yych <= '\'') goto yy1846; - if (yych <= '(') goto yy1857; - goto yy1858; - } else { - if (yych == '<') goto yy1845; - goto yy1846; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') goto yy1855; - if (yych <= 0x7F) goto yy1846; - } else { - if (yych <= 0xDF) goto yy1847; - if (yych <= 0xE0) goto yy1849; - goto yy1850; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1854; - if (yych <= 0xEF) goto yy1850; - goto yy1851; - } else { - if (yych <= 0xF3) goto yy1852; - if (yych <= 0xF4) goto yy1853; - } - } - } -yy1841: - { return (bufsize_t)(p - start); } -yy1842: - yyaccept = 0; - marker = ++p; - yych = *p; -yy1843: - if (yybm[0+yych] & 8) { - goto yy1842; - } - if (yych <= 0x7F) { - if (yych <= ')') { - if (yych <= 0x1F) goto yy1841; - if (yych <= '\'') goto yy1870; - if (yych <= '(') goto yy1861; - goto yy1841; - } else { - if (yych <= '<') { - if (yych <= ';') goto yy1870; - goto yy1905; - } else { - if (yych == '\\') goto yy1879; - goto yy1870; - } - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) { - if (yych <= 0xC1) goto yy1841; - goto yy1872; - } else { - if (yych <= 0xE0) goto yy1873; - if (yych <= 0xEC) goto yy1874; - goto yy1878; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1874; - goto yy1875; - } else { - if (yych <= 0xF3) goto yy1876; - if (yych <= 0xF4) goto yy1877; - goto yy1841; - } - } - } -yy1844: - yyaccept = 0; - yych = *(marker = ++p); - goto yy1843; -yy1845: - yyaccept = 0; - yych = *(marker = ++p); - if (yybm[0+yych] & 64) { - goto yy1905; - } - if (yych <= '>') { - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1841; - goto yy1919; - } else { - if (yych <= '\n') goto yy1841; - if (yych <= '\f') goto yy1919; - goto yy1841; - } - } else { - if (yych <= '(') { - if (yych <= ' ') goto yy1919; - goto yy1917; - } else { - if (yych <= ')') goto yy1919; - if (yych <= '<') goto yy1870; - goto yy1907; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') goto yy1916; - goto yy1841; - } else { - if (yych <= 0xDF) goto yy1909; - if (yych <= 0xE0) goto yy1910; - goto yy1911; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1915; - if (yych <= 0xEF) goto yy1911; - goto yy1912; - } else { - if (yych <= 0xF3) goto yy1913; - if (yych <= 0xF4) goto yy1914; - goto yy1841; - } - } - } -yy1846: - yyaccept = 0; - yych = *(marker = ++p); - goto yy1871; -yy1847: - yych = *++p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1846; -yy1848: - p = marker; - if (yyaccept <= 1) { - if (yyaccept == 0) { - goto yy1841; - } else { - goto yy1856; - } - } else { - goto yy1908; - } -yy1849: - yych = *++p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1847; - goto yy1848; -yy1850: - yych = *++p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1847; - goto yy1848; -yy1851: - yych = *++p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1850; - goto yy1848; -yy1852: - yych = *++p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1850; - goto yy1848; -yy1853: - yych = *++p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1850; - goto yy1848; -yy1854: - yych = *++p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1847; - goto yy1848; -yy1855: - yyaccept = 1; - yych = *(marker = ++p); - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) goto yy1870; - } else { - if (yych <= 0xDF) goto yy1880; - if (yych <= 0xE0) goto yy1881; - goto yy1882; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1886; - if (yych <= 0xEF) goto yy1882; - goto yy1883; - } else { - if (yych <= 0xF3) goto yy1884; - if (yych <= 0xF4) goto yy1885; - } - } -yy1856: - { return 0; } -yy1857: - yyaccept = 1; - yych = *(marker = ++p); - if (yych <= '(') { - if (yych <= ' ') goto yy1856; - if (yych <= '\'') goto yy1862; - goto yy1856; - } else { - if (yych <= 0x7F) goto yy1862; - if (yych <= 0xC1) goto yy1856; - if (yych <= 0xF4) goto yy1862; - goto yy1856; - } -yy1858: - yych = *++p; - goto yy1856; -yy1859: - ++p; - yych = *p; - if (yybm[0+yych] & 16) { - goto yy1859; - } - if (yych <= 0xE0) { - if (yych <= ')') { - if (yych <= ' ') goto yy1848; - if (yych >= ')') goto yy1887; - } else { - if (yych <= 0x7F) goto yy1861; - if (yych <= 0xC1) goto yy1848; - if (yych <= 0xDF) goto yy1863; - goto yy1864; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1869; - goto yy1865; - } else { - if (yych <= 0xF0) goto yy1866; - if (yych <= 0xF3) goto yy1867; - if (yych <= 0xF4) goto yy1868; - goto yy1848; - } - } -yy1861: - ++p; - yych = *p; -yy1862: - if (yybm[0+yych] & 32) { - goto yy1861; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '(') goto yy1848; - if (yych <= ')') goto yy1870; - goto yy1859; - } else { - if (yych <= 0xC1) goto yy1848; - if (yych >= 0xE0) goto yy1864; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1869; - goto yy1865; - } else { - if (yych <= 0xF0) goto yy1866; - if (yych <= 0xF3) goto yy1867; - if (yych <= 0xF4) goto yy1868; - goto yy1848; - } - } -yy1863: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1861; - goto yy1848; -yy1864: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1863; - goto yy1848; -yy1865: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1863; - goto yy1848; -yy1866: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1865; - goto yy1848; -yy1867: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1865; - goto yy1848; -yy1868: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1865; - goto yy1848; -yy1869: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1863; - goto yy1848; -yy1870: - yyaccept = 0; - marker = ++p; - yych = *p; -yy1871: - if (yych <= 0xC1) { - if (yych <= ')') { - if (yych <= ' ') goto yy1841; - if (yych <= '\'') goto yy1870; - if (yych <= '(') goto yy1861; - goto yy1841; - } else { - if (yych == '\\') goto yy1879; - if (yych <= 0x7F) goto yy1870; - goto yy1841; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1872; - if (yych <= 0xE0) goto yy1873; - if (yych <= 0xEC) goto yy1874; - goto yy1878; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1874; - goto yy1875; - } else { - if (yych <= 0xF3) goto yy1876; - if (yych <= 0xF4) goto yy1877; - goto yy1841; - } - } - } -yy1872: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1870; - goto yy1848; -yy1873: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1872; - goto yy1848; -yy1874: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1872; - goto yy1848; -yy1875: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1874; - goto yy1848; -yy1876: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1874; - goto yy1848; -yy1877: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1874; - goto yy1848; -yy1878: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1872; - goto yy1848; -yy1879: - ++p; - yych = *p; - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) goto yy1870; - goto yy1848; - } else { - if (yych <= 0xDF) goto yy1880; - if (yych <= 0xE0) goto yy1881; - goto yy1882; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1886; - if (yych <= 0xEF) goto yy1882; - goto yy1883; - } else { - if (yych <= 0xF3) goto yy1884; - if (yych <= 0xF4) goto yy1885; - goto yy1848; - } - } -yy1880: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1870; - goto yy1848; -yy1881: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1880; - goto yy1848; -yy1882: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1880; - goto yy1848; -yy1883: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1882; - goto yy1848; -yy1884: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1882; - goto yy1848; -yy1885: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1882; - goto yy1848; -yy1886: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1880; - goto yy1848; -yy1887: - yyaccept = 0; - marker = ++p; - yych = *p; -yy1888: - if (yych <= 0xC1) { - if (yych <= ')') { - if (yych <= ' ') goto yy1841; - if (yych <= '\'') goto yy1887; - if (yych <= '(') goto yy1861; - goto yy1870; - } else { - if (yych == '\\') goto yy1896; - if (yych <= 0x7F) goto yy1887; - goto yy1841; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1889; - if (yych <= 0xE0) goto yy1890; - if (yych <= 0xEC) goto yy1891; - goto yy1895; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1891; - goto yy1892; - } else { - if (yych <= 0xF3) goto yy1893; - if (yych <= 0xF4) goto yy1894; - goto yy1841; - } - } - } -yy1889: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1887; - goto yy1848; -yy1890: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1889; - goto yy1848; -yy1891: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1889; - goto yy1848; -yy1892: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1891; - goto yy1848; -yy1893: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1891; - goto yy1848; -yy1894: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1891; - goto yy1848; -yy1895: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1889; - goto yy1848; -yy1896: - ++p; - yych = *p; - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= ' ') goto yy1870; - if (yych <= '[') goto yy1887; - } else { - if (yych <= 0x7F) goto yy1887; - if (yych <= 0xC1) goto yy1848; - if (yych <= 0xDF) goto yy1898; - goto yy1899; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1904; - goto yy1900; - } else { - if (yych <= 0xF0) goto yy1901; - if (yych <= 0xF3) goto yy1902; - if (yych <= 0xF4) goto yy1903; - goto yy1848; - } - } - yyaccept = 0; - marker = ++p; - yych = *p; - if (yych <= 0xDF) { - if (yych <= '[') { - if (yych <= ' ') goto yy1841; - if (yych == '(') goto yy1861; - goto yy1887; - } else { - if (yych <= '\\') goto yy1896; - if (yych <= 0x7F) goto yy1887; - if (yych <= 0xC1) goto yy1841; - goto yy1889; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy1890; - if (yych == 0xED) goto yy1895; - goto yy1891; - } else { - if (yych <= 0xF0) goto yy1892; - if (yych <= 0xF3) goto yy1893; - if (yych <= 0xF4) goto yy1894; - goto yy1841; - } - } -yy1898: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1887; - goto yy1848; -yy1899: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1898; - goto yy1848; -yy1900: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1898; - goto yy1848; -yy1901: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1900; - goto yy1848; -yy1902: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1900; - goto yy1848; -yy1903: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1900; - goto yy1848; -yy1904: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1898; - goto yy1848; -yy1905: - yyaccept = 0; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1905; - } - if (yych <= '>') { - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1841; - goto yy1919; - } else { - if (yych <= '\n') goto yy1841; - if (yych <= '\f') goto yy1919; - goto yy1841; - } - } else { - if (yych <= '(') { - if (yych <= ' ') goto yy1919; - goto yy1917; - } else { - if (yych <= ')') goto yy1919; - if (yych <= '<') goto yy1870; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') goto yy1916; - goto yy1841; - } else { - if (yych <= 0xDF) goto yy1909; - if (yych <= 0xE0) goto yy1910; - goto yy1911; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1915; - if (yych <= 0xEF) goto yy1911; - goto yy1912; - } else { - if (yych <= 0xF3) goto yy1913; - if (yych <= 0xF4) goto yy1914; - goto yy1841; - } - } - } -yy1907: - yyaccept = 2; - yych = *(marker = ++p); - if (yych <= ')') { - if (yych <= ' ') goto yy1908; - if (yych <= '(') goto yy1871; - } else { - if (yych <= 0x7F) goto yy1871; - if (yych <= 0xC1) goto yy1908; - if (yych <= 0xF4) goto yy1871; - } -yy1908: - { return (bufsize_t)(p - start); } -yy1909: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1905; - goto yy1848; -yy1910: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1909; - goto yy1848; -yy1911: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1909; - goto yy1848; -yy1912: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1911; - goto yy1848; -yy1913: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1911; - goto yy1848; -yy1914: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1911; - goto yy1848; -yy1915: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1909; - goto yy1848; -yy1916: - ++p; - yych = *p; - if (yych <= 0x7F) { - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1870; - goto yy1905; - } else { - if (yych <= '\n') goto yy1870; - if (yych <= '\f') goto yy1905; - goto yy1870; - } - } else { - if (yych <= '>') { - if (yych <= '=') goto yy1905; - goto yy1963; - } else { - if (yych == '\\') goto yy1964; - goto yy1905; - } - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) { - if (yych <= 0xC1) goto yy1848; - goto yy1965; - } else { - if (yych <= 0xE0) goto yy1966; - if (yych <= 0xEC) goto yy1967; - goto yy1971; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1967; - goto yy1968; - } else { - if (yych <= 0xF3) goto yy1969; - if (yych <= 0xF4) goto yy1970; - goto yy1848; - } - } - } -yy1917: - ++p; - yych = *p; - if (yych <= '>') { - if (yych <= ' ') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1848; - if (yych >= '\n') goto yy1848; - } else { - if (yych == '\r') goto yy1848; - } - } else { - if (yych <= ')') { - if (yych <= '\'') goto yy1917; - if (yych >= ')') goto yy1905; - } else { - if (yych == '<') goto yy1861; - if (yych <= '=') goto yy1917; - goto yy1932; - } - } - } else { - if (yych <= 0xE0) { - if (yych <= 0x7F) { - if (yych == '\\') goto yy1933; - goto yy1917; - } else { - if (yych <= 0xC1) goto yy1848; - if (yych <= 0xDF) goto yy1935; - goto yy1936; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1941; - goto yy1937; - } else { - if (yych <= 0xF0) goto yy1938; - if (yych <= 0xF3) goto yy1939; - if (yych <= 0xF4) goto yy1940; - goto yy1848; - } - } - } -yy1919: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1919; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '<') goto yy1848; - if (yych >= '?') goto yy1922; - } else { - if (yych <= 0xC1) goto yy1848; - if (yych <= 0xDF) goto yy1924; - goto yy1925; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1930; - goto yy1926; - } else { - if (yych <= 0xF0) goto yy1927; - if (yych <= 0xF3) goto yy1928; - if (yych <= 0xF4) goto yy1929; - goto yy1848; - } - } -yy1921: - yych = *++p; - goto yy1908; -yy1922: - ++p; - yych = *p; - if (yych <= 0x7F) { - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1848; - goto yy1919; - } else { - if (yych <= '\n') goto yy1848; - if (yych <= '\f') goto yy1919; - goto yy1848; - } - } else { - if (yych <= '>') { - if (yych <= '=') goto yy1919; - goto yy1931; - } else { - if (yych == '\\') goto yy1922; - goto yy1919; - } - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) { - if (yych <= 0xC1) goto yy1848; - } else { - if (yych <= 0xE0) goto yy1925; - if (yych <= 0xEC) goto yy1926; - goto yy1930; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1926; - goto yy1927; - } else { - if (yych <= 0xF3) goto yy1928; - if (yych <= 0xF4) goto yy1929; - goto yy1848; - } - } - } -yy1924: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1919; - goto yy1848; -yy1925: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1924; - goto yy1848; -yy1926: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1924; - goto yy1848; -yy1927: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1926; - goto yy1848; -yy1928: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1926; - goto yy1848; -yy1929: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1926; - goto yy1848; -yy1930: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1924; - goto yy1848; -yy1931: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy1919; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '<') goto yy1908; - if (yych <= '>') goto yy1921; - goto yy1922; - } else { - if (yych <= 0xC1) goto yy1908; - if (yych <= 0xDF) goto yy1924; - goto yy1925; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1930; - goto yy1926; - } else { - if (yych <= 0xF0) goto yy1927; - if (yych <= 0xF3) goto yy1928; - if (yych <= 0xF4) goto yy1929; - goto yy1908; - } - } -yy1932: - yyaccept = 2; - yych = *(marker = ++p); - if (yych <= '(') { - if (yych <= ' ') goto yy1908; - if (yych <= '\'') goto yy1862; - goto yy1908; - } else { - if (yych <= 0x7F) goto yy1862; - if (yych <= 0xC1) goto yy1908; - if (yych <= 0xF4) goto yy1862; - goto yy1908; - } -yy1933: - ++p; - yych = *p; - if (yych <= '[') { - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1848; - goto yy1919; - } else { - if (yych <= '\n') goto yy1848; - if (yych <= '\f') goto yy1919; - goto yy1848; - } - } else { - if (yych <= ')') { - if (yych <= ' ') goto yy1919; - if (yych <= '(') goto yy1917; - goto yy1942; - } else { - if (yych == '>') goto yy1944; - goto yy1917; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') goto yy1933; - if (yych <= 0x7F) goto yy1917; - goto yy1848; - } else { - if (yych <= 0xDF) goto yy1935; - if (yych <= 0xE0) goto yy1936; - goto yy1937; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1941; - if (yych <= 0xEF) goto yy1937; - goto yy1938; - } else { - if (yych <= 0xF3) goto yy1939; - if (yych <= 0xF4) goto yy1940; - goto yy1848; - } - } - } -yy1935: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1917; - goto yy1848; -yy1936: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1935; - goto yy1848; -yy1937: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1935; - goto yy1848; -yy1938: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1937; - goto yy1848; -yy1939: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1937; - goto yy1848; -yy1940: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1937; - goto yy1848; -yy1941: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1935; - goto yy1848; -yy1942: - yyaccept = 0; - marker = ++p; - yych = *p; - if (yych <= '>') { - if (yych <= ' ') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1841; - if (yych <= '\t') goto yy1919; - goto yy1841; - } else { - if (yych == '\r') goto yy1841; - goto yy1919; - } - } else { - if (yych <= ')') { - if (yych <= '\'') goto yy1942; - if (yych <= '(') goto yy1917; - goto yy1905; - } else { - if (yych == '<') goto yy1887; - if (yych <= '=') goto yy1942; - goto yy1945; - } - } - } else { - if (yych <= 0xE0) { - if (yych <= 0x7F) { - if (yych == '\\') goto yy1946; - goto yy1942; - } else { - if (yych <= 0xC1) goto yy1841; - if (yych <= 0xDF) goto yy1947; - goto yy1948; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1953; - goto yy1949; - } else { - if (yych <= 0xF0) goto yy1950; - if (yych <= 0xF3) goto yy1951; - if (yych <= 0xF4) goto yy1952; - goto yy1841; - } - } - } -yy1944: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yych <= '>') { - if (yych <= ' ') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1908; - if (yych <= '\t') goto yy1919; - goto yy1908; - } else { - if (yych == '\r') goto yy1908; - goto yy1919; - } - } else { - if (yych <= ')') { - if (yych <= '\'') goto yy1917; - if (yych <= '(') goto yy1919; - goto yy1905; - } else { - if (yych == '<') goto yy1861; - if (yych <= '=') goto yy1917; - goto yy1932; - } - } - } else { - if (yych <= 0xE0) { - if (yych <= 0x7F) { - if (yych == '\\') goto yy1933; - goto yy1917; - } else { - if (yych <= 0xC1) goto yy1908; - if (yych <= 0xDF) goto yy1935; - goto yy1936; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1941; - goto yy1937; - } else { - if (yych <= 0xF0) goto yy1938; - if (yych <= 0xF3) goto yy1939; - if (yych <= 0xF4) goto yy1940; - goto yy1908; - } - } - } -yy1945: - yyaccept = 2; - yych = *(marker = ++p); - if (yych <= ' ') goto yy1908; - if (yych <= 0x7F) goto yy1888; - if (yych <= 0xC1) goto yy1908; - if (yych <= 0xF4) goto yy1888; - goto yy1908; -yy1946: - ++p; - yych = *p; - if (yych <= '\\') { - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1870; - goto yy1905; - } else { - if (yych <= '\n') goto yy1870; - if (yych <= '\f') goto yy1905; - goto yy1870; - } - } else { - if (yych <= '=') { - if (yych <= ' ') goto yy1905; - goto yy1942; - } else { - if (yych <= '>') goto yy1954; - if (yych <= '[') goto yy1942; - goto yy1955; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) goto yy1942; - goto yy1848; - } else { - if (yych <= 0xDF) goto yy1956; - if (yych <= 0xE0) goto yy1957; - goto yy1958; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1962; - if (yych <= 0xEF) goto yy1958; - goto yy1959; - } else { - if (yych <= 0xF3) goto yy1960; - if (yych <= 0xF4) goto yy1961; - goto yy1848; - } - } - } -yy1947: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1942; - goto yy1848; -yy1948: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1947; - goto yy1848; -yy1949: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1947; - goto yy1848; -yy1950: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1949; - goto yy1848; -yy1951: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1949; - goto yy1848; -yy1952: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1949; - goto yy1848; -yy1953: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1947; - goto yy1848; -yy1954: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yych <= '>') { - if (yych <= ' ') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1908; - if (yych <= '\t') goto yy1919; - goto yy1908; - } else { - if (yych == '\r') goto yy1908; - goto yy1919; - } - } else { - if (yych <= ')') { - if (yych <= '\'') goto yy1942; - if (yych <= '(') goto yy1917; - goto yy1905; - } else { - if (yych == '<') goto yy1887; - if (yych <= '=') goto yy1942; - goto yy1945; - } - } - } else { - if (yych <= 0xE0) { - if (yych <= 0x7F) { - if (yych == '\\') goto yy1946; - goto yy1942; - } else { - if (yych <= 0xC1) goto yy1908; - if (yych <= 0xDF) goto yy1947; - goto yy1948; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1953; - goto yy1949; - } else { - if (yych <= 0xF0) goto yy1950; - if (yych <= 0xF3) goto yy1951; - if (yych <= 0xF4) goto yy1952; - goto yy1908; - } - } - } -yy1955: - yyaccept = 0; - marker = ++p; - yych = *p; - if (yych <= '[') { - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1841; - goto yy1919; - } else { - if (yych <= '\n') goto yy1841; - if (yych <= '\f') goto yy1919; - goto yy1841; - } - } else { - if (yych <= '(') { - if (yych <= ' ') goto yy1919; - if (yych <= '\'') goto yy1942; - goto yy1917; - } else { - if (yych == '>') goto yy1954; - goto yy1942; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') goto yy1946; - if (yych <= 0x7F) goto yy1942; - goto yy1841; - } else { - if (yych <= 0xDF) goto yy1947; - if (yych <= 0xE0) goto yy1948; - goto yy1949; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1953; - if (yych <= 0xEF) goto yy1949; - goto yy1950; - } else { - if (yych <= 0xF3) goto yy1951; - if (yych <= 0xF4) goto yy1952; - goto yy1841; - } - } - } -yy1956: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1942; - goto yy1848; -yy1957: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1956; - goto yy1848; -yy1958: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1956; - goto yy1848; -yy1959: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1958; - goto yy1848; -yy1960: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1958; - goto yy1848; -yy1961: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1958; - goto yy1848; -yy1962: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1956; - goto yy1848; -yy1963: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy1905; - } - if (yych <= '>') { - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) goto yy1908; - goto yy1919; - } else { - if (yych <= '\n') goto yy1908; - if (yych <= '\f') goto yy1919; - goto yy1908; - } - } else { - if (yych <= '(') { - if (yych <= ' ') goto yy1919; - goto yy1917; - } else { - if (yych <= ')') goto yy1919; - if (yych <= '<') goto yy1870; - goto yy1907; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') goto yy1916; - goto yy1908; - } else { - if (yych <= 0xDF) goto yy1909; - if (yych <= 0xE0) goto yy1910; - goto yy1911; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1915; - if (yych <= 0xEF) goto yy1911; - goto yy1912; - } else { - if (yych <= 0xF3) goto yy1913; - if (yych <= 0xF4) goto yy1914; - goto yy1908; - } - } - } -yy1964: - yyaccept = 0; - marker = ++p; - yych = *p; - if (yych <= '[') { - if (yych <= ' ') { - if (yych <= '\n') { - if (yych <= 0x00) goto yy1841; - if (yych <= '\t') goto yy1919; - goto yy1841; - } else { - if (yych == '\r') goto yy1841; - goto yy1919; - } - } else { - if (yych <= ')') { - if (yych <= '\'') goto yy1905; - if (yych <= '(') goto yy1917; - goto yy1919; - } else { - if (yych == '>') goto yy1963; - goto yy1905; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') goto yy1916; - if (yych <= 0x7F) goto yy1905; - goto yy1841; - } else { - if (yych <= 0xDF) goto yy1909; - if (yych <= 0xE0) goto yy1910; - goto yy1911; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy1915; - if (yych <= 0xEF) goto yy1911; - goto yy1912; - } else { - if (yych <= 0xF3) goto yy1913; - if (yych <= 0xF4) goto yy1914; - goto yy1841; - } - } - } -yy1965: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1905; - goto yy1848; -yy1966: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1848; - if (yych <= 0xBF) goto yy1965; - goto yy1848; -yy1967: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1965; - goto yy1848; -yy1968: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1848; - if (yych <= 0xBF) goto yy1967; - goto yy1848; -yy1969: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0xBF) goto yy1967; - goto yy1848; -yy1970: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x8F) goto yy1967; - goto yy1848; -yy1971: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1848; - if (yych <= 0x9F) goto yy1965; - goto yy1848; -} - + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 8, 128, 128, 8, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 136, 224, 224, 224, 224, 224, 224, 224, 128, 128, + 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 32, 224, 32, 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, 224, 224, 224, 16, 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, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); + if (yych <= '[') { + if (yych <= ' ') { + if (yych <= '\f') { + if (yych == '\n') + goto yy1844; + goto yy1860; + } else { + if (yych <= '\r') + goto yy1846; + if (yych <= 0x1F) + goto yy1860; + goto yy1846; + } + } else { + if (yych <= ')') { + if (yych <= '\'') + goto yy1848; + if (yych <= '(') + goto yy1859; + goto yy1860; + } else { + if (yych == '<') + goto yy1847; + goto yy1848; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') + goto yy1857; + if (yych <= 0x7F) + goto yy1848; + } else { + if (yych <= 0xDF) + goto yy1849; + if (yych <= 0xE0) + goto yy1851; + goto yy1852; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1856; + if (yych <= 0xEF) + goto yy1852; + goto yy1853; + } else { + if (yych <= 0xF3) + goto yy1854; + if (yych <= 0xF4) + goto yy1855; + } + } + } + yy1843 : { return (bufsize_t)(p - start); } + yy1844: + yyaccept = 0; + marker = ++p; + yych = *p; + yy1845: + if (yybm[0 + yych] & 8) { + goto yy1844; + } + if (yych <= 0x7F) { + if (yych <= ')') { + if (yych <= 0x1F) + goto yy1843; + if (yych <= '\'') + goto yy1872; + if (yych <= '(') + goto yy1863; + goto yy1843; + } else { + if (yych <= '<') { + if (yych <= ';') + goto yy1872; + goto yy1907; + } else { + if (yych == '\\') + goto yy1881; + goto yy1872; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) { + if (yych <= 0xC1) + goto yy1843; + goto yy1874; + } else { + if (yych <= 0xE0) + goto yy1875; + if (yych <= 0xEC) + goto yy1876; + goto yy1880; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1876; + goto yy1877; + } else { + if (yych <= 0xF3) + goto yy1878; + if (yych <= 0xF4) + goto yy1879; + goto yy1843; + } + } + } + yy1846: + yyaccept = 0; + yych = *(marker = ++p); + goto yy1845; + yy1847: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy1907; + } + if (yych <= '>') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy1843; + goto yy1921; + } else { + if (yych <= '\n') + goto yy1843; + if (yych <= '\f') + goto yy1921; + goto yy1843; + } + } else { + if (yych <= '(') { + if (yych <= ' ') + goto yy1921; + goto yy1919; + } else { + if (yych <= ')') + goto yy1921; + if (yych <= '<') + goto yy1872; + goto yy1909; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') + goto yy1918; + goto yy1843; + } else { + if (yych <= 0xDF) + goto yy1911; + if (yych <= 0xE0) + goto yy1912; + goto yy1913; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1917; + if (yych <= 0xEF) + goto yy1913; + goto yy1914; + } else { + if (yych <= 0xF3) + goto yy1915; + if (yych <= 0xF4) + goto yy1916; + goto yy1843; + } + } + } + yy1848: + yyaccept = 0; + yych = *(marker = ++p); + goto yy1873; + yy1849: + yych = *++p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1848; + yy1850: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy1843; + } else { + goto yy1858; + } + } else { + goto yy1910; + } + yy1851: + yych = *++p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1849; + goto yy1850; + yy1852: + yych = *++p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1849; + goto yy1850; + yy1853: + yych = *++p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1852; + goto yy1850; + yy1854: + yych = *++p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1852; + goto yy1850; + yy1855: + yych = *++p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1852; + goto yy1850; + yy1856: + yych = *++p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1849; + goto yy1850; + yy1857: + yyaccept = 1; + yych = *(marker = ++p); + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) + goto yy1872; + } else { + if (yych <= 0xDF) + goto yy1882; + if (yych <= 0xE0) + goto yy1883; + goto yy1884; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1888; + if (yych <= 0xEF) + goto yy1884; + goto yy1885; + } else { + if (yych <= 0xF3) + goto yy1886; + if (yych <= 0xF4) + goto yy1887; + } + } + yy1858 : { return 0; } + yy1859: + yyaccept = 1; + yych = *(marker = ++p); + if (yych <= '(') { + if (yych <= ' ') + goto yy1858; + if (yych <= '\'') + goto yy1864; + goto yy1858; + } else { + if (yych <= 0x7F) + goto yy1864; + if (yych <= 0xC1) + goto yy1858; + if (yych <= 0xF4) + goto yy1864; + goto yy1858; + } + yy1860: + yych = *++p; + goto yy1858; + yy1861: + ++p; + yych = *p; + if (yybm[0 + yych] & 16) { + goto yy1861; + } + if (yych <= 0xE0) { + if (yych <= ')') { + if (yych <= ' ') + goto yy1850; + if (yych >= ')') + goto yy1889; + } else { + if (yych <= 0x7F) + goto yy1863; + if (yych <= 0xC1) + goto yy1850; + if (yych <= 0xDF) + goto yy1865; + goto yy1866; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1871; + goto yy1867; + } else { + if (yych <= 0xF0) + goto yy1868; + if (yych <= 0xF3) + goto yy1869; + if (yych <= 0xF4) + goto yy1870; + goto yy1850; + } + } + yy1863: + ++p; + yych = *p; + yy1864: + if (yybm[0 + yych] & 32) { + goto yy1863; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= '(') + goto yy1850; + if (yych <= ')') + goto yy1872; + goto yy1861; + } else { + if (yych <= 0xC1) + goto yy1850; + if (yych >= 0xE0) + goto yy1866; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1871; + goto yy1867; + } else { + if (yych <= 0xF0) + goto yy1868; + if (yych <= 0xF3) + goto yy1869; + if (yych <= 0xF4) + goto yy1870; + goto yy1850; + } + } + yy1865: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1863; + goto yy1850; + yy1866: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1865; + goto yy1850; + yy1867: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1865; + goto yy1850; + yy1868: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1867; + goto yy1850; + yy1869: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1867; + goto yy1850; + yy1870: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1867; + goto yy1850; + yy1871: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1865; + goto yy1850; + yy1872: + yyaccept = 0; + marker = ++p; + yych = *p; + yy1873: + if (yych <= 0xC1) { + if (yych <= ')') { + if (yych <= ' ') + goto yy1843; + if (yych <= '\'') + goto yy1872; + if (yych <= '(') + goto yy1863; + goto yy1843; + } else { + if (yych == '\\') + goto yy1881; + if (yych <= 0x7F) + goto yy1872; + goto yy1843; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1874; + if (yych <= 0xE0) + goto yy1875; + if (yych <= 0xEC) + goto yy1876; + goto yy1880; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1876; + goto yy1877; + } else { + if (yych <= 0xF3) + goto yy1878; + if (yych <= 0xF4) + goto yy1879; + goto yy1843; + } + } + } + yy1874: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1872; + goto yy1850; + yy1875: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1874; + goto yy1850; + yy1876: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1874; + goto yy1850; + yy1877: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1876; + goto yy1850; + yy1878: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1876; + goto yy1850; + yy1879: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1876; + goto yy1850; + yy1880: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1874; + goto yy1850; + yy1881: + ++p; + yych = *p; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) + goto yy1872; + goto yy1850; + } else { + if (yych <= 0xDF) + goto yy1882; + if (yych <= 0xE0) + goto yy1883; + goto yy1884; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1888; + if (yych <= 0xEF) + goto yy1884; + goto yy1885; + } else { + if (yych <= 0xF3) + goto yy1886; + if (yych <= 0xF4) + goto yy1887; + goto yy1850; + } + } + yy1882: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1872; + goto yy1850; + yy1883: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1882; + goto yy1850; + yy1884: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1882; + goto yy1850; + yy1885: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1884; + goto yy1850; + yy1886: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1884; + goto yy1850; + yy1887: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1884; + goto yy1850; + yy1888: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1882; + goto yy1850; + yy1889: + yyaccept = 0; + marker = ++p; + yych = *p; + yy1890: + if (yych <= 0xC1) { + if (yych <= ')') { + if (yych <= ' ') + goto yy1843; + if (yych <= '\'') + goto yy1889; + if (yych <= '(') + goto yy1863; + goto yy1872; + } else { + if (yych == '\\') + goto yy1898; + if (yych <= 0x7F) + goto yy1889; + goto yy1843; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1891; + if (yych <= 0xE0) + goto yy1892; + if (yych <= 0xEC) + goto yy1893; + goto yy1897; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1893; + goto yy1894; + } else { + if (yych <= 0xF3) + goto yy1895; + if (yych <= 0xF4) + goto yy1896; + goto yy1843; + } + } + } + yy1891: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1889; + goto yy1850; + yy1892: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1891; + goto yy1850; + yy1893: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1891; + goto yy1850; + yy1894: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1893; + goto yy1850; + yy1895: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1893; + goto yy1850; + yy1896: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1893; + goto yy1850; + yy1897: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1891; + goto yy1850; + yy1898: + ++p; + yych = *p; + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= ' ') + goto yy1872; + if (yych <= '[') + goto yy1889; + } else { + if (yych <= 0x7F) + goto yy1889; + if (yych <= 0xC1) + goto yy1850; + if (yych <= 0xDF) + goto yy1900; + goto yy1901; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1906; + goto yy1902; + } else { + if (yych <= 0xF0) + goto yy1903; + if (yych <= 0xF3) + goto yy1904; + if (yych <= 0xF4) + goto yy1905; + goto yy1850; + } + } + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= 0xDF) { + if (yych <= '[') { + if (yych <= ' ') + goto yy1843; + if (yych == '(') + goto yy1863; + goto yy1889; + } else { + if (yych <= '\\') + goto yy1898; + if (yych <= 0x7F) + goto yy1889; + if (yych <= 0xC1) + goto yy1843; + goto yy1891; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1892; + if (yych == 0xED) + goto yy1897; + goto yy1893; + } else { + if (yych <= 0xF0) + goto yy1894; + if (yych <= 0xF3) + goto yy1895; + if (yych <= 0xF4) + goto yy1896; + goto yy1843; + } + } + yy1900: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1889; + goto yy1850; + yy1901: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1900; + goto yy1850; + yy1902: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1900; + goto yy1850; + yy1903: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1902; + goto yy1850; + yy1904: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1902; + goto yy1850; + yy1905: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1902; + goto yy1850; + yy1906: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1900; + goto yy1850; + yy1907: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1907; + } + if (yych <= '>') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy1843; + goto yy1921; + } else { + if (yych <= '\n') + goto yy1843; + if (yych <= '\f') + goto yy1921; + goto yy1843; + } + } else { + if (yych <= '(') { + if (yych <= ' ') + goto yy1921; + goto yy1919; + } else { + if (yych <= ')') + goto yy1921; + if (yych <= '<') + goto yy1872; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') + goto yy1918; + goto yy1843; + } else { + if (yych <= 0xDF) + goto yy1911; + if (yych <= 0xE0) + goto yy1912; + goto yy1913; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1917; + if (yych <= 0xEF) + goto yy1913; + goto yy1914; + } else { + if (yych <= 0xF3) + goto yy1915; + if (yych <= 0xF4) + goto yy1916; + goto yy1843; + } + } + } + yy1909: + yyaccept = 2; + yych = *(marker = ++p); + if (yych <= ')') { + if (yych <= ' ') + goto yy1910; + if (yych <= '(') + goto yy1873; + } else { + if (yych <= 0x7F) + goto yy1873; + if (yych <= 0xC1) + goto yy1910; + if (yych <= 0xF4) + goto yy1873; + } + yy1910 : { return (bufsize_t)(p - start); } + yy1911: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1907; + goto yy1850; + yy1912: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1911; + goto yy1850; + yy1913: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1911; + goto yy1850; + yy1914: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1913; + goto yy1850; + yy1915: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1913; + goto yy1850; + yy1916: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1913; + goto yy1850; + yy1917: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1911; + goto yy1850; + yy1918: + ++p; + yych = *p; + if (yych <= 0x7F) { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy1872; + goto yy1907; + } else { + if (yych <= '\n') + goto yy1872; + if (yych <= '\f') + goto yy1907; + goto yy1872; + } + } else { + if (yych <= '>') { + if (yych <= '=') + goto yy1907; + goto yy1965; + } else { + if (yych == '\\') + goto yy1966; + goto yy1907; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) { + if (yych <= 0xC1) + goto yy1850; + goto yy1967; + } else { + if (yych <= 0xE0) + goto yy1968; + if (yych <= 0xEC) + goto yy1969; + goto yy1973; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1969; + goto yy1970; + } else { + if (yych <= 0xF3) + goto yy1971; + if (yych <= 0xF4) + goto yy1972; + goto yy1850; + } + } + } + yy1919: + ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= '\n') { + if (yych <= 0x00) + goto yy1850; + if (yych >= '\n') + goto yy1850; + } else { + if (yych == '\r') + goto yy1850; + } + } else { + if (yych <= ')') { + if (yych <= '\'') + goto yy1919; + if (yych >= ')') + goto yy1907; + } else { + if (yych == '<') + goto yy1863; + if (yych <= '=') + goto yy1919; + goto yy1934; + } + } + } else { + if (yych <= 0xE0) { + if (yych <= 0x7F) { + if (yych == '\\') + goto yy1935; + goto yy1919; + } else { + if (yych <= 0xC1) + goto yy1850; + if (yych <= 0xDF) + goto yy1937; + goto yy1938; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1943; + goto yy1939; + } else { + if (yych <= 0xF0) + goto yy1940; + if (yych <= 0xF3) + goto yy1941; + if (yych <= 0xF4) + goto yy1942; + goto yy1850; + } + } + } + yy1921: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1921; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= '<') + goto yy1850; + if (yych >= '?') + goto yy1924; + } else { + if (yych <= 0xC1) + goto yy1850; + if (yych <= 0xDF) + goto yy1926; + goto yy1927; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1932; + goto yy1928; + } else { + if (yych <= 0xF0) + goto yy1929; + if (yych <= 0xF3) + goto yy1930; + if (yych <= 0xF4) + goto yy1931; + goto yy1850; + } + } + yy1923: + yych = *++p; + goto yy1910; + yy1924: + ++p; + yych = *p; + if (yych <= 0x7F) { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy1850; + goto yy1921; + } else { + if (yych <= '\n') + goto yy1850; + if (yych <= '\f') + goto yy1921; + goto yy1850; + } + } else { + if (yych <= '>') { + if (yych <= '=') + goto yy1921; + goto yy1933; + } else { + if (yych == '\\') + goto yy1924; + goto yy1921; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) { + if (yych <= 0xC1) + goto yy1850; + } else { + if (yych <= 0xE0) + goto yy1927; + if (yych <= 0xEC) + goto yy1928; + goto yy1932; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1928; + goto yy1929; + } else { + if (yych <= 0xF3) + goto yy1930; + if (yych <= 0xF4) + goto yy1931; + goto yy1850; + } + } + } + yy1926: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1921; + goto yy1850; + yy1927: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1926; + goto yy1850; + yy1928: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1926; + goto yy1850; + yy1929: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1928; + goto yy1850; + yy1930: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1928; + goto yy1850; + yy1931: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1928; + goto yy1850; + yy1932: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1926; + goto yy1850; + yy1933: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1921; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= '<') + goto yy1910; + if (yych <= '>') + goto yy1923; + goto yy1924; + } else { + if (yych <= 0xC1) + goto yy1910; + if (yych <= 0xDF) + goto yy1926; + goto yy1927; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1932; + goto yy1928; + } else { + if (yych <= 0xF0) + goto yy1929; + if (yych <= 0xF3) + goto yy1930; + if (yych <= 0xF4) + goto yy1931; + goto yy1910; + } + } + yy1934: + yyaccept = 2; + yych = *(marker = ++p); + if (yych <= '(') { + if (yych <= ' ') + goto yy1910; + if (yych <= '\'') + goto yy1864; + goto yy1910; + } else { + if (yych <= 0x7F) + goto yy1864; + if (yych <= 0xC1) + goto yy1910; + if (yych <= 0xF4) + goto yy1864; + goto yy1910; + } + yy1935: + ++p; + yych = *p; + if (yych <= '[') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy1850; + goto yy1921; + } else { + if (yych <= '\n') + goto yy1850; + if (yych <= '\f') + goto yy1921; + goto yy1850; + } + } else { + if (yych <= ')') { + if (yych <= ' ') + goto yy1921; + if (yych <= '(') + goto yy1919; + goto yy1944; + } else { + if (yych == '>') + goto yy1946; + goto yy1919; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') + goto yy1935; + if (yych <= 0x7F) + goto yy1919; + goto yy1850; + } else { + if (yych <= 0xDF) + goto yy1937; + if (yych <= 0xE0) + goto yy1938; + goto yy1939; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1943; + if (yych <= 0xEF) + goto yy1939; + goto yy1940; + } else { + if (yych <= 0xF3) + goto yy1941; + if (yych <= 0xF4) + goto yy1942; + goto yy1850; + } + } + } + yy1937: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1919; + goto yy1850; + yy1938: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1937; + goto yy1850; + yy1939: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1937; + goto yy1850; + yy1940: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1939; + goto yy1850; + yy1941: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1939; + goto yy1850; + yy1942: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1939; + goto yy1850; + yy1943: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1937; + goto yy1850; + yy1944: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= '\n') { + if (yych <= 0x00) + goto yy1843; + if (yych <= '\t') + goto yy1921; + goto yy1843; + } else { + if (yych == '\r') + goto yy1843; + goto yy1921; + } + } else { + if (yych <= ')') { + if (yych <= '\'') + goto yy1944; + if (yych <= '(') + goto yy1919; + goto yy1907; + } else { + if (yych == '<') + goto yy1889; + if (yych <= '=') + goto yy1944; + goto yy1947; + } + } + } else { + if (yych <= 0xE0) { + if (yych <= 0x7F) { + if (yych == '\\') + goto yy1948; + goto yy1944; + } else { + if (yych <= 0xC1) + goto yy1843; + if (yych <= 0xDF) + goto yy1949; + goto yy1950; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1955; + goto yy1951; + } else { + if (yych <= 0xF0) + goto yy1952; + if (yych <= 0xF3) + goto yy1953; + if (yych <= 0xF4) + goto yy1954; + goto yy1843; + } + } + } + yy1946: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= '\n') { + if (yych <= 0x00) + goto yy1910; + if (yych <= '\t') + goto yy1921; + goto yy1910; + } else { + if (yych == '\r') + goto yy1910; + goto yy1921; + } + } else { + if (yych <= ')') { + if (yych <= '\'') + goto yy1919; + if (yych <= '(') + goto yy1921; + goto yy1907; + } else { + if (yych == '<') + goto yy1863; + if (yych <= '=') + goto yy1919; + goto yy1934; + } + } + } else { + if (yych <= 0xE0) { + if (yych <= 0x7F) { + if (yych == '\\') + goto yy1935; + goto yy1919; + } else { + if (yych <= 0xC1) + goto yy1910; + if (yych <= 0xDF) + goto yy1937; + goto yy1938; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1943; + goto yy1939; + } else { + if (yych <= 0xF0) + goto yy1940; + if (yych <= 0xF3) + goto yy1941; + if (yych <= 0xF4) + goto yy1942; + goto yy1910; + } + } + } + yy1947: + yyaccept = 2; + yych = *(marker = ++p); + if (yych <= ' ') + goto yy1910; + if (yych <= 0x7F) + goto yy1890; + if (yych <= 0xC1) + goto yy1910; + if (yych <= 0xF4) + goto yy1890; + goto yy1910; + yy1948: + ++p; + yych = *p; + if (yych <= '\\') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy1872; + goto yy1907; + } else { + if (yych <= '\n') + goto yy1872; + if (yych <= '\f') + goto yy1907; + goto yy1872; + } + } else { + if (yych <= '=') { + if (yych <= ' ') + goto yy1907; + goto yy1944; + } else { + if (yych <= '>') + goto yy1956; + if (yych <= '[') + goto yy1944; + goto yy1957; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) + goto yy1944; + goto yy1850; + } else { + if (yych <= 0xDF) + goto yy1958; + if (yych <= 0xE0) + goto yy1959; + goto yy1960; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1964; + if (yych <= 0xEF) + goto yy1960; + goto yy1961; + } else { + if (yych <= 0xF3) + goto yy1962; + if (yych <= 0xF4) + goto yy1963; + goto yy1850; + } + } + } + yy1949: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1944; + goto yy1850; + yy1950: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1949; + goto yy1850; + yy1951: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1949; + goto yy1850; + yy1952: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1951; + goto yy1850; + yy1953: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1951; + goto yy1850; + yy1954: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1951; + goto yy1850; + yy1955: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1949; + goto yy1850; + yy1956: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= '\n') { + if (yych <= 0x00) + goto yy1910; + if (yych <= '\t') + goto yy1921; + goto yy1910; + } else { + if (yych == '\r') + goto yy1910; + goto yy1921; + } + } else { + if (yych <= ')') { + if (yych <= '\'') + goto yy1944; + if (yych <= '(') + goto yy1919; + goto yy1907; + } else { + if (yych == '<') + goto yy1889; + if (yych <= '=') + goto yy1944; + goto yy1947; + } + } + } else { + if (yych <= 0xE0) { + if (yych <= 0x7F) { + if (yych == '\\') + goto yy1948; + goto yy1944; + } else { + if (yych <= 0xC1) + goto yy1910; + if (yych <= 0xDF) + goto yy1949; + goto yy1950; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1955; + goto yy1951; + } else { + if (yych <= 0xF0) + goto yy1952; + if (yych <= 0xF3) + goto yy1953; + if (yych <= 0xF4) + goto yy1954; + goto yy1910; + } + } + } + yy1957: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= '[') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy1843; + goto yy1921; + } else { + if (yych <= '\n') + goto yy1843; + if (yych <= '\f') + goto yy1921; + goto yy1843; + } + } else { + if (yych <= '(') { + if (yych <= ' ') + goto yy1921; + if (yych <= '\'') + goto yy1944; + goto yy1919; + } else { + if (yych == '>') + goto yy1956; + goto yy1944; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') + goto yy1948; + if (yych <= 0x7F) + goto yy1944; + goto yy1843; + } else { + if (yych <= 0xDF) + goto yy1949; + if (yych <= 0xE0) + goto yy1950; + goto yy1951; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1955; + if (yych <= 0xEF) + goto yy1951; + goto yy1952; + } else { + if (yych <= 0xF3) + goto yy1953; + if (yych <= 0xF4) + goto yy1954; + goto yy1843; + } + } + } + yy1958: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1944; + goto yy1850; + yy1959: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1958; + goto yy1850; + yy1960: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1958; + goto yy1850; + yy1961: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1960; + goto yy1850; + yy1962: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1960; + goto yy1850; + yy1963: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1960; + goto yy1850; + yy1964: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1958; + goto yy1850; + yy1965: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy1907; + } + if (yych <= '>') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy1910; + goto yy1921; + } else { + if (yych <= '\n') + goto yy1910; + if (yych <= '\f') + goto yy1921; + goto yy1910; + } + } else { + if (yych <= '(') { + if (yych <= ' ') + goto yy1921; + goto yy1919; + } else { + if (yych <= ')') + goto yy1921; + if (yych <= '<') + goto yy1872; + goto yy1909; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') + goto yy1918; + goto yy1910; + } else { + if (yych <= 0xDF) + goto yy1911; + if (yych <= 0xE0) + goto yy1912; + goto yy1913; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1917; + if (yych <= 0xEF) + goto yy1913; + goto yy1914; + } else { + if (yych <= 0xF3) + goto yy1915; + if (yych <= 0xF4) + goto yy1916; + goto yy1910; + } + } + } + yy1966: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= '[') { + if (yych <= ' ') { + if (yych <= '\n') { + if (yych <= 0x00) + goto yy1843; + if (yych <= '\t') + goto yy1921; + goto yy1843; + } else { + if (yych == '\r') + goto yy1843; + goto yy1921; + } + } else { + if (yych <= ')') { + if (yych <= '\'') + goto yy1907; + if (yych <= '(') + goto yy1919; + goto yy1921; + } else { + if (yych == '>') + goto yy1965; + goto yy1907; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') + goto yy1918; + if (yych <= 0x7F) + goto yy1907; + goto yy1843; + } else { + if (yych <= 0xDF) + goto yy1911; + if (yych <= 0xE0) + goto yy1912; + goto yy1913; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1917; + if (yych <= 0xEF) + goto yy1913; + goto yy1914; + } else { + if (yych <= 0xF3) + goto yy1915; + if (yych <= 0xF4) + goto yy1916; + goto yy1843; + } + } + } + yy1967: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1907; + goto yy1850; + yy1968: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1850; + if (yych <= 0xBF) + goto yy1967; + goto yy1850; + yy1969: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1967; + goto yy1850; + yy1970: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1850; + if (yych <= 0xBF) + goto yy1969; + goto yy1850; + yy1971: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0xBF) + goto yy1969; + goto yy1850; + yy1972: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x8F) + goto yy1969; + goto yy1850; + yy1973: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1850; + if (yych <= 0x9F) + goto yy1967; + goto yy1850; + } } // 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). -bufsize_t _scan_link_title(const unsigned char *p) -{ +bufsize_t _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, 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, 224, 224, 224, 224, 224, - 224, 224, 96, 224, 224, 224, 224, 160, - 224, 192, 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, 224, 224, 224, 224, - 224, 224, 224, 224, 224, 224, 224, 224, - 224, 224, 224, 224, 224, 224, 224, 224, - 224, 224, 224, 224, 16, 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, 224, - 224, 224, 224, 224, 224, 224, 224, 224, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 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 = *(marker = p); - if (yych <= 0xC1) { - if (yych <= '"') { - if (yych == '\n') goto yy1974; - if (yych <= '!') goto yy1978; - goto yy1975; - } else { - if (yych <= '\'') { - if (yych <= '&') goto yy1978; - goto yy1976; - } else { - if (yych <= '(') goto yy1977; - if (yych <= 0x7F) goto yy1978; - } - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy1979; - if (yych <= 0xE0) goto yy1981; - if (yych <= 0xEC) goto yy1982; - goto yy1986; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy1982; - goto yy1983; - } else { - if (yych <= 0xF3) goto yy1984; - if (yych <= 0xF4) goto yy1985; - } - } - } -yy1974: - { return 0; } -yy1975: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x00) goto yy1974; - if (yych <= 0x7F) goto yy2018; - if (yych <= 0xC1) goto yy1974; - if (yych <= 0xF4) goto yy2018; - goto yy1974; -yy1976: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x00) goto yy1974; - if (yych <= 0x7F) goto yy2004; - if (yych <= 0xC1) goto yy1974; - if (yych <= 0xF4) goto yy2004; - goto yy1974; -yy1977: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x00) goto yy1974; - if (yych <= 0x7F) goto yy1990; - if (yych <= 0xC1) goto yy1974; - if (yych <= 0xF4) goto yy1990; - goto yy1974; -yy1978: - yych = *++p; - goto yy1974; -yy1979: - yych = *++p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy1978; -yy1980: - p = marker; - if (yyaccept <= 1) { - if (yyaccept == 0) { - goto yy1974; - } else { - goto yy1999; - } - } else { - if (yyaccept == 2) { - goto yy2013; - } else { - goto yy2027; - } - } -yy1981: - yych = *++p; - if (yych <= 0x9F) goto yy1980; - if (yych <= 0xBF) goto yy1979; - goto yy1980; -yy1982: - yych = *++p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy1979; - goto yy1980; -yy1983: - yych = *++p; - if (yych <= 0x8F) goto yy1980; - if (yych <= 0xBF) goto yy1982; - goto yy1980; -yy1984: - yych = *++p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy1982; - goto yy1980; -yy1985: - yych = *++p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0x8F) goto yy1982; - goto yy1980; -yy1986: - yych = *++p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0x9F) goto yy1979; - goto yy1980; -yy1987: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1989; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= 0x00) goto yy1980; - if (yych <= ')') goto yy2000; - goto yy1987; - } else { - if (yych <= 0xC1) goto yy1980; - if (yych <= 0xDF) goto yy1991; - goto yy1992; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1997; - goto yy1993; - } else { - if (yych <= 0xF0) goto yy1994; - if (yych <= 0xF3) goto yy1995; - if (yych <= 0xF4) goto yy1996; - goto yy1980; - } - } -yy1989: - ++p; - yych = *p; -yy1990: - if (yybm[0+yych] & 32) { - goto yy1989; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= 0x00) goto yy1980; - if (yych <= ')') goto yy1998; - goto yy1987; - } else { - if (yych <= 0xC1) goto yy1980; - if (yych >= 0xE0) goto yy1992; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1997; - goto yy1993; - } else { - if (yych <= 0xF0) goto yy1994; - if (yych <= 0xF3) goto yy1995; - if (yych <= 0xF4) goto yy1996; - goto yy1980; - } - } -yy1991: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy1989; - goto yy1980; -yy1992: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1980; - if (yych <= 0xBF) goto yy1991; - goto yy1980; -yy1993: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy1991; - goto yy1980; -yy1994: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1980; - if (yych <= 0xBF) goto yy1993; - goto yy1980; -yy1995: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy1993; - goto yy1980; -yy1996: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0x8F) goto yy1993; - goto yy1980; -yy1997: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0x9F) goto yy1991; - goto yy1980; -yy1998: - ++p; -yy1999: - { return (bufsize_t)(p - start); } -yy2000: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy1989; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= 0x00) goto yy1999; - if (yych <= ')') goto yy1998; - goto yy1987; - } else { - if (yych <= 0xC1) goto yy1999; - if (yych <= 0xDF) goto yy1991; - goto yy1992; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy1997; - goto yy1993; - } else { - if (yych <= 0xF0) goto yy1994; - if (yych <= 0xF3) goto yy1995; - if (yych <= 0xF4) goto yy1996; - goto yy1999; - } - } -yy2001: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy2003; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= 0x00) goto yy1980; - if (yych <= '\'') goto yy2014; - goto yy2001; - } else { - if (yych <= 0xC1) goto yy1980; - if (yych <= 0xDF) goto yy2005; - goto yy2006; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy2011; - goto yy2007; - } else { - if (yych <= 0xF0) goto yy2008; - if (yych <= 0xF3) goto yy2009; - if (yych <= 0xF4) goto yy2010; - goto yy1980; - } - } -yy2003: - ++p; - yych = *p; -yy2004: - if (yybm[0+yych] & 64) { - goto yy2003; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= 0x00) goto yy1980; - if (yych <= '\'') goto yy2012; - goto yy2001; - } else { - if (yych <= 0xC1) goto yy1980; - if (yych >= 0xE0) goto yy2006; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy2011; - goto yy2007; - } else { - if (yych <= 0xF0) goto yy2008; - if (yych <= 0xF3) goto yy2009; - if (yych <= 0xF4) goto yy2010; - goto yy1980; - } - } -yy2005: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy2003; - goto yy1980; -yy2006: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1980; - if (yych <= 0xBF) goto yy2005; - goto yy1980; -yy2007: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy2005; - goto yy1980; -yy2008: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1980; - if (yych <= 0xBF) goto yy2007; - goto yy1980; -yy2009: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy2007; - goto yy1980; -yy2010: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0x8F) goto yy2007; - goto yy1980; -yy2011: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0x9F) goto yy2005; - goto yy1980; -yy2012: - ++p; -yy2013: - { return (bufsize_t)(p - start); } -yy2014: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy2003; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= 0x00) goto yy2013; - if (yych <= '\'') goto yy2012; - goto yy2001; - } else { - if (yych <= 0xC1) goto yy2013; - if (yych <= 0xDF) goto yy2005; - goto yy2006; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy2011; - goto yy2007; - } else { - if (yych <= 0xF0) goto yy2008; - if (yych <= 0xF3) goto yy2009; - if (yych <= 0xF4) goto yy2010; - goto yy2013; - } - } -yy2015: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy2017; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= 0x00) goto yy1980; - if (yych <= '"') goto yy2028; - goto yy2015; - } else { - if (yych <= 0xC1) goto yy1980; - if (yych <= 0xDF) goto yy2019; - goto yy2020; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy2025; - goto yy2021; - } else { - if (yych <= 0xF0) goto yy2022; - if (yych <= 0xF3) goto yy2023; - if (yych <= 0xF4) goto yy2024; - goto yy1980; - } - } -yy2017: - ++p; - yych = *p; -yy2018: - if (yybm[0+yych] & 128) { - goto yy2017; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= 0x00) goto yy1980; - if (yych <= '"') goto yy2026; - goto yy2015; - } else { - if (yych <= 0xC1) goto yy1980; - if (yych >= 0xE0) goto yy2020; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy2025; - goto yy2021; - } else { - if (yych <= 0xF0) goto yy2022; - if (yych <= 0xF3) goto yy2023; - if (yych <= 0xF4) goto yy2024; - goto yy1980; - } - } -yy2019: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy2017; - goto yy1980; -yy2020: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy1980; - if (yych <= 0xBF) goto yy2019; - goto yy1980; -yy2021: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy2019; - goto yy1980; -yy2022: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy1980; - if (yych <= 0xBF) goto yy2021; - goto yy1980; -yy2023: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0xBF) goto yy2021; - goto yy1980; -yy2024: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0x8F) goto yy2021; - goto yy1980; -yy2025: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy1980; - if (yych <= 0x9F) goto yy2019; - goto yy1980; -yy2026: - ++p; -yy2027: - { return (bufsize_t)(p - start); } -yy2028: - yyaccept = 3; - marker = ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy2017; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= 0x00) goto yy2027; - if (yych <= '"') goto yy2026; - goto yy2015; - } else { - if (yych <= 0xC1) goto yy2027; - if (yych <= 0xDF) goto yy2019; - goto yy2020; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy2025; - goto yy2021; - } else { - if (yych <= 0xF0) goto yy2022; - if (yych <= 0xF3) goto yy2023; - if (yych <= 0xF4) goto yy2024; - goto yy2027; - } - } -} - + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 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, 224, + 224, 224, 224, 224, 224, 224, 96, 224, 224, 224, 224, 160, 224, 192, + 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, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, 16, 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, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); + if (yych <= 0xC1) { + if (yych <= '"') { + if (yych == '\n') + goto yy1976; + if (yych <= '!') + goto yy1980; + goto yy1977; + } else { + if (yych <= '\'') { + if (yych <= '&') + goto yy1980; + goto yy1978; + } else { + if (yych <= '(') + goto yy1979; + if (yych <= 0x7F) + goto yy1980; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1981; + if (yych <= 0xE0) + goto yy1983; + if (yych <= 0xEC) + goto yy1984; + goto yy1988; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1984; + goto yy1985; + } else { + if (yych <= 0xF3) + goto yy1986; + if (yych <= 0xF4) + goto yy1987; + } + } + } + yy1976 : { return 0; } + yy1977: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy1976; + if (yych <= 0x7F) + goto yy2020; + if (yych <= 0xC1) + goto yy1976; + if (yych <= 0xF4) + goto yy2020; + goto yy1976; + yy1978: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy1976; + if (yych <= 0x7F) + goto yy2006; + if (yych <= 0xC1) + goto yy1976; + if (yych <= 0xF4) + goto yy2006; + goto yy1976; + yy1979: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy1976; + if (yych <= 0x7F) + goto yy1992; + if (yych <= 0xC1) + goto yy1976; + if (yych <= 0xF4) + goto yy1992; + goto yy1976; + yy1980: + yych = *++p; + goto yy1976; + yy1981: + yych = *++p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy1980; + yy1982: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy1976; + } else { + goto yy2001; + } + } else { + if (yyaccept == 2) { + goto yy2015; + } else { + goto yy2029; + } + } + yy1983: + yych = *++p; + if (yych <= 0x9F) + goto yy1982; + if (yych <= 0xBF) + goto yy1981; + goto yy1982; + yy1984: + yych = *++p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy1981; + goto yy1982; + yy1985: + yych = *++p; + if (yych <= 0x8F) + goto yy1982; + if (yych <= 0xBF) + goto yy1984; + goto yy1982; + yy1986: + yych = *++p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy1984; + goto yy1982; + yy1987: + yych = *++p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0x8F) + goto yy1984; + goto yy1982; + yy1988: + yych = *++p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0x9F) + goto yy1981; + goto yy1982; + yy1989: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy1991; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy1982; + if (yych <= ')') + goto yy2002; + goto yy1989; + } else { + if (yych <= 0xC1) + goto yy1982; + if (yych <= 0xDF) + goto yy1993; + goto yy1994; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1999; + goto yy1995; + } else { + if (yych <= 0xF0) + goto yy1996; + if (yych <= 0xF3) + goto yy1997; + if (yych <= 0xF4) + goto yy1998; + goto yy1982; + } + } + yy1991: + ++p; + yych = *p; + yy1992: + if (yybm[0 + yych] & 32) { + goto yy1991; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy1982; + if (yych <= ')') + goto yy2000; + goto yy1989; + } else { + if (yych <= 0xC1) + goto yy1982; + if (yych >= 0xE0) + goto yy1994; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1999; + goto yy1995; + } else { + if (yych <= 0xF0) + goto yy1996; + if (yych <= 0xF3) + goto yy1997; + if (yych <= 0xF4) + goto yy1998; + goto yy1982; + } + } + yy1993: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy1991; + goto yy1982; + yy1994: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1982; + if (yych <= 0xBF) + goto yy1993; + goto yy1982; + yy1995: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy1993; + goto yy1982; + yy1996: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1982; + if (yych <= 0xBF) + goto yy1995; + goto yy1982; + yy1997: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy1995; + goto yy1982; + yy1998: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0x8F) + goto yy1995; + goto yy1982; + yy1999: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0x9F) + goto yy1993; + goto yy1982; + yy2000: + ++p; + yy2001 : { return (bufsize_t)(p - start); } + yy2002: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy1991; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy2001; + if (yych <= ')') + goto yy2000; + goto yy1989; + } else { + if (yych <= 0xC1) + goto yy2001; + if (yych <= 0xDF) + goto yy1993; + goto yy1994; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1999; + goto yy1995; + } else { + if (yych <= 0xF0) + goto yy1996; + if (yych <= 0xF3) + goto yy1997; + if (yych <= 0xF4) + goto yy1998; + goto yy2001; + } + } + yy2003: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy2005; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy1982; + if (yych <= '\'') + goto yy2016; + goto yy2003; + } else { + if (yych <= 0xC1) + goto yy1982; + if (yych <= 0xDF) + goto yy2007; + goto yy2008; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy2013; + goto yy2009; + } else { + if (yych <= 0xF0) + goto yy2010; + if (yych <= 0xF3) + goto yy2011; + if (yych <= 0xF4) + goto yy2012; + goto yy1982; + } + } + yy2005: + ++p; + yych = *p; + yy2006: + if (yybm[0 + yych] & 64) { + goto yy2005; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy1982; + if (yych <= '\'') + goto yy2014; + goto yy2003; + } else { + if (yych <= 0xC1) + goto yy1982; + if (yych >= 0xE0) + goto yy2008; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy2013; + goto yy2009; + } else { + if (yych <= 0xF0) + goto yy2010; + if (yych <= 0xF3) + goto yy2011; + if (yych <= 0xF4) + goto yy2012; + goto yy1982; + } + } + yy2007: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy2005; + goto yy1982; + yy2008: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1982; + if (yych <= 0xBF) + goto yy2007; + goto yy1982; + yy2009: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy2007; + goto yy1982; + yy2010: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1982; + if (yych <= 0xBF) + goto yy2009; + goto yy1982; + yy2011: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy2009; + goto yy1982; + yy2012: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0x8F) + goto yy2009; + goto yy1982; + yy2013: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0x9F) + goto yy2007; + goto yy1982; + yy2014: + ++p; + yy2015 : { return (bufsize_t)(p - start); } + yy2016: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy2005; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy2015; + if (yych <= '\'') + goto yy2014; + goto yy2003; + } else { + if (yych <= 0xC1) + goto yy2015; + if (yych <= 0xDF) + goto yy2007; + goto yy2008; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy2013; + goto yy2009; + } else { + if (yych <= 0xF0) + goto yy2010; + if (yych <= 0xF3) + goto yy2011; + if (yych <= 0xF4) + goto yy2012; + goto yy2015; + } + } + yy2017: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy2019; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy1982; + if (yych <= '"') + goto yy2030; + goto yy2017; + } else { + if (yych <= 0xC1) + goto yy1982; + if (yych <= 0xDF) + goto yy2021; + goto yy2022; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy2027; + goto yy2023; + } else { + if (yych <= 0xF0) + goto yy2024; + if (yych <= 0xF3) + goto yy2025; + if (yych <= 0xF4) + goto yy2026; + goto yy1982; + } + } + yy2019: + ++p; + yych = *p; + yy2020: + if (yybm[0 + yych] & 128) { + goto yy2019; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy1982; + if (yych <= '"') + goto yy2028; + goto yy2017; + } else { + if (yych <= 0xC1) + goto yy1982; + if (yych >= 0xE0) + goto yy2022; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy2027; + goto yy2023; + } else { + if (yych <= 0xF0) + goto yy2024; + if (yych <= 0xF3) + goto yy2025; + if (yych <= 0xF4) + goto yy2026; + goto yy1982; + } + } + yy2021: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy2019; + goto yy1982; + yy2022: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy1982; + if (yych <= 0xBF) + goto yy2021; + goto yy1982; + yy2023: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy2021; + goto yy1982; + yy2024: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy1982; + if (yych <= 0xBF) + goto yy2023; + goto yy1982; + yy2025: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0xBF) + goto yy2023; + goto yy1982; + yy2026: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0x8F) + goto yy2023; + goto yy1982; + yy2027: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy1982; + if (yych <= 0x9F) + goto yy2021; + goto yy1982; + yy2028: + ++p; + yy2029 : { return (bufsize_t)(p - start); } + yy2030: + yyaccept = 3; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy2019; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy2029; + if (yych <= '"') + goto yy2028; + goto yy2017; + } else { + if (yych <= 0xC1) + goto yy2029; + if (yych <= 0xDF) + goto yy2021; + goto yy2022; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy2027; + goto yy2023; + } else { + if (yych <= 0xF0) + goto yy2024; + if (yych <= 0xF3) + goto yy2025; + if (yych <= 0xF4) + goto yy2026; + goto yy2029; + } + } + } } // Match space characters, including newlines. -bufsize_t _scan_spacechars(const unsigned char *p) -{ +bufsize_t _scan_spacechars(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, 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 = *(marker = p); - if (yych <= 0xC1) { - if (yych <= '\r') { - if (yych <= 0x08) goto yy2035; - if (yych == '\n') goto yy2033; - goto yy2032; - } else { - if (yych == ' ') goto yy2032; - if (yych <= 0x7F) goto yy2035; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy2037; - if (yych <= 0xE0) goto yy2039; - if (yych <= 0xEC) goto yy2040; - goto yy2044; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy2040; - goto yy2041; - } else { - if (yych <= 0xF3) goto yy2042; - if (yych <= 0xF4) goto yy2043; - } - } - } -yy2031: - { return (bufsize_t)(p - start); } -yy2032: - yych = *++p; - goto yy2034; -yy2033: - ++p; - yych = *p; -yy2034: - if (yybm[0+yych] & 128) { - goto yy2033; - } - goto yy2031; -yy2035: - ++p; - { return 0; } -yy2037: - yych = *++p; - if (yych <= 0x7F) goto yy2038; - if (yych <= 0xBF) goto yy2035; -yy2038: - p = marker; - goto yy2031; -yy2039: - yych = *++p; - if (yych <= 0x9F) goto yy2038; - if (yych <= 0xBF) goto yy2037; - goto yy2038; -yy2040: - yych = *++p; - if (yych <= 0x7F) goto yy2038; - if (yych <= 0xBF) goto yy2037; - goto yy2038; -yy2041: - yych = *++p; - if (yych <= 0x8F) goto yy2038; - if (yych <= 0xBF) goto yy2040; - goto yy2038; -yy2042: - yych = *++p; - if (yych <= 0x7F) goto yy2038; - if (yych <= 0xBF) goto yy2040; - goto yy2038; -yy2043: - yych = *++p; - if (yych <= 0x7F) goto yy2038; - if (yych <= 0x8F) goto yy2040; - goto yy2038; -yy2044: - ++p; - if ((yych = *p) <= 0x7F) goto yy2038; - if (yych <= 0x9F) goto yy2037; - goto yy2038; -} + 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 = *(marker = p); + if (yych <= 0xC1) { + if (yych <= '\r') { + if (yych <= 0x08) + goto yy2037; + if (yych == '\n') + goto yy2035; + goto yy2034; + } else { + if (yych == ' ') + goto yy2034; + if (yych <= 0x7F) + goto yy2037; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy2039; + if (yych <= 0xE0) + goto yy2041; + if (yych <= 0xEC) + goto yy2042; + goto yy2046; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy2042; + goto yy2043; + } else { + if (yych <= 0xF3) + goto yy2044; + if (yych <= 0xF4) + goto yy2045; + } + } + } + yy2033 : { return (bufsize_t)(p - start); } + yy2034: + yych = *++p; + goto yy2036; + yy2035: + ++p; + yych = *p; + yy2036: + if (yybm[0 + yych] & 128) { + goto yy2035; + } + goto yy2033; + yy2037: + ++p; + { return 0; } + yy2039: + yych = *++p; + if (yych <= 0x7F) + goto yy2040; + if (yych <= 0xBF) + goto yy2037; + yy2040: + p = marker; + goto yy2033; + yy2041: + yych = *++p; + if (yych <= 0x9F) + goto yy2040; + if (yych <= 0xBF) + goto yy2039; + goto yy2040; + yy2042: + yych = *++p; + if (yych <= 0x7F) + goto yy2040; + if (yych <= 0xBF) + goto yy2039; + goto yy2040; + yy2043: + yych = *++p; + if (yych <= 0x8F) + goto yy2040; + if (yych <= 0xBF) + goto yy2042; + goto yy2040; + yy2044: + yych = *++p; + if (yych <= 0x7F) + goto yy2040; + if (yych <= 0xBF) + goto yy2042; + goto yy2040; + yy2045: + yych = *++p; + if (yych <= 0x7F) + goto yy2040; + if (yych <= 0x8F) + goto yy2042; + goto yy2040; + yy2046: + ++p; + if ((yych = *p) <= 0x7F) + goto yy2040; + if (yych <= 0x9F) + goto yy2039; + goto yy2040; + } } // Match ATX header start. -bufsize_t _scan_atx_header_start(const unsigned char *p) -{ +bufsize_t _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 = *(marker = p); - if (yych <= 0xDF) { - if (yych <= '"') { - if (yych != '\n') goto yy2049; - } else { - if (yych <= '#') goto yy2048; - if (yych <= 0x7F) goto yy2049; - if (yych >= 0xC2) goto yy2050; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy2052; - if (yych == 0xED) goto yy2057; - goto yy2053; - } else { - if (yych <= 0xF0) goto yy2054; - if (yych <= 0xF3) goto yy2055; - if (yych <= 0xF4) goto yy2056; - } - } -yy2047: - { return 0; } -yy2048: - yych = *(marker = ++p); - if (yybm[0+yych] & 128) { - goto yy2060; - } - if (yych <= '\f') { - if (yych == '\n') goto yy2058; - goto yy2047; - } else { - if (yych <= '\r') goto yy2058; - if (yych == '#') goto yy2062; - goto yy2047; - } -yy2049: - yych = *++p; - goto yy2047; -yy2050: - yych = *++p; - if (yych <= 0x7F) goto yy2051; - if (yych <= 0xBF) goto yy2049; -yy2051: - p = marker; - goto yy2047; -yy2052: - yych = *++p; - if (yych <= 0x9F) goto yy2051; - if (yych <= 0xBF) goto yy2050; - goto yy2051; -yy2053: - yych = *++p; - if (yych <= 0x7F) goto yy2051; - if (yych <= 0xBF) goto yy2050; - goto yy2051; -yy2054: - yych = *++p; - if (yych <= 0x8F) goto yy2051; - if (yych <= 0xBF) goto yy2053; - goto yy2051; -yy2055: - yych = *++p; - if (yych <= 0x7F) goto yy2051; - if (yych <= 0xBF) goto yy2053; - goto yy2051; -yy2056: - yych = *++p; - if (yych <= 0x7F) goto yy2051; - if (yych <= 0x8F) goto yy2053; - goto yy2051; -yy2057: - yych = *++p; - if (yych <= 0x7F) goto yy2051; - if (yych <= 0x9F) goto yy2050; - goto yy2051; -yy2058: - ++p; -yy2059: - { return (bufsize_t)(p - start); } -yy2060: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy2060; - } - goto yy2059; -yy2062: - yych = *++p; - if (yybm[0+yych] & 128) { - goto yy2060; - } - if (yych <= '\f') { - if (yych == '\n') goto yy2058; - goto yy2051; - } else { - if (yych <= '\r') goto yy2058; - if (yych != '#') goto yy2051; - } - yych = *++p; - if (yybm[0+yych] & 128) { - goto yy2060; - } - if (yych <= '\f') { - if (yych == '\n') goto yy2058; - goto yy2051; - } else { - if (yych <= '\r') goto yy2058; - if (yych != '#') goto yy2051; - } - yych = *++p; - if (yybm[0+yych] & 128) { - goto yy2060; - } - if (yych <= '\f') { - if (yych == '\n') goto yy2058; - goto yy2051; - } else { - if (yych <= '\r') goto yy2058; - if (yych != '#') goto yy2051; - } - yych = *++p; - if (yybm[0+yych] & 128) { - goto yy2060; - } - if (yych <= '\f') { - if (yych == '\n') goto yy2058; - goto yy2051; - } else { - if (yych <= '\r') goto yy2058; - if (yych != '#') goto yy2051; - } - ++p; - if (yybm[0+(yych = *p)] & 128) { - goto yy2060; - } - if (yych == '\n') goto yy2058; - if (yych == '\r') goto yy2058; - goto yy2051; -} - + { + 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 = *(marker = p); + if (yych <= 0xDF) { + if (yych <= '"') { + if (yych != '\n') + goto yy2051; + } else { + if (yych <= '#') + goto yy2050; + if (yych <= 0x7F) + goto yy2051; + if (yych >= 0xC2) + goto yy2052; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy2054; + if (yych == 0xED) + goto yy2059; + goto yy2055; + } else { + if (yych <= 0xF0) + goto yy2056; + if (yych <= 0xF3) + goto yy2057; + if (yych <= 0xF4) + goto yy2058; + } + } + yy2049 : { return 0; } + yy2050: + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy2062; + } + if (yych <= '\f') { + if (yych == '\n') + goto yy2060; + goto yy2049; + } else { + if (yych <= '\r') + goto yy2060; + if (yych == '#') + goto yy2064; + goto yy2049; + } + yy2051: + yych = *++p; + goto yy2049; + yy2052: + yych = *++p; + if (yych <= 0x7F) + goto yy2053; + if (yych <= 0xBF) + goto yy2051; + yy2053: + p = marker; + goto yy2049; + yy2054: + yych = *++p; + if (yych <= 0x9F) + goto yy2053; + if (yych <= 0xBF) + goto yy2052; + goto yy2053; + yy2055: + yych = *++p; + if (yych <= 0x7F) + goto yy2053; + if (yych <= 0xBF) + goto yy2052; + goto yy2053; + yy2056: + yych = *++p; + if (yych <= 0x8F) + goto yy2053; + if (yych <= 0xBF) + goto yy2055; + goto yy2053; + yy2057: + yych = *++p; + if (yych <= 0x7F) + goto yy2053; + if (yych <= 0xBF) + goto yy2055; + goto yy2053; + yy2058: + yych = *++p; + if (yych <= 0x7F) + goto yy2053; + if (yych <= 0x8F) + goto yy2055; + goto yy2053; + yy2059: + yych = *++p; + if (yych <= 0x7F) + goto yy2053; + if (yych <= 0x9F) + goto yy2052; + goto yy2053; + yy2060: + ++p; + yy2061 : { return (bufsize_t)(p - start); } + yy2062: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy2062; + } + goto yy2061; + yy2064: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy2062; + } + if (yych <= '\f') { + if (yych == '\n') + goto yy2060; + goto yy2053; + } else { + if (yych <= '\r') + goto yy2060; + if (yych != '#') + goto yy2053; + } + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy2062; + } + if (yych <= '\f') { + if (yych == '\n') + goto yy2060; + goto yy2053; + } else { + if (yych <= '\r') + goto yy2060; + if (yych != '#') + goto yy2053; + } + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy2062; + } + if (yych <= '\f') { + if (yych == '\n') + goto yy2060; + goto yy2053; + } else { + if (yych <= '\r') + goto yy2060; + if (yych != '#') + goto yy2053; + } + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy2062; + } + if (yych <= '\f') { + if (yych == '\n') + goto yy2060; + goto yy2053; + } else { + if (yych <= '\r') + goto yy2060; + if (yych != '#') + goto yy2053; + } + ++p; + if (yybm[0 + (yych = *p)] & 128) { + goto yy2062; + } + if (yych == '\n') + goto yy2060; + if (yych == '\r') + goto yy2060; + goto yy2053; + } } // Match setext header line. Return 1 for level-1 header, // 2 for level-2, 0 for no match. -bufsize_t _scan_setext_header_line(const unsigned char *p) -{ +bufsize_t _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 = *(marker = p); - if (yych <= 0xC1) { - if (yych <= '-') { - if (yych == '\n') goto yy2069; - if (yych <= ',') goto yy2072; - goto yy2071; - } else { - if (yych == '=') goto yy2070; - if (yych <= 0x7F) goto yy2072; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy2073; - if (yych <= 0xE0) goto yy2075; - if (yych <= 0xEC) goto yy2076; - goto yy2080; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy2076; - goto yy2077; - } else { - if (yych <= 0xF3) goto yy2078; - if (yych <= 0xF4) goto yy2079; - } - } - } -yy2069: - { return 0; } -yy2070: - yych = *(marker = ++p); - if (yybm[0+yych] & 128) { - goto yy2091; - } - if (yych <= '\f') { - if (yych == '\n') goto yy2089; - goto yy2069; - } else { - if (yych <= '\r') goto yy2089; - if (yych == ' ') goto yy2087; - goto yy2069; - } -yy2071: - yych = *(marker = ++p); - if (yybm[0+yych] & 32) { - goto yy2081; - } - if (yych <= '\f') { - if (yych == '\n') goto yy2083; - goto yy2069; - } else { - if (yych <= '\r') goto yy2083; - if (yych == '-') goto yy2085; - goto yy2069; - } -yy2072: - yych = *++p; - goto yy2069; -yy2073: - yych = *++p; - if (yych <= 0x7F) goto yy2074; - if (yych <= 0xBF) goto yy2072; -yy2074: - p = marker; - goto yy2069; -yy2075: - yych = *++p; - if (yych <= 0x9F) goto yy2074; - if (yych <= 0xBF) goto yy2073; - goto yy2074; -yy2076: - yych = *++p; - if (yych <= 0x7F) goto yy2074; - if (yych <= 0xBF) goto yy2073; - goto yy2074; -yy2077: - yych = *++p; - if (yych <= 0x8F) goto yy2074; - if (yych <= 0xBF) goto yy2076; - goto yy2074; -yy2078: - yych = *++p; - if (yych <= 0x7F) goto yy2074; - if (yych <= 0xBF) goto yy2076; - goto yy2074; -yy2079: - yych = *++p; - if (yych <= 0x7F) goto yy2074; - if (yych <= 0x8F) goto yy2076; - goto yy2074; -yy2080: - yych = *++p; - if (yych <= 0x7F) goto yy2074; - if (yych <= 0x9F) goto yy2073; - goto yy2074; -yy2081: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy2081; - } - if (yych == '\n') goto yy2083; - if (yych != '\r') goto yy2074; -yy2083: - ++p; - { return 2; } -yy2085: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy2081; - } - if (yych <= '\f') { - if (yych == '\n') goto yy2083; - goto yy2074; - } else { - if (yych <= '\r') goto yy2083; - if (yych == '-') goto yy2085; - goto yy2074; - } -yy2087: - ++p; - yych = *p; - if (yych <= '\f') { - if (yych != '\n') goto yy2074; - } else { - if (yych <= '\r') goto yy2089; - if (yych == ' ') goto yy2087; - goto yy2074; - } -yy2089: - ++p; - { return 1; } -yy2091: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy2091; - } - if (yych <= '\f') { - if (yych == '\n') goto yy2089; - goto yy2074; - } else { - if (yych <= '\r') goto yy2089; - if (yych == ' ') goto yy2087; - goto yy2074; - } -} - + { + 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 = *(marker = p); + if (yych <= 0xC1) { + if (yych <= '-') { + if (yych == '\n') + goto yy2071; + if (yych <= ',') + goto yy2074; + goto yy2073; + } else { + if (yych == '=') + goto yy2072; + if (yych <= 0x7F) + goto yy2074; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy2075; + if (yych <= 0xE0) + goto yy2077; + if (yych <= 0xEC) + goto yy2078; + goto yy2082; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy2078; + goto yy2079; + } else { + if (yych <= 0xF3) + goto yy2080; + if (yych <= 0xF4) + goto yy2081; + } + } + } + yy2071 : { return 0; } + yy2072: + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy2093; + } + if (yych <= '\f') { + if (yych == '\n') + goto yy2091; + goto yy2071; + } else { + if (yych <= '\r') + goto yy2091; + if (yych == ' ') + goto yy2089; + goto yy2071; + } + yy2073: + yych = *(marker = ++p); + if (yybm[0 + yych] & 32) { + goto yy2083; + } + if (yych <= '\f') { + if (yych == '\n') + goto yy2085; + goto yy2071; + } else { + if (yych <= '\r') + goto yy2085; + if (yych == '-') + goto yy2087; + goto yy2071; + } + yy2074: + yych = *++p; + goto yy2071; + yy2075: + yych = *++p; + if (yych <= 0x7F) + goto yy2076; + if (yych <= 0xBF) + goto yy2074; + yy2076: + p = marker; + goto yy2071; + yy2077: + yych = *++p; + if (yych <= 0x9F) + goto yy2076; + if (yych <= 0xBF) + goto yy2075; + goto yy2076; + yy2078: + yych = *++p; + if (yych <= 0x7F) + goto yy2076; + if (yych <= 0xBF) + goto yy2075; + goto yy2076; + yy2079: + yych = *++p; + if (yych <= 0x8F) + goto yy2076; + if (yych <= 0xBF) + goto yy2078; + goto yy2076; + yy2080: + yych = *++p; + if (yych <= 0x7F) + goto yy2076; + if (yych <= 0xBF) + goto yy2078; + goto yy2076; + yy2081: + yych = *++p; + if (yych <= 0x7F) + goto yy2076; + if (yych <= 0x8F) + goto yy2078; + goto yy2076; + yy2082: + yych = *++p; + if (yych <= 0x7F) + goto yy2076; + if (yych <= 0x9F) + goto yy2075; + goto yy2076; + yy2083: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy2083; + } + if (yych == '\n') + goto yy2085; + if (yych != '\r') + goto yy2076; + yy2085: + ++p; + { return 2; } + yy2087: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy2083; + } + if (yych <= '\f') { + if (yych == '\n') + goto yy2085; + goto yy2076; + } else { + if (yych <= '\r') + goto yy2085; + if (yych == '-') + goto yy2087; + goto yy2076; + } + yy2089: + ++p; + yych = *p; + if (yych <= '\f') { + if (yych != '\n') + goto yy2076; + } else { + if (yych <= '\r') + goto yy2091; + if (yych == ' ') + goto yy2089; + goto yy2076; + } + yy2091: + ++p; + { return 1; } + yy2093: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy2093; + } + if (yych <= '\f') { + if (yych == '\n') + goto yy2091; + goto yy2076; + } else { + if (yych <= '\r') + goto yy2091; + if (yych == ' ') + goto yy2089; + goto yy2076; + } + } } // 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." -bufsize_t _scan_hrule(const unsigned char *p) -{ +bufsize_t _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 = *(marker = p); - if (yych <= 0x7F) { - if (yych <= '*') { - if (yych == '\n') goto yy2095; - if (yych <= ')') goto yy2099; - goto yy2096; - } else { - if (yych <= '-') { - if (yych <= ',') goto yy2099; - goto yy2098; - } else { - if (yych == '_') goto yy2097; - goto yy2099; - } - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) { - if (yych >= 0xC2) goto yy2100; - } else { - if (yych <= 0xE0) goto yy2102; - if (yych <= 0xEC) goto yy2103; - goto yy2107; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy2103; - goto yy2104; - } else { - if (yych <= 0xF3) goto yy2105; - if (yych <= 0xF4) goto yy2106; - } - } - } -yy2095: - { return 0; } -yy2096: - yych = *(marker = ++p); - if (yych == ' ') goto yy2128; - if (yych == '*') goto yy2130; - goto yy2095; -yy2097: - yych = *(marker = ++p); - if (yych == ' ') goto yy2118; - if (yych == '_') goto yy2120; - goto yy2095; -yy2098: - yych = *(marker = ++p); - if (yybm[0+yych] & 8) { - goto yy2108; - } - if (yych == '-') goto yy2110; - goto yy2095; -yy2099: - yych = *++p; - goto yy2095; -yy2100: - yych = *++p; - if (yych <= 0x7F) goto yy2101; - if (yych <= 0xBF) goto yy2099; -yy2101: - p = marker; - goto yy2095; -yy2102: - yych = *++p; - if (yych <= 0x9F) goto yy2101; - if (yych <= 0xBF) goto yy2100; - goto yy2101; -yy2103: - yych = *++p; - if (yych <= 0x7F) goto yy2101; - if (yych <= 0xBF) goto yy2100; - goto yy2101; -yy2104: - yych = *++p; - if (yych <= 0x8F) goto yy2101; - if (yych <= 0xBF) goto yy2103; - goto yy2101; -yy2105: - yych = *++p; - if (yych <= 0x7F) goto yy2101; - if (yych <= 0xBF) goto yy2103; - goto yy2101; -yy2106: - yych = *++p; - if (yych <= 0x7F) goto yy2101; - if (yych <= 0x8F) goto yy2103; - goto yy2101; -yy2107: - yych = *++p; - if (yych <= 0x7F) goto yy2101; - if (yych <= 0x9F) goto yy2100; - goto yy2101; -yy2108: - ++p; - yych = *p; - if (yybm[0+yych] & 8) { - goto yy2108; - } - if (yych != '-') goto yy2101; -yy2110: - ++p; - yych = *p; - if (yych == ' ') goto yy2110; - if (yych != '-') goto yy2101; -yy2112: - ++p; - yych = *p; - if (yybm[0+yych] & 16) { - goto yy2112; - } - if (yych <= '\n') { - if (yych <= 0x08) goto yy2101; - if (yych >= '\n') goto yy2116; - } else { - if (yych == '\r') goto yy2116; - goto yy2101; - } -yy2114: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy2114; - } - if (yych <= 0x08) goto yy2101; - if (yych <= '\n') goto yy2116; - if (yych != '\r') goto yy2101; -yy2116: - ++p; - { return (bufsize_t)(p - start); } -yy2118: - ++p; - yych = *p; - if (yych == ' ') goto yy2118; - if (yych != '_') goto yy2101; -yy2120: - ++p; - yych = *p; - if (yych == ' ') goto yy2120; - if (yych != '_') goto yy2101; -yy2122: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy2122; - } - if (yych <= '\n') { - if (yych <= 0x08) goto yy2101; - if (yych >= '\n') goto yy2126; - } else { - if (yych == '\r') goto yy2126; - goto yy2101; - } -yy2124: - ++p; - yych = *p; - if (yych <= '\f') { - if (yych <= 0x08) goto yy2101; - if (yych <= '\t') goto yy2124; - if (yych >= '\v') goto yy2101; - } else { - if (yych <= '\r') goto yy2126; - if (yych == ' ') goto yy2124; - goto yy2101; - } -yy2126: - ++p; - { return (bufsize_t)(p - start); } -yy2128: - ++p; - yych = *p; - if (yych == ' ') goto yy2128; - if (yych != '*') goto yy2101; -yy2130: - ++p; - yych = *p; - if (yych == ' ') goto yy2130; - if (yych != '*') goto yy2101; -yy2132: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy2132; - } - if (yych <= '\n') { - if (yych <= 0x08) goto yy2101; - if (yych >= '\n') goto yy2136; - } else { - if (yych == '\r') goto yy2136; - goto yy2101; - } -yy2134: - ++p; - yych = *p; - if (yych <= '\f') { - if (yych <= 0x08) goto yy2101; - if (yych <= '\t') goto yy2134; - if (yych >= '\v') goto yy2101; - } else { - if (yych <= '\r') goto yy2136; - if (yych == ' ') goto yy2134; - goto yy2101; - } -yy2136: - ++p; - { return (bufsize_t)(p - start); } -} - + { + 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 = *(marker = p); + if (yych <= 0x7F) { + if (yych <= '*') { + if (yych == '\n') + goto yy2097; + if (yych <= ')') + goto yy2101; + goto yy2098; + } else { + if (yych <= '-') { + if (yych <= ',') + goto yy2101; + goto yy2100; + } else { + if (yych == '_') + goto yy2099; + goto yy2101; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) { + if (yych >= 0xC2) + goto yy2102; + } else { + if (yych <= 0xE0) + goto yy2104; + if (yych <= 0xEC) + goto yy2105; + goto yy2109; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy2105; + goto yy2106; + } else { + if (yych <= 0xF3) + goto yy2107; + if (yych <= 0xF4) + goto yy2108; + } + } + } + yy2097 : { return 0; } + yy2098: + yych = *(marker = ++p); + if (yych == ' ') + goto yy2130; + if (yych == '*') + goto yy2132; + goto yy2097; + yy2099: + yych = *(marker = ++p); + if (yych == ' ') + goto yy2120; + if (yych == '_') + goto yy2122; + goto yy2097; + yy2100: + yych = *(marker = ++p); + if (yybm[0 + yych] & 8) { + goto yy2110; + } + if (yych == '-') + goto yy2112; + goto yy2097; + yy2101: + yych = *++p; + goto yy2097; + yy2102: + yych = *++p; + if (yych <= 0x7F) + goto yy2103; + if (yych <= 0xBF) + goto yy2101; + yy2103: + p = marker; + goto yy2097; + yy2104: + yych = *++p; + if (yych <= 0x9F) + goto yy2103; + if (yych <= 0xBF) + goto yy2102; + goto yy2103; + yy2105: + yych = *++p; + if (yych <= 0x7F) + goto yy2103; + if (yych <= 0xBF) + goto yy2102; + goto yy2103; + yy2106: + yych = *++p; + if (yych <= 0x8F) + goto yy2103; + if (yych <= 0xBF) + goto yy2105; + goto yy2103; + yy2107: + yych = *++p; + if (yych <= 0x7F) + goto yy2103; + if (yych <= 0xBF) + goto yy2105; + goto yy2103; + yy2108: + yych = *++p; + if (yych <= 0x7F) + goto yy2103; + if (yych <= 0x8F) + goto yy2105; + goto yy2103; + yy2109: + yych = *++p; + if (yych <= 0x7F) + goto yy2103; + if (yych <= 0x9F) + goto yy2102; + goto yy2103; + yy2110: + ++p; + yych = *p; + if (yybm[0 + yych] & 8) { + goto yy2110; + } + if (yych != '-') + goto yy2103; + yy2112: + ++p; + yych = *p; + if (yych == ' ') + goto yy2112; + if (yych != '-') + goto yy2103; + yy2114: + ++p; + yych = *p; + if (yybm[0 + yych] & 16) { + goto yy2114; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy2103; + if (yych >= '\n') + goto yy2118; + } else { + if (yych == '\r') + goto yy2118; + goto yy2103; + } + yy2116: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy2116; + } + if (yych <= 0x08) + goto yy2103; + if (yych <= '\n') + goto yy2118; + if (yych != '\r') + goto yy2103; + yy2118: + ++p; + { return (bufsize_t)(p - start); } + yy2120: + ++p; + yych = *p; + if (yych == ' ') + goto yy2120; + if (yych != '_') + goto yy2103; + yy2122: + ++p; + yych = *p; + if (yych == ' ') + goto yy2122; + if (yych != '_') + goto yy2103; + yy2124: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy2124; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy2103; + if (yych >= '\n') + goto yy2128; + } else { + if (yych == '\r') + goto yy2128; + goto yy2103; + } + yy2126: + ++p; + yych = *p; + if (yych <= '\f') { + if (yych <= 0x08) + goto yy2103; + if (yych <= '\t') + goto yy2126; + if (yych >= '\v') + goto yy2103; + } else { + if (yych <= '\r') + goto yy2128; + if (yych == ' ') + goto yy2126; + goto yy2103; + } + yy2128: + ++p; + { return (bufsize_t)(p - start); } + yy2130: + ++p; + yych = *p; + if (yych == ' ') + goto yy2130; + if (yych != '*') + goto yy2103; + yy2132: + ++p; + yych = *p; + if (yych == ' ') + goto yy2132; + if (yych != '*') + goto yy2103; + yy2134: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy2134; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy2103; + if (yych >= '\n') + goto yy2138; + } else { + if (yych == '\r') + goto yy2138; + goto yy2103; + } + yy2136: + ++p; + yych = *p; + if (yych <= '\f') { + if (yych <= 0x08) + goto yy2103; + if (yych <= '\t') + goto yy2136; + if (yych >= '\v') + goto yy2103; + } else { + if (yych <= '\r') + goto yy2138; + if (yych == ' ') + goto yy2136; + goto yy2103; + } + yy2138: + ++p; + { return (bufsize_t)(p - start); } + } } // Scan an opening code fence. -bufsize_t _scan_open_code_fence(const unsigned char *p) -{ +bufsize_t _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, 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, - 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, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 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 = *(marker = p); - if (yych <= 0xC1) { - if (yych <= '`') { - if (yych == '\n') goto yy2140; - if (yych <= '_') goto yy2143; - goto yy2141; - } else { - if (yych == '~') goto yy2142; - if (yych <= 0x7F) goto yy2143; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy2144; - if (yych <= 0xE0) goto yy2146; - if (yych <= 0xEC) goto yy2147; - goto yy2151; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy2147; - goto yy2148; - } else { - if (yych <= 0xF3) goto yy2149; - if (yych <= 0xF4) goto yy2150; - } - } - } -yy2140: - { return 0; } -yy2141: - yych = *(marker = ++p); - if (yych == '`') goto yy2166; - goto yy2140; -yy2142: - yych = *(marker = ++p); - if (yych == '~') goto yy2152; - goto yy2140; -yy2143: - yych = *++p; - goto yy2140; -yy2144: - yych = *++p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0xBF) goto yy2143; -yy2145: - p = marker; - goto yy2140; -yy2146: - yych = *++p; - if (yych <= 0x9F) goto yy2145; - if (yych <= 0xBF) goto yy2144; - goto yy2145; -yy2147: - yych = *++p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0xBF) goto yy2144; - goto yy2145; -yy2148: - yych = *++p; - if (yych <= 0x8F) goto yy2145; - if (yych <= 0xBF) goto yy2147; - goto yy2145; -yy2149: - yych = *++p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0xBF) goto yy2147; - goto yy2145; -yy2150: - yych = *++p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0x8F) goto yy2147; - goto yy2145; -yy2151: - yych = *++p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0x9F) goto yy2144; - goto yy2145; -yy2152: - yych = *++p; - if (yybm[0+yych] & 16) { - goto yy2153; - } - goto yy2145; -yy2153: - marker = p + 1; - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy2155; - } - if (yych <= 0xE0) { - if (yych <= '~') { - if (yych <= 0x00) goto yy2145; - if (yych <= '\r') goto yy2164; - goto yy2153; - } else { - if (yych <= 0xC1) goto yy2145; - if (yych <= 0xDF) goto yy2157; - goto yy2158; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy2163; - goto yy2159; - } else { - if (yych <= 0xF0) goto yy2160; - if (yych <= 0xF3) goto yy2161; - if (yych <= 0xF4) goto yy2162; - goto yy2145; - } - } -yy2155: - ++p; - yych = *p; - if (yybm[0+yych] & 32) { - goto yy2155; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy2145; - if (yych <= '\r') goto yy2164; - goto yy2145; - } else { - if (yych <= 0xDF) goto yy2157; - if (yych <= 0xE0) goto yy2158; - goto yy2159; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy2163; - if (yych <= 0xEF) goto yy2159; - goto yy2160; - } else { - if (yych <= 0xF3) goto yy2161; - if (yych <= 0xF4) goto yy2162; - goto yy2145; - } - } -yy2157: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0xBF) goto yy2155; - goto yy2145; -yy2158: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy2145; - if (yych <= 0xBF) goto yy2157; - goto yy2145; -yy2159: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0xBF) goto yy2157; - goto yy2145; -yy2160: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy2145; - if (yych <= 0xBF) goto yy2159; - goto yy2145; -yy2161: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0xBF) goto yy2159; - goto yy2145; -yy2162: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0x8F) goto yy2159; - goto yy2145; -yy2163: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0x9F) goto yy2157; - goto yy2145; -yy2164: - ++p; - p = marker; - { return (bufsize_t)(p - start); } -yy2166: - yych = *++p; - if (yybm[0+yych] & 64) { - goto yy2167; - } - goto yy2145; -yy2167: - marker = p + 1; - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy2169; - } - if (yych <= 0xE0) { - if (yych <= '`') { - if (yych <= 0x00) goto yy2145; - if (yych <= '\r') goto yy2178; - goto yy2167; - } else { - if (yych <= 0xC1) goto yy2145; - if (yych <= 0xDF) goto yy2171; - goto yy2172; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) goto yy2177; - goto yy2173; - } else { - if (yych <= 0xF0) goto yy2174; - if (yych <= 0xF3) goto yy2175; - if (yych <= 0xF4) goto yy2176; - goto yy2145; - } - } -yy2169: - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy2169; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) goto yy2145; - if (yych <= '\r') goto yy2178; - goto yy2145; - } else { - if (yych <= 0xDF) goto yy2171; - if (yych <= 0xE0) goto yy2172; - goto yy2173; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) goto yy2177; - if (yych <= 0xEF) goto yy2173; - goto yy2174; - } else { - if (yych <= 0xF3) goto yy2175; - if (yych <= 0xF4) goto yy2176; - goto yy2145; - } - } -yy2171: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0xBF) goto yy2169; - goto yy2145; -yy2172: - ++p; - yych = *p; - if (yych <= 0x9F) goto yy2145; - if (yych <= 0xBF) goto yy2171; - goto yy2145; -yy2173: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0xBF) goto yy2171; - goto yy2145; -yy2174: - ++p; - yych = *p; - if (yych <= 0x8F) goto yy2145; - if (yych <= 0xBF) goto yy2173; - goto yy2145; -yy2175: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0xBF) goto yy2173; - goto yy2145; -yy2176: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0x8F) goto yy2173; - goto yy2145; -yy2177: - ++p; - yych = *p; - if (yych <= 0x7F) goto yy2145; - if (yych <= 0x9F) goto yy2171; - goto yy2145; -yy2178: - ++p; - p = marker; - { return (bufsize_t)(p - start); } -} - + { + unsigned char yych; + static const unsigned char yybm[] = { + 0, 160, 160, 160, 160, 160, 160, 160, 160, 160, 0, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); + if (yych <= 0xC1) { + if (yych <= '`') { + if (yych == '\n') + goto yy2142; + if (yych <= '_') + goto yy2145; + goto yy2143; + } else { + if (yych == '~') + goto yy2144; + if (yych <= 0x7F) + goto yy2145; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy2146; + if (yych <= 0xE0) + goto yy2148; + if (yych <= 0xEC) + goto yy2149; + goto yy2153; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy2149; + goto yy2150; + } else { + if (yych <= 0xF3) + goto yy2151; + if (yych <= 0xF4) + goto yy2152; + } + } + } + yy2142 : { return 0; } + yy2143: + yych = *(marker = ++p); + if (yych == '`') + goto yy2168; + goto yy2142; + yy2144: + yych = *(marker = ++p); + if (yych == '~') + goto yy2154; + goto yy2142; + yy2145: + yych = *++p; + goto yy2142; + yy2146: + yych = *++p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0xBF) + goto yy2145; + yy2147: + p = marker; + goto yy2142; + yy2148: + yych = *++p; + if (yych <= 0x9F) + goto yy2147; + if (yych <= 0xBF) + goto yy2146; + goto yy2147; + yy2149: + yych = *++p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0xBF) + goto yy2146; + goto yy2147; + yy2150: + yych = *++p; + if (yych <= 0x8F) + goto yy2147; + if (yych <= 0xBF) + goto yy2149; + goto yy2147; + yy2151: + yych = *++p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0xBF) + goto yy2149; + goto yy2147; + yy2152: + yych = *++p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0x8F) + goto yy2149; + goto yy2147; + yy2153: + yych = *++p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0x9F) + goto yy2146; + goto yy2147; + yy2154: + yych = *++p; + if (yybm[0 + yych] & 16) { + goto yy2155; + } + goto yy2147; + yy2155: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy2157; + } + if (yych <= 0xE0) { + if (yych <= '~') { + if (yych <= 0x00) + goto yy2147; + if (yych <= '\r') + goto yy2166; + goto yy2155; + } else { + if (yych <= 0xC1) + goto yy2147; + if (yych <= 0xDF) + goto yy2159; + goto yy2160; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy2165; + goto yy2161; + } else { + if (yych <= 0xF0) + goto yy2162; + if (yych <= 0xF3) + goto yy2163; + if (yych <= 0xF4) + goto yy2164; + goto yy2147; + } + } + yy2157: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy2157; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy2147; + if (yych <= '\r') + goto yy2166; + goto yy2147; + } else { + if (yych <= 0xDF) + goto yy2159; + if (yych <= 0xE0) + goto yy2160; + goto yy2161; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy2165; + if (yych <= 0xEF) + goto yy2161; + goto yy2162; + } else { + if (yych <= 0xF3) + goto yy2163; + if (yych <= 0xF4) + goto yy2164; + goto yy2147; + } + } + yy2159: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0xBF) + goto yy2157; + goto yy2147; + yy2160: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy2147; + if (yych <= 0xBF) + goto yy2159; + goto yy2147; + yy2161: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0xBF) + goto yy2159; + goto yy2147; + yy2162: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy2147; + if (yych <= 0xBF) + goto yy2161; + goto yy2147; + yy2163: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0xBF) + goto yy2161; + goto yy2147; + yy2164: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0x8F) + goto yy2161; + goto yy2147; + yy2165: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0x9F) + goto yy2159; + goto yy2147; + yy2166: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + yy2168: + yych = *++p; + if (yybm[0 + yych] & 64) { + goto yy2169; + } + goto yy2147; + yy2169: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy2171; + } + if (yych <= 0xE0) { + if (yych <= '`') { + if (yych <= 0x00) + goto yy2147; + if (yych <= '\r') + goto yy2180; + goto yy2169; + } else { + if (yych <= 0xC1) + goto yy2147; + if (yych <= 0xDF) + goto yy2173; + goto yy2174; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy2179; + goto yy2175; + } else { + if (yych <= 0xF0) + goto yy2176; + if (yych <= 0xF3) + goto yy2177; + if (yych <= 0xF4) + goto yy2178; + goto yy2147; + } + } + yy2171: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy2171; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy2147; + if (yych <= '\r') + goto yy2180; + goto yy2147; + } else { + if (yych <= 0xDF) + goto yy2173; + if (yych <= 0xE0) + goto yy2174; + goto yy2175; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy2179; + if (yych <= 0xEF) + goto yy2175; + goto yy2176; + } else { + if (yych <= 0xF3) + goto yy2177; + if (yych <= 0xF4) + goto yy2178; + goto yy2147; + } + } + yy2173: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0xBF) + goto yy2171; + goto yy2147; + yy2174: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy2147; + if (yych <= 0xBF) + goto yy2173; + goto yy2147; + yy2175: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0xBF) + goto yy2173; + goto yy2147; + yy2176: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy2147; + if (yych <= 0xBF) + goto yy2175; + goto yy2147; + yy2177: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0xBF) + goto yy2175; + goto yy2147; + yy2178: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0x8F) + goto yy2175; + goto yy2147; + yy2179: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy2147; + if (yych <= 0x9F) + goto yy2173; + goto yy2147; + yy2180: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + } } // Scan a closing code fence with length at least len. -bufsize_t _scan_close_code_fence(const unsigned char *p) -{ +bufsize_t _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 = *(marker = p); - if (yych <= 0xC1) { - if (yych <= '`') { - if (yych == '\n') goto yy2182; - if (yych <= '_') goto yy2185; - goto yy2183; - } else { - if (yych == '~') goto yy2184; - if (yych <= 0x7F) goto yy2185; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) goto yy2186; - if (yych <= 0xE0) goto yy2188; - if (yych <= 0xEC) goto yy2189; - goto yy2193; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) goto yy2189; - goto yy2190; - } else { - if (yych <= 0xF3) goto yy2191; - if (yych <= 0xF4) goto yy2192; - } - } - } -yy2182: - { return 0; } -yy2183: - yych = *(marker = ++p); - if (yych == '`') goto yy2201; - goto yy2182; -yy2184: - yych = *(marker = ++p); - if (yych == '~') goto yy2194; - goto yy2182; -yy2185: - yych = *++p; - goto yy2182; -yy2186: - yych = *++p; - if (yych <= 0x7F) goto yy2187; - if (yych <= 0xBF) goto yy2185; -yy2187: - p = marker; - goto yy2182; -yy2188: - yych = *++p; - if (yych <= 0x9F) goto yy2187; - if (yych <= 0xBF) goto yy2186; - goto yy2187; -yy2189: - yych = *++p; - if (yych <= 0x7F) goto yy2187; - if (yych <= 0xBF) goto yy2186; - goto yy2187; -yy2190: - yych = *++p; - if (yych <= 0x8F) goto yy2187; - if (yych <= 0xBF) goto yy2189; - goto yy2187; -yy2191: - yych = *++p; - if (yych <= 0x7F) goto yy2187; - if (yych <= 0xBF) goto yy2189; - goto yy2187; -yy2192: - yych = *++p; - if (yych <= 0x7F) goto yy2187; - if (yych <= 0x8F) goto yy2189; - goto yy2187; -yy2193: - yych = *++p; - if (yych <= 0x7F) goto yy2187; - if (yych <= 0x9F) goto yy2186; - goto yy2187; -yy2194: - yych = *++p; - if (yybm[0+yych] & 32) { - goto yy2195; - } - goto yy2187; -yy2195: - marker = p + 1; - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy2197; - } - if (yych <= '\f') { - if (yych <= 0x08) goto yy2187; - if (yych <= '\n') goto yy2199; - goto yy2187; - } else { - if (yych <= '\r') goto yy2199; - if (yych == '~') goto yy2195; - goto yy2187; - } -yy2197: - ++p; - yych = *p; - if (yybm[0+yych] & 64) { - goto yy2197; - } - if (yych <= 0x08) goto yy2187; - if (yych <= '\n') goto yy2199; - if (yych != '\r') goto yy2187; -yy2199: - ++p; - p = marker; - { return (bufsize_t)(p - start); } -yy2201: - yych = *++p; - if (yybm[0+yych] & 128) { - goto yy2202; - } - goto yy2187; -yy2202: - marker = p + 1; - ++p; - yych = *p; - if (yybm[0+yych] & 128) { - goto yy2202; - } - if (yych <= '\f') { - if (yych <= 0x08) goto yy2187; - if (yych <= '\t') goto yy2204; - if (yych <= '\n') goto yy2206; - goto yy2187; - } else { - if (yych <= '\r') goto yy2206; - if (yych != ' ') goto yy2187; - } -yy2204: - ++p; - yych = *p; - if (yych <= '\f') { - if (yych <= 0x08) goto yy2187; - if (yych <= '\t') goto yy2204; - if (yych >= '\v') goto yy2187; - } else { - if (yych <= '\r') goto yy2206; - if (yych == ' ') goto yy2204; - goto yy2187; - } -yy2206: - ++p; - p = marker; - { return (bufsize_t)(p - start); } -} - + { + 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 = *(marker = p); + if (yych <= 0xC1) { + if (yych <= '`') { + if (yych == '\n') + goto yy2184; + if (yych <= '_') + goto yy2187; + goto yy2185; + } else { + if (yych == '~') + goto yy2186; + if (yych <= 0x7F) + goto yy2187; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy2188; + if (yych <= 0xE0) + goto yy2190; + if (yych <= 0xEC) + goto yy2191; + goto yy2195; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy2191; + goto yy2192; + } else { + if (yych <= 0xF3) + goto yy2193; + if (yych <= 0xF4) + goto yy2194; + } + } + } + yy2184 : { return 0; } + yy2185: + yych = *(marker = ++p); + if (yych == '`') + goto yy2203; + goto yy2184; + yy2186: + yych = *(marker = ++p); + if (yych == '~') + goto yy2196; + goto yy2184; + yy2187: + yych = *++p; + goto yy2184; + yy2188: + yych = *++p; + if (yych <= 0x7F) + goto yy2189; + if (yych <= 0xBF) + goto yy2187; + yy2189: + p = marker; + goto yy2184; + yy2190: + yych = *++p; + if (yych <= 0x9F) + goto yy2189; + if (yych <= 0xBF) + goto yy2188; + goto yy2189; + yy2191: + yych = *++p; + if (yych <= 0x7F) + goto yy2189; + if (yych <= 0xBF) + goto yy2188; + goto yy2189; + yy2192: + yych = *++p; + if (yych <= 0x8F) + goto yy2189; + if (yych <= 0xBF) + goto yy2191; + goto yy2189; + yy2193: + yych = *++p; + if (yych <= 0x7F) + goto yy2189; + if (yych <= 0xBF) + goto yy2191; + goto yy2189; + yy2194: + yych = *++p; + if (yych <= 0x7F) + goto yy2189; + if (yych <= 0x8F) + goto yy2191; + goto yy2189; + yy2195: + yych = *++p; + if (yych <= 0x7F) + goto yy2189; + if (yych <= 0x9F) + goto yy2188; + goto yy2189; + yy2196: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy2197; + } + goto yy2189; + yy2197: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy2199; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy2189; + if (yych <= '\n') + goto yy2201; + goto yy2189; + } else { + if (yych <= '\r') + goto yy2201; + if (yych == '~') + goto yy2197; + goto yy2189; + } + yy2199: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy2199; + } + if (yych <= 0x08) + goto yy2189; + if (yych <= '\n') + goto yy2201; + if (yych != '\r') + goto yy2189; + yy2201: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + yy2203: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy2204; + } + goto yy2189; + yy2204: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy2204; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy2189; + if (yych <= '\t') + goto yy2206; + if (yych <= '\n') + goto yy2208; + goto yy2189; + } else { + if (yych <= '\r') + goto yy2208; + if (yych != ' ') + goto yy2189; + } + yy2206: + ++p; + yych = *p; + if (yych <= '\f') { + if (yych <= 0x08) + goto yy2189; + if (yych <= '\t') + goto yy2206; + if (yych >= '\v') + goto yy2189; + } else { + if (yych <= '\r') + goto yy2208; + if (yych == ' ') + goto yy2206; + goto yy2189; + } + yy2208: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + } } // Scans an entity. // Returns number of chars matched. -bufsize_t _scan_entity(const unsigned char *p) -{ +bufsize_t _scan_entity(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; -{ - unsigned char yych; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= '%') { - if (yych != '\n') goto yy2212; - } else { - if (yych <= '&') goto yy2211; - if (yych <= 0x7F) goto yy2212; - if (yych >= 0xC2) goto yy2213; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy2215; - if (yych == 0xED) goto yy2220; - goto yy2216; - } else { - if (yych <= 0xF0) goto yy2217; - if (yych <= 0xF3) goto yy2218; - if (yych <= 0xF4) goto yy2219; - } - } -yy2210: - { return 0; } -yy2211: - yych = *(marker = ++p); - if (yych <= '@') { - if (yych == '#') goto yy2221; - goto yy2210; - } else { - if (yych <= 'Z') goto yy2222; - if (yych <= '`') goto yy2210; - if (yych <= 'z') goto yy2222; - goto yy2210; - } -yy2212: - yych = *++p; - goto yy2210; -yy2213: - yych = *++p; - if (yych <= 0x7F) goto yy2214; - if (yych <= 0xBF) goto yy2212; -yy2214: - p = marker; - goto yy2210; -yy2215: - yych = *++p; - if (yych <= 0x9F) goto yy2214; - if (yych <= 0xBF) goto yy2213; - goto yy2214; -yy2216: - yych = *++p; - if (yych <= 0x7F) goto yy2214; - if (yych <= 0xBF) goto yy2213; - goto yy2214; -yy2217: - yych = *++p; - if (yych <= 0x8F) goto yy2214; - if (yych <= 0xBF) goto yy2216; - goto yy2214; -yy2218: - yych = *++p; - if (yych <= 0x7F) goto yy2214; - if (yych <= 0xBF) goto yy2216; - goto yy2214; -yy2219: - yych = *++p; - if (yych <= 0x7F) goto yy2214; - if (yych <= 0x8F) goto yy2216; - goto yy2214; -yy2220: - yych = *++p; - if (yych <= 0x7F) goto yy2214; - if (yych <= 0x9F) goto yy2213; - goto yy2214; -yy2221: - yych = *++p; - if (yych <= 'W') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2257; - goto yy2214; - } else { - if (yych <= 'X') goto yy2256; - if (yych == 'x') goto yy2256; - goto yy2214; - } -yy2222: - yych = *++p; - if (yych <= '@') { - if (yych <= '/') goto yy2214; - if (yych >= ':') goto yy2214; - } else { - if (yych <= 'Z') goto yy2223; - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } -yy2223: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2226; - if (yych <= ':') goto yy2214; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - goto yy2226; - } else { - if (yych <= '`') goto yy2214; - if (yych <= 'z') goto yy2226; - goto yy2214; - } - } -yy2224: - ++p; - { return (bufsize_t)(p - start); } -yy2226: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2227; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2227: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2228; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2228: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2229; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2229: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2230; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2230: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2231; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2231: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2232; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2232: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2233; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2233: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2234; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2234: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2235; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2235: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2236; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2236: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2237; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2237: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2238; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2238: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2239; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2239: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2240; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2240: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2241; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2241: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2242; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2242: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2243; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2243: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2244; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2244: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2245; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2245: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2246; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2246: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2247; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2247: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2248; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2248: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2249; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2249: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2250; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2250: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2251; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2251: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2252; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2252: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2253; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2253: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2254; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2254: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2255; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'Z') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= '{') goto yy2214; - } - } -yy2255: - yych = *++p; - if (yych == ';') goto yy2224; - goto yy2214; -yy2256: - yych = *++p; - if (yych <= '@') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2264; - goto yy2214; - } else { - if (yych <= 'F') goto yy2264; - if (yych <= '`') goto yy2214; - if (yych <= 'f') goto yy2264; - goto yy2214; - } -yy2257: - yych = *++p; - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2258; - if (yych == ';') goto yy2224; - goto yy2214; -yy2258: - yych = *++p; - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2259; - if (yych == ';') goto yy2224; - goto yy2214; -yy2259: - yych = *++p; - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2260; - if (yych == ';') goto yy2224; - goto yy2214; -yy2260: - yych = *++p; - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2261; - if (yych == ';') goto yy2224; - goto yy2214; -yy2261: - yych = *++p; - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2262; - if (yych == ';') goto yy2224; - goto yy2214; -yy2262: - yych = *++p; - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2263; - if (yych == ';') goto yy2224; - goto yy2214; -yy2263: - yych = *++p; - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2255; - if (yych == ';') goto yy2224; - goto yy2214; -yy2264: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2265; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= 'g') goto yy2214; - } - } -yy2265: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2266; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= 'g') goto yy2214; - } - } -yy2266: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2267; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= 'g') goto yy2214; - } - } -yy2267: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2268; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= 'g') goto yy2214; - } - } -yy2268: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2269; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= 'g') goto yy2214; - } - } -yy2269: - yych = *++p; - if (yych <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2270; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy2214; - } else { - if (yych <= '`') goto yy2214; - if (yych >= 'g') goto yy2214; - } - } -yy2270: - ++p; - if ((yych = *p) <= ';') { - if (yych <= '/') goto yy2214; - if (yych <= '9') goto yy2255; - if (yych <= ':') goto yy2214; - goto yy2224; - } else { - if (yych <= 'F') { - if (yych <= '@') goto yy2214; - goto yy2255; - } else { - if (yych <= '`') goto yy2214; - if (yych <= 'f') goto yy2255; - goto yy2214; - } - } -} - + { + unsigned char yych; + yych = *(marker = p); + if (yych <= 0xDF) { + if (yych <= '%') { + if (yych != '\n') + goto yy2214; + } else { + if (yych <= '&') + goto yy2213; + if (yych <= 0x7F) + goto yy2214; + if (yych >= 0xC2) + goto yy2215; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy2217; + if (yych == 0xED) + goto yy2222; + goto yy2218; + } else { + if (yych <= 0xF0) + goto yy2219; + if (yych <= 0xF3) + goto yy2220; + if (yych <= 0xF4) + goto yy2221; + } + } + yy2212 : { return 0; } + yy2213: + yych = *(marker = ++p); + if (yych <= '@') { + if (yych == '#') + goto yy2223; + goto yy2212; + } else { + if (yych <= 'Z') + goto yy2224; + if (yych <= '`') + goto yy2212; + if (yych <= 'z') + goto yy2224; + goto yy2212; + } + yy2214: + yych = *++p; + goto yy2212; + yy2215: + yych = *++p; + if (yych <= 0x7F) + goto yy2216; + if (yych <= 0xBF) + goto yy2214; + yy2216: + p = marker; + goto yy2212; + yy2217: + yych = *++p; + if (yych <= 0x9F) + goto yy2216; + if (yych <= 0xBF) + goto yy2215; + goto yy2216; + yy2218: + yych = *++p; + if (yych <= 0x7F) + goto yy2216; + if (yych <= 0xBF) + goto yy2215; + goto yy2216; + yy2219: + yych = *++p; + if (yych <= 0x8F) + goto yy2216; + if (yych <= 0xBF) + goto yy2218; + goto yy2216; + yy2220: + yych = *++p; + if (yych <= 0x7F) + goto yy2216; + if (yych <= 0xBF) + goto yy2218; + goto yy2216; + yy2221: + yych = *++p; + if (yych <= 0x7F) + goto yy2216; + if (yych <= 0x8F) + goto yy2218; + goto yy2216; + yy2222: + yych = *++p; + if (yych <= 0x7F) + goto yy2216; + if (yych <= 0x9F) + goto yy2215; + goto yy2216; + yy2223: + yych = *++p; + if (yych <= 'W') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2259; + goto yy2216; + } else { + if (yych <= 'X') + goto yy2258; + if (yych == 'x') + goto yy2258; + goto yy2216; + } + yy2224: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') + goto yy2216; + if (yych >= ':') + goto yy2216; + } else { + if (yych <= 'Z') + goto yy2225; + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + yy2225: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2228; + if (yych <= ':') + goto yy2216; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + goto yy2228; + } else { + if (yych <= '`') + goto yy2216; + if (yych <= 'z') + goto yy2228; + goto yy2216; + } + } + yy2226: + ++p; + { return (bufsize_t)(p - start); } + yy2228: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2229; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2229: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2230; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2230: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2231; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2231: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2232; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2232: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2233; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2233: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2234; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2234: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2235; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2235: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2236; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2236: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2237; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2237: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2238; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2238: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2239; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2239: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2240; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2240: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2241; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2241: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2242; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2242: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2243; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2243: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2244; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2244: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2245; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2245: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2246; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2246: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2247; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2247: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2248; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2248: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2249; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2249: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2250; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2250: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2251; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2251: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2252; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2252: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2253; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2253: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2254; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2254: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2255; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2255: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2256; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2256: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2257; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= '{') + goto yy2216; + } + } + yy2257: + yych = *++p; + if (yych == ';') + goto yy2226; + goto yy2216; + yy2258: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2266; + goto yy2216; + } else { + if (yych <= 'F') + goto yy2266; + if (yych <= '`') + goto yy2216; + if (yych <= 'f') + goto yy2266; + goto yy2216; + } + yy2259: + yych = *++p; + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2260; + if (yych == ';') + goto yy2226; + goto yy2216; + yy2260: + yych = *++p; + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2261; + if (yych == ';') + goto yy2226; + goto yy2216; + yy2261: + yych = *++p; + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2262; + if (yych == ';') + goto yy2226; + goto yy2216; + yy2262: + yych = *++p; + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2263; + if (yych == ';') + goto yy2226; + goto yy2216; + yy2263: + yych = *++p; + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2264; + if (yych == ';') + goto yy2226; + goto yy2216; + yy2264: + yych = *++p; + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2265; + if (yych == ';') + goto yy2226; + goto yy2216; + yy2265: + yych = *++p; + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2257; + if (yych == ';') + goto yy2226; + goto yy2216; + yy2266: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2267; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= 'g') + goto yy2216; + } + } + yy2267: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2268; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= 'g') + goto yy2216; + } + } + yy2268: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2269; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= 'g') + goto yy2216; + } + } + yy2269: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2270; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= 'g') + goto yy2216; + } + } + yy2270: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2271; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= 'g') + goto yy2216; + } + } + yy2271: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2272; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy2216; + } else { + if (yych <= '`') + goto yy2216; + if (yych >= 'g') + goto yy2216; + } + } + yy2272: + ++p; + if ((yych = *p) <= ';') { + if (yych <= '/') + goto yy2216; + if (yych <= '9') + goto yy2257; + if (yych <= ':') + goto yy2216; + goto yy2226; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy2216; + goto yy2257; + } else { + if (yych <= '`') + goto yy2216; + if (yych <= 'f') + goto yy2257; + goto yy2216; + } + } + } } // Returns positive value if a URL begins in a way that is potentially // dangerous, with javascript:, vbscript:, file:, or data:, otherwise 0. -bufsize_t _scan_dangerous_url(const unsigned char *p) -{ +bufsize_t _scan_dangerous_url(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; -{ - unsigned char yych; - unsigned int yyaccept = 0; - yych = *(marker = p); - if (yych <= 'f') { - if (yych <= 'I') { - if (yych <= 'C') { - if (yych != '\n') goto yy2278; - } else { - if (yych <= 'D') goto yy2274; - if (yych == 'F') goto yy2277; - goto yy2278; - } - } else { - if (yych <= 'V') { - if (yych <= 'J') goto yy2275; - if (yych <= 'U') goto yy2278; - goto yy2276; - } else { - if (yych == 'd') goto yy2274; - if (yych <= 'e') goto yy2278; - goto yy2277; - } - } - } else { - if (yych <= 0xDF) { - if (yych <= 'u') { - if (yych == 'j') goto yy2275; - goto yy2278; - } else { - if (yych <= 'v') goto yy2276; - if (yych <= 0x7F) goto yy2278; - if (yych >= 0xC2) goto yy2279; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) goto yy2281; - if (yych == 0xED) goto yy2286; - goto yy2282; - } else { - if (yych <= 0xF0) goto yy2283; - if (yych <= 0xF3) goto yy2284; - if (yych <= 0xF4) goto yy2285; - } - } - } -yy2273: - { return 0; } -yy2274: - yyaccept = 0; - yych = *(marker = ++p); - if (yych == 'A') goto yy2308; - if (yych == 'a') goto yy2308; - goto yy2273; -yy2275: - yyaccept = 0; - yych = *(marker = ++p); - if (yych == 'A') goto yy2299; - if (yych == 'a') goto yy2299; - goto yy2273; -yy2276: - yyaccept = 0; - yych = *(marker = ++p); - if (yych == 'B') goto yy2292; - if (yych == 'b') goto yy2292; - goto yy2273; -yy2277: - yyaccept = 0; - yych = *(marker = ++p); - if (yych == 'I') goto yy2287; - if (yych == 'i') goto yy2287; - goto yy2273; -yy2278: - yych = *++p; - goto yy2273; -yy2279: - yych = *++p; - if (yych <= 0x7F) goto yy2280; - if (yych <= 0xBF) goto yy2278; -yy2280: - p = marker; - if (yyaccept == 0) { - goto yy2273; - } else { - goto yy2291; - } -yy2281: - yych = *++p; - if (yych <= 0x9F) goto yy2280; - if (yych <= 0xBF) goto yy2279; - goto yy2280; -yy2282: - yych = *++p; - if (yych <= 0x7F) goto yy2280; - if (yych <= 0xBF) goto yy2279; - goto yy2280; -yy2283: - yych = *++p; - if (yych <= 0x8F) goto yy2280; - if (yych <= 0xBF) goto yy2282; - goto yy2280; -yy2284: - yych = *++p; - if (yych <= 0x7F) goto yy2280; - if (yych <= 0xBF) goto yy2282; - goto yy2280; -yy2285: - yych = *++p; - if (yych <= 0x7F) goto yy2280; - if (yych <= 0x8F) goto yy2282; - goto yy2280; -yy2286: - yych = *++p; - if (yych <= 0x7F) goto yy2280; - if (yych <= 0x9F) goto yy2279; - goto yy2280; -yy2287: - yych = *++p; - if (yych == 'L') goto yy2288; - if (yych != 'l') goto yy2280; -yy2288: - yych = *++p; - if (yych == 'E') goto yy2289; - if (yych != 'e') goto yy2280; -yy2289: - yych = *++p; - if (yych != ':') goto yy2280; -yy2290: - ++p; -yy2291: - { return (bufsize_t)(p - start); } -yy2292: - yych = *++p; - if (yych == 'S') goto yy2293; - if (yych != 's') goto yy2280; -yy2293: - yych = *++p; - if (yych == 'C') goto yy2294; - if (yych != 'c') goto yy2280; -yy2294: - yych = *++p; - if (yych == 'R') goto yy2295; - if (yych != 'r') goto yy2280; -yy2295: - yych = *++p; - if (yych == 'I') goto yy2296; - if (yych != 'i') goto yy2280; -yy2296: - yych = *++p; - if (yych == 'P') goto yy2297; - if (yych != 'p') goto yy2280; -yy2297: - yych = *++p; - if (yych == 'T') goto yy2298; - if (yych != 't') goto yy2280; -yy2298: - yych = *++p; - if (yych == ':') goto yy2290; - goto yy2280; -yy2299: - yych = *++p; - if (yych == 'V') goto yy2300; - if (yych != 'v') goto yy2280; -yy2300: - yych = *++p; - if (yych == 'A') goto yy2301; - if (yych != 'a') goto yy2280; -yy2301: - yych = *++p; - if (yych == 'S') goto yy2302; - if (yych != 's') goto yy2280; -yy2302: - yych = *++p; - if (yych == 'C') goto yy2303; - if (yych != 'c') goto yy2280; -yy2303: - yych = *++p; - if (yych == 'R') goto yy2304; - if (yych != 'r') goto yy2280; -yy2304: - yych = *++p; - if (yych == 'I') goto yy2305; - if (yych != 'i') goto yy2280; -yy2305: - yych = *++p; - if (yych == 'P') goto yy2306; - if (yych != 'p') goto yy2280; -yy2306: - yych = *++p; - if (yych == 'T') goto yy2307; - if (yych != 't') goto yy2280; -yy2307: - yych = *++p; - if (yych == ':') goto yy2290; - goto yy2280; -yy2308: - yych = *++p; - if (yych == 'T') goto yy2309; - if (yych != 't') goto yy2280; -yy2309: - yych = *++p; - if (yych == 'A') goto yy2310; - if (yych != 'a') goto yy2280; -yy2310: - yych = *++p; - if (yych != ':') goto yy2280; - yyaccept = 1; - yych = *(marker = ++p); - if (yych == 'I') goto yy2312; - if (yych != 'i') goto yy2291; -yy2312: - yych = *++p; - if (yych == 'M') goto yy2313; - if (yych != 'm') goto yy2280; -yy2313: - yych = *++p; - if (yych == 'A') goto yy2314; - if (yych != 'a') goto yy2280; -yy2314: - yych = *++p; - if (yych == 'G') goto yy2315; - if (yych != 'g') goto yy2280; -yy2315: - yych = *++p; - if (yych == 'E') goto yy2316; - if (yych != 'e') goto yy2280; -yy2316: - yych = *++p; - if (yych != '/') goto yy2280; - yych = *++p; - if (yych <= 'W') { - if (yych <= 'J') { - if (yych == 'G') goto yy2319; - if (yych <= 'I') goto yy2280; - goto yy2320; - } else { - if (yych == 'P') goto yy2318; - if (yych <= 'V') goto yy2280; - goto yy2321; - } - } else { - if (yych <= 'j') { - if (yych == 'g') goto yy2319; - if (yych <= 'i') goto yy2280; - goto yy2320; - } else { - if (yych <= 'p') { - if (yych <= 'o') goto yy2280; - } else { - if (yych == 'w') goto yy2321; - goto yy2280; - } - } - } -yy2318: - yych = *++p; - if (yych == 'N') goto yy2329; - if (yych == 'n') goto yy2329; - goto yy2280; -yy2319: - yych = *++p; - if (yych == 'I') goto yy2328; - if (yych == 'i') goto yy2328; - goto yy2280; -yy2320: - yych = *++p; - if (yych == 'P') goto yy2326; - if (yych == 'p') goto yy2326; - goto yy2280; -yy2321: - yych = *++p; - if (yych == 'E') goto yy2322; - if (yych != 'e') goto yy2280; -yy2322: - yych = *++p; - if (yych == 'B') goto yy2323; - if (yych != 'b') goto yy2280; -yy2323: - yych = *++p; - if (yych == 'P') goto yy2324; - if (yych != 'p') goto yy2280; -yy2324: - ++p; - { return 0; } -yy2326: - yych = *++p; - if (yych == 'E') goto yy2327; - if (yych != 'e') goto yy2280; -yy2327: - yych = *++p; - if (yych == 'G') goto yy2324; - if (yych == 'g') goto yy2324; - goto yy2280; -yy2328: - yych = *++p; - if (yych == 'F') goto yy2324; - if (yych == 'f') goto yy2324; - goto yy2280; -yy2329: - ++p; - if ((yych = *p) == 'G') goto yy2324; - if (yych == 'g') goto yy2324; - goto yy2280; + { + unsigned char yych; + unsigned int yyaccept = 0; + yych = *(marker = p); + if (yych <= 'f') { + if (yych <= 'I') { + if (yych <= 'C') { + if (yych != '\n') + goto yy2280; + } else { + if (yych <= 'D') + goto yy2276; + if (yych == 'F') + goto yy2279; + goto yy2280; + } + } else { + if (yych <= 'V') { + if (yych <= 'J') + goto yy2277; + if (yych <= 'U') + goto yy2280; + goto yy2278; + } else { + if (yych == 'd') + goto yy2276; + if (yych <= 'e') + goto yy2280; + goto yy2279; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= 'u') { + if (yych == 'j') + goto yy2277; + goto yy2280; + } else { + if (yych <= 'v') + goto yy2278; + if (yych <= 0x7F) + goto yy2280; + if (yych >= 0xC2) + goto yy2281; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy2283; + if (yych == 0xED) + goto yy2288; + goto yy2284; + } else { + if (yych <= 0xF0) + goto yy2285; + if (yych <= 0xF3) + goto yy2286; + if (yych <= 0xF4) + goto yy2287; + } + } + } + yy2275 : { return 0; } + yy2276: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'A') + goto yy2310; + if (yych == 'a') + goto yy2310; + goto yy2275; + yy2277: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'A') + goto yy2301; + if (yych == 'a') + goto yy2301; + goto yy2275; + yy2278: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'B') + goto yy2294; + if (yych == 'b') + goto yy2294; + goto yy2275; + yy2279: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'I') + goto yy2289; + if (yych == 'i') + goto yy2289; + goto yy2275; + yy2280: + yych = *++p; + goto yy2275; + yy2281: + yych = *++p; + if (yych <= 0x7F) + goto yy2282; + if (yych <= 0xBF) + goto yy2280; + yy2282: + p = marker; + if (yyaccept == 0) { + goto yy2275; + } else { + goto yy2293; + } + yy2283: + yych = *++p; + if (yych <= 0x9F) + goto yy2282; + if (yych <= 0xBF) + goto yy2281; + goto yy2282; + yy2284: + yych = *++p; + if (yych <= 0x7F) + goto yy2282; + if (yych <= 0xBF) + goto yy2281; + goto yy2282; + yy2285: + yych = *++p; + if (yych <= 0x8F) + goto yy2282; + if (yych <= 0xBF) + goto yy2284; + goto yy2282; + yy2286: + yych = *++p; + if (yych <= 0x7F) + goto yy2282; + if (yych <= 0xBF) + goto yy2284; + goto yy2282; + yy2287: + yych = *++p; + if (yych <= 0x7F) + goto yy2282; + if (yych <= 0x8F) + goto yy2284; + goto yy2282; + yy2288: + yych = *++p; + if (yych <= 0x7F) + goto yy2282; + if (yych <= 0x9F) + goto yy2281; + goto yy2282; + yy2289: + yych = *++p; + if (yych == 'L') + goto yy2290; + if (yych != 'l') + goto yy2282; + yy2290: + yych = *++p; + if (yych == 'E') + goto yy2291; + if (yych != 'e') + goto yy2282; + yy2291: + yych = *++p; + if (yych != ':') + goto yy2282; + yy2292: + ++p; + yy2293 : { return (bufsize_t)(p - start); } + yy2294: + yych = *++p; + if (yych == 'S') + goto yy2295; + if (yych != 's') + goto yy2282; + yy2295: + yych = *++p; + if (yych == 'C') + goto yy2296; + if (yych != 'c') + goto yy2282; + yy2296: + yych = *++p; + if (yych == 'R') + goto yy2297; + if (yych != 'r') + goto yy2282; + yy2297: + yych = *++p; + if (yych == 'I') + goto yy2298; + if (yych != 'i') + goto yy2282; + yy2298: + yych = *++p; + if (yych == 'P') + goto yy2299; + if (yych != 'p') + goto yy2282; + yy2299: + yych = *++p; + if (yych == 'T') + goto yy2300; + if (yych != 't') + goto yy2282; + yy2300: + yych = *++p; + if (yych == ':') + goto yy2292; + goto yy2282; + yy2301: + yych = *++p; + if (yych == 'V') + goto yy2302; + if (yych != 'v') + goto yy2282; + yy2302: + yych = *++p; + if (yych == 'A') + goto yy2303; + if (yych != 'a') + goto yy2282; + yy2303: + yych = *++p; + if (yych == 'S') + goto yy2304; + if (yych != 's') + goto yy2282; + yy2304: + yych = *++p; + if (yych == 'C') + goto yy2305; + if (yych != 'c') + goto yy2282; + yy2305: + yych = *++p; + if (yych == 'R') + goto yy2306; + if (yych != 'r') + goto yy2282; + yy2306: + yych = *++p; + if (yych == 'I') + goto yy2307; + if (yych != 'i') + goto yy2282; + yy2307: + yych = *++p; + if (yych == 'P') + goto yy2308; + if (yych != 'p') + goto yy2282; + yy2308: + yych = *++p; + if (yych == 'T') + goto yy2309; + if (yych != 't') + goto yy2282; + yy2309: + yych = *++p; + if (yych == ':') + goto yy2292; + goto yy2282; + yy2310: + yych = *++p; + if (yych == 'T') + goto yy2311; + if (yych != 't') + goto yy2282; + yy2311: + yych = *++p; + if (yych == 'A') + goto yy2312; + if (yych != 'a') + goto yy2282; + yy2312: + yych = *++p; + if (yych != ':') + goto yy2282; + yyaccept = 1; + yych = *(marker = ++p); + if (yych == 'I') + goto yy2314; + if (yych != 'i') + goto yy2293; + yy2314: + yych = *++p; + if (yych == 'M') + goto yy2315; + if (yych != 'm') + goto yy2282; + yy2315: + yych = *++p; + if (yych == 'A') + goto yy2316; + if (yych != 'a') + goto yy2282; + yy2316: + yych = *++p; + if (yych == 'G') + goto yy2317; + if (yych != 'g') + goto yy2282; + yy2317: + yych = *++p; + if (yych == 'E') + goto yy2318; + if (yych != 'e') + goto yy2282; + yy2318: + yych = *++p; + if (yych != '/') + goto yy2282; + yych = *++p; + if (yych <= 'W') { + if (yych <= 'J') { + if (yych == 'G') + goto yy2321; + if (yych <= 'I') + goto yy2282; + goto yy2322; + } else { + if (yych == 'P') + goto yy2320; + if (yych <= 'V') + goto yy2282; + goto yy2323; + } + } else { + if (yych <= 'j') { + if (yych == 'g') + goto yy2321; + if (yych <= 'i') + goto yy2282; + goto yy2322; + } else { + if (yych <= 'p') { + if (yych <= 'o') + goto yy2282; + } else { + if (yych == 'w') + goto yy2323; + goto yy2282; + } + } + } + yy2320: + yych = *++p; + if (yych == 'N') + goto yy2331; + if (yych == 'n') + goto yy2331; + goto yy2282; + yy2321: + yych = *++p; + if (yych == 'I') + goto yy2330; + if (yych == 'i') + goto yy2330; + goto yy2282; + yy2322: + yych = *++p; + if (yych == 'P') + goto yy2328; + if (yych == 'p') + goto yy2328; + goto yy2282; + yy2323: + yych = *++p; + if (yych == 'E') + goto yy2324; + if (yych != 'e') + goto yy2282; + yy2324: + yych = *++p; + if (yych == 'B') + goto yy2325; + if (yych != 'b') + goto yy2282; + yy2325: + yych = *++p; + if (yych == 'P') + goto yy2326; + if (yych != 'p') + goto yy2282; + yy2326: + ++p; + { return 0; } + yy2328: + yych = *++p; + if (yych == 'E') + goto yy2329; + if (yych != 'e') + goto yy2282; + yy2329: + yych = *++p; + if (yych == 'G') + goto yy2326; + if (yych == 'g') + goto yy2326; + goto yy2282; + yy2330: + yych = *++p; + if (yych == 'F') + goto yy2326; + if (yych == 'f') + goto yy2326; + goto yy2282; + yy2331: + ++p; + if ((yych = *p) == 'G') + goto yy2326; + if (yych == 'g') + goto yy2326; + goto yy2282; + } } - -} - diff --git a/scanners.h b/scanners.h index a6a71bf..4616f9f 100644 --- a/scanners.h +++ b/scanners.h @@ -5,7 +5,8 @@ extern "C" { #endif -bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, bufsize_t offset); +bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, + bufsize_t offset); bufsize_t _scan_scheme(const unsigned char *p); bufsize_t _scan_autolink_uri(const unsigned char *p); bufsize_t _scan_autolink_email(const unsigned char *p); diff --git a/scanners.re b/scanners.re index fbe3283..0037bc4 100644 --- a/scanners.re +++ b/scanners.re @@ -32,7 +32,7 @@ bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, tagname = [A-Za-z][A-Za-z0-9-]*; - blocktagname = 'address'|'article'|'aside'|'base'|'basefont'|'blockquote'|'body'|'caption'|'center'|'col'|'colgroup'|'dd'|'details'|'dialog'|'dir'|'div'|'dl'|'dt'|'fieldset'|'figcaption'|'figure'|'footer'|'form'|'frame'|'frameset'|'h1'|'head'|'header'|'hr'|'html'|'legend'|'li'|'link'|'main'|'menu'|'menuitem'|'meta'|'nav'|'noframes'|'ol'|'optgroup'|'option'|'p'|'param'|'pre'|'section'|'source'|'title'|'summary'|'table'|'tbody'|'td'|'tfoot'|'th'|'thead'|'title'|'tr'|'track'|'ul'; + blocktagname = 'address'|'article'|'aside'|'base'|'basefont'|'blockquote'|'body'|'caption'|'center'|'col'|'colgroup'|'dd'|'details'|'dialog'|'dir'|'div'|'dl'|'dt'|'fieldset'|'figcaption'|'figure'|'footer'|'form'|'frame'|'frameset'|'h1'|'head'|'header'|'hr'|'html'|'iframe'|'legend'|'li'|'link'|'main'|'menu'|'menuitem'|'meta'|'nav'|'noframes'|'ol'|'optgroup'|'option'|'p'|'param'|'section'|'source'|'title'|'summary'|'table'|'tbody'|'td'|'tfoot'|'th'|'thead'|'title'|'tr'|'track'|'ul'; attributename = [a-zA-Z_:][a-zA-Z0-9:._-]*; diff --git a/utf8.c b/utf8.c index ffe6652..319539d 100644 --- a/utf8.c +++ b/utf8.c @@ -6,452 +6,309 @@ #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); + 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, bufsize_t str_len) -{ - int length, i; +static int utf8proc_charlen(const uint8_t *str, bufsize_t str_len) { + int length, i; - if (!str_len) - return 0; + if (!str_len) + return 0; - length = utf8proc_utf8class[str[0]]; + length = utf8proc_utf8class[str[0]]; - if (!length) - return -1; + if (!length) + return -1; - if (str_len >= 0 && (bufsize_t)length > str_len) - return -str_len; + if (str_len >= 0 && (bufsize_t)length > str_len) + return -str_len; - for (i = 1; i < length; i++) { - if ((str[i] & 0xC0) != 0x80) - return -i; - } + for (i = 1; i < length; i++) { + if ((str[i] & 0xC0) != 0x80) + return -i; + } - return length; + return length; } // Validate a single UTF-8 character according to RFC 3629. -static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) -{ - int length = utf8proc_utf8class[str[0]]; - - if (!length) - return -1; - - if ((bufsize_t)length > str_len) - return -str_len; - - switch (length) { - case 2: - if ((str[1] & 0xC0) != 0x80) - return -1; - if (str[0] < 0xC2) { - // Overlong - return -length; - } - break; - - case 3: - if ((str[1] & 0xC0) != 0x80) - return -1; - if ((str[2] & 0xC0) != 0x80) - return -2; - 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[1] & 0xC0) != 0x80) - return -1; - if ((str[2] & 0xC0) != 0x80) - return -2; - if ((str[3] & 0xC0) != 0x80) - return -3; - 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; +static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) { + int length = utf8proc_utf8class[str[0]]; + + if (!length) + return -1; + + if ((bufsize_t)length > str_len) + return -str_len; + + switch (length) { + case 2: + if ((str[1] & 0xC0) != 0x80) + return -1; + if (str[0] < 0xC2) { + // Overlong + return -length; + } + break; + + case 3: + if ((str[1] & 0xC0) != 0x80) + return -1; + if ((str[2] & 0xC0) != 0x80) + return -2; + 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[1] & 0xC0) != 0x80) + return -1; + if ((str[2] & 0xC0) != 0x80) + return -2; + if ((str[3] & 0xC0) != 0x80) + return -3; + 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_check(cmark_strbuf *ob, const uint8_t *line, bufsize_t size) -{ - bufsize_t i = 0; - - while (i < size) { - bufsize_t org = i; - int charlen = 0; - - while (i < size) { - if (line[i] < 0x80 && line[i] != 0) { - i++; - } else if (line[i] >= 0x80) { - charlen = utf8proc_valid(line + i, size - i); - if (charlen < 0) { - charlen = -charlen; - break; - } - i += charlen; - } else if (line[i] == 0) { - // ASCII NUL is technically valid but rejected - // for security reasons. - charlen = 1; - break; - } - } - - if (i > org) { - cmark_strbuf_put(ob, line + org, i - org); - } - - if (i >= size) { - break; - } else { - // Invalid UTF-8 - encode_unknown(ob); - i += charlen; - } - } +void cmark_utf8proc_check(cmark_strbuf *ob, const uint8_t *line, bufsize_t size) { + bufsize_t i = 0; + + while (i < size) { + bufsize_t org = i; + int charlen = 0; + + while (i < size) { + if (line[i] < 0x80 && line[i] != 0) { + i++; + } else if (line[i] >= 0x80) { + charlen = utf8proc_valid(line + i, size - i); + if (charlen < 0) { + charlen = -charlen; + break; + } + i += charlen; + } else if (line[i] == 0) { + // ASCII NUL is technically valid but rejected + // for security reasons. + charlen = 1; + break; + } + } + + if (i > org) { + cmark_strbuf_put(ob, line + org, i - org); + } + + if (i >= size) { + break; + } else { + // Invalid UTF-8 + encode_unknown(ob); + i += charlen; + } + } } -int utf8proc_iterate(const uint8_t *str, bufsize_t 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 = -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) - return -1; - - *dst = uc; - return length; +int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t 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 = -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) + return -1; + + *dst = uc; + return length; } -void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) -{ - uint8_t dst[4]; - bufsize_t 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 cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) { + uint8_t dst[4]; + bufsize_t len = 0; + + assert(uc >= 0); + + if (uc < 0x80) { + dst[0] = (uint8_t)(uc); + len = 1; + } else if (uc < 0x800) { + dst[0] = (uint8_t)(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] = (uint8_t)(0xE0 + (uc >> 12)); + dst[1] = 0x80 + ((uc >> 6) & 0x3F); + dst[2] = 0x80 + (uc & 0x3F); + len = 3; + } else if (uc < 0x110000) { + dst[0] = (uint8_t)(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, bufsize_t len) -{ - int32_t c; +void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, bufsize_t len) { + int32_t c; -#define bufpush(x) \ - utf8proc_encode_char(x, dest) +#define bufpush(x) cmark_utf8proc_encode_char(x, dest) - while (len > 0) { - bufsize_t char_len = utf8proc_iterate(str, len, &c); + while (len > 0) { + bufsize_t char_len = cmark_utf8proc_iterate(str, len, &c); - if (char_len >= 0) { + if (char_len >= 0) { #include "case_fold_switch.inc" - } else { - encode_unknown(dest); - char_len = -char_len; - } - - str += char_len; - len -= char_len; - } + } 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); +int cmark_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); +int cmark_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/utf8.h b/utf8.h index 9f1a4ec..43b3757 100644 --- a/utf8.h +++ b/utf8.h @@ -8,12 +8,12 @@ extern "C" { #endif -void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, bufsize_t len); -void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf); -int utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst); -void utf8proc_check(cmark_strbuf *dest, const uint8_t *line, bufsize_t size); -int utf8proc_is_space(int32_t uc); -int utf8proc_is_punctuation(int32_t uc); +void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, bufsize_t len); +void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf); +int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst); +void cmark_utf8proc_check(cmark_strbuf *dest, const uint8_t *line, bufsize_t size); +int cmark_utf8proc_is_space(int32_t uc); +int cmark_utf8proc_is_punctuation(int32_t uc); #ifdef __cplusplus } diff --git a/xml.c b/xml.c index 7eec5a6..0b225fa 100644 --- a/xml.c +++ b/xml.c @@ -11,157 +11,142 @@ // Functions to convert cmark_nodes to XML strings. -static void escape_xml(cmark_strbuf *dest, const unsigned char *source, bufsize_t length) -{ - houdini_escape_html0(dest, source, length, 0); +static void escape_xml(cmark_strbuf *dest, const unsigned char *source, + bufsize_t length) { + houdini_escape_html0(dest, source, length, 0); } struct render_state { - cmark_strbuf* xml; - int indent; + 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 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.data, - node->as.link.url.len); - cmark_strbuf_putc(xml, '"'); - cmark_strbuf_puts(xml, " title=\""); - escape_xml(xml, node->as.link.title.data, - node->as.link.title.len); - 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; +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); + char buffer[100]; + + if (entering) { + indent(state); + cmark_strbuf_putc(xml, '<'); + cmark_strbuf_puts(xml, cmark_node_get_type_string(node)); + + if (options & CMARK_OPT_SOURCEPOS && node->start_line != 0) { + sprintf(buffer, " sourcepos=\"%d:%d-%d:%d\"", node->start_line, + node->start_column, node->end_line, node->end_column); + cmark_strbuf_puts(xml, buffer); + } + + 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); + cmark_strbuf_puts(xml, buffer); + 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.data, node->as.link.url.len); + cmark_strbuf_putc(xml, '"'); + cmark_strbuf_puts(xml, " title=\""); + escape_xml(xml, node->as.link.title.data, node->as.link.title.len); + 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_puts(xml, "\n"); + } + + 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; +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; } From 8924ec19037dfeee43e053f6c8e37ea09e6120fa Mon Sep 17 00:00:00 2001 From: jcadam Date: Tue, 29 Dec 2015 20:37:15 -0500 Subject: [PATCH 18/26] updated to cmark 0.23.0 --- CMakeLists.txt | 175 - bench.h | 27 - blocks.c | 148 +- chunk.h | 12 +- cmark.h | 122 +- cmark_ctype.c | 12 +- cmark_version.h | 4 +- commonmark.c | 34 +- commonmark_test.go | 19 +- houdini_html_u.c | 11 +- html.c | 44 +- inlines.c | 19 +- iterator.c | 4 +- latex.c | 82 +- man.c | 22 +- node.c | 165 +- node.go | 44 +- node.h | 10 +- render.c | 9 +- render.h | 1 + scanners.c | 8038 ++++++++++++++++++++------------------------ scanners.h | 13 +- scanners.re | 27 +- utf8.c | 9 +- utf8.h | 6 +- xml.c | 24 +- 26 files changed, 4274 insertions(+), 4807 deletions(-) delete mode 100644 CMakeLists.txt delete mode 100644 bench.h diff --git a/CMakeLists.txt b/CMakeLists.txt deleted file mode 100644 index eee9316..0000000 --- a/CMakeLists.txt +++ /dev/null @@ -1,175 +0,0 @@ -cmake_minimum_required(VERSION 2.8) -set(LIBRARY "libcmark") -set(STATICLIBRARY "libcmark_static") -set(HEADERS - cmark.h - parser.h - buffer.h - node.h - iterator.h - chunk.h - references.h - bench.h - utf8.h - scanners.h - inlines.h - houdini.h - cmark_ctype.h - render.h - ) -set(LIBRARY_SOURCES - cmark.c - node.c - iterator.c - blocks.c - inlines.c - scanners.c - scanners.re - utf8.c - buffer.c - references.c - render.c - man.c - xml.c - html.c - commonmark.c - latex.c - houdini_href_e.c - houdini_html_e.c - houdini_html_u.c - cmark_ctype.c - ${HEADERS} - ) - -set(PROGRAM "cmark") -set(PROGRAM_SOURCES - ${LIBRARY_SOURCES} - main.c - ) - -include_directories(. ${CMAKE_CURRENT_BINARY_DIR}) - -configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmark_version.h.in - ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h) - -configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark.pc.in - ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc @ONLY) -install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc - DESTINATION lib/pkgconfig) - -include (GenerateExportHeader) - -add_executable(${PROGRAM} ${PROGRAM_SOURCES}) -add_compiler_export_flags() - -# Disable the PUBLIC declarations when compiling the executable: -set_target_properties(${PROGRAM} PROPERTIES - COMPILE_FLAGS -DCMARK_STATIC_DEFINE) - -# Check integrity of node structure when compiled as debug: -set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DCMARK_DEBUG_NODES") -set(CMAKE_LINKER_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG}") - -set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -pg") -set(CMAKE_LINKER_PROFILE "${CMAKE_LINKER_FLAGS_RELEASE} -pg") - -if (${CMAKE_MAJOR_VERSION} GREATER 1 AND ${CMAKE_MINOR_VERSION} GREATER 8) - set(CMAKE_C_VISIBILITY_PRESET hidden) - set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) -elseif(CMAKE_COMPILER_IS_GNUCC OR ${CMAKE_C_COMPILER_ID} STREQUAL "Clang") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") -endif () - -add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES}) -add_library(${STATICLIBRARY} STATIC ${LIBRARY_SOURCES}) -# Include minor version and patch level in soname for now. -set_target_properties(${LIBRARY} PROPERTIES - OUTPUT_NAME "cmark" - SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH} - VERSION ${PROJECT_VERSION}) -set_target_properties(${STATICLIBRARY} PROPERTIES - COMPILE_FLAGS -DCMARK_STATIC_DEFINE) - -if (MSVC) - set_target_properties(${STATICLIBRARY} PROPERTIES - OUTPUT_NAME "cmark_static" - VERSION ${PROJECT_VERSION}) -else() - set_target_properties(${STATICLIBRARY} PROPERTIES - OUTPUT_NAME "cmark" - VERSION ${PROJECT_VERSION}) -endif(MSVC) - -set_property(TARGET ${LIBRARY} - APPEND PROPERTY MACOSX_RPATH true) - -generate_export_header(${LIBRARY} - BASE_NAME ${PROJECT_NAME}) - -if (MSVC) - set_property(TARGET ${PROGRAM} - APPEND PROPERTY LINK_FLAGS /INCREMENTAL:NO) -endif(MSVC) - -set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON) -include (InstallRequiredSystemLibraries) -install(TARGETS ${PROGRAM} ${LIBRARY} - RUNTIME DESTINATION bin - LIBRARY DESTINATION lib - ) - -install(FILES - cmark.h - ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h - ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h - DESTINATION include - ) - -# Feature tests -include(CheckIncludeFile) -include(CheckCSourceCompiles) -include(CheckCSourceRuns) -include(CheckSymbolExists) -CHECK_INCLUDE_FILE(stdbool.h HAVE_STDBOOL_H) -CHECK_C_SOURCE_COMPILES( - "int main() { __builtin_expect(0,0); return 0; }" - HAVE___BUILTIN_EXPECT) -CHECK_C_SOURCE_COMPILES(" - int f(void) __attribute__ (()); - int main() { return 0; } -" HAVE___ATTRIBUTE__) -CHECK_C_SOURCE_RUNS(" - #include - int main() { return snprintf(NULL, 0, \"123\") == 3 ? 0 : 1; } -" HAVE_C99_SNPRINTF) -CHECK_SYMBOL_EXISTS(va_copy stdarg.h HAVE_VA_COPY) - -CONFIGURE_FILE( - ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in - ${CMAKE_CURRENT_BINARY_DIR}/config.h) - -# Always compile with warnings -if(MSVC) - # Force to always compile with W4 - if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") - string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") - else() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4") - endif() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127 /wd4244 /wd4267 /wd4706 /wd4800 /D_CRT_SECURE_NO_WARNINGS") -elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=c99 -pedantic") -endif() - -# Compile as C++ under MSVC -if(MSVC) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /TP") -endif() - -if($ENV{TIMER}) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DTIMER=1") -endif($ENV{TIMER}) - -if(CMAKE_BUILD_TYPE STREQUAL "Ubsan") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined") -endif() diff --git a/bench.h b/bench.h deleted file mode 100644 index 744dea3..0000000 --- a/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/blocks.c b/blocks.c index 49ac273..773179e 100644 --- a/blocks.c +++ b/blocks.c @@ -48,7 +48,7 @@ static cmark_node *make_block(cmark_node_type tag, int start_line, // Create a root document node. static cmark_node *make_document() { - cmark_node *e = make_block(NODE_DOCUMENT, 1, 1); + cmark_node *e = make_block(CMARK_NODE_DOCUMENT, 1, 1); return e; } @@ -112,14 +112,16 @@ static bool is_blank(cmark_strbuf *s, bufsize_t offset) { 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)); + return (parent_type == CMARK_NODE_DOCUMENT || + parent_type == CMARK_NODE_BLOCK_QUOTE || + parent_type == CMARK_NODE_ITEM || + (parent_type == CMARK_NODE_LIST && child_type == CMARK_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); + return (block_type == CMARK_NODE_PARAGRAPH || + block_type == CMARK_NODE_HEADING || + block_type == CMARK_NODE_CODE_BLOCK); } static void add_line(cmark_node *node, cmark_chunk *ch, bufsize_t offset) { @@ -162,7 +164,7 @@ static bool ends_with_blank_line(cmark_node *node) { if (cur->last_line_blank) { return true; } - if (cur->type == NODE_LIST || cur->type == NODE_ITEM) { + if (cur->type == CMARK_NODE_LIST || cur->type == CMARK_NODE_ITEM) { cur = cur->last_child; } else { cur = NULL; @@ -176,7 +178,7 @@ 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) { + while (b && b->type != CMARK_NODE_LIST) { b = b->last_child; } if (b) { @@ -204,9 +206,9 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { // 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)) { + } else if (b->type == CMARK_NODE_DOCUMENT || + (b->type == CMARK_NODE_CODE_BLOCK && b->as.code.fenced) || + (b->type == CMARK_NODE_HEADING && b->as.heading.setext)) { b->end_line = parser->line_number; b->end_column = parser->curline->size; if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\n') @@ -219,7 +221,7 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { } switch (b->type) { - case NODE_PARAGRAPH: + case CMARK_NODE_PARAGRAPH: while (cmark_strbuf_at(&b->string_content, 0) == '[' && (pos = cmark_parse_reference_inline(&b->string_content, parser->refmap))) { @@ -232,7 +234,7 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { } break; - case NODE_CODE_BLOCK: + case CMARK_NODE_CODE_BLOCK: if (!b->as.code.fenced) { // indented code remove_trailing_blank_lines(&b->string_content); cmark_strbuf_putc(&b->string_content, '\n'); @@ -260,11 +262,11 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { b->as.code.literal = cmark_chunk_buf_detach(&b->string_content); break; - case NODE_HTML: + case CMARK_NODE_HTML_BLOCK: b->as.literal = cmark_chunk_buf_detach(&b->string_content); break; - case NODE_LIST: // determine tight/loose status + case CMARK_NODE_LIST: // determine tight/loose status b->as.list.tight = true; // tight by default item = b->first_child; @@ -334,7 +336,8 @@ static void process_inlines(cmark_node *root, cmark_reference_map *refmap, 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) { + if (cur->type == CMARK_NODE_PARAGRAPH || + cur->type == CMARK_NODE_HEADING) { cmark_parse_inlines(cur, refmap, options); } } @@ -569,7 +572,7 @@ static void S_advance_offset(cmark_parser *parser, cmark_chunk *input, int chars_to_tab; while (count > 0 && (c = peek_at(input, parser->offset))) { if (c == '\t') { - chars_to_tab = 4 - (parser->column % TAB_STOP); + chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); parser->column += chars_to_tab; parser->offset += 1; count -= (columns ? chars_to_tab : 1); @@ -601,7 +604,7 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, } // ensure line ends with a newline: if (bytes == 0 || !S_is_line_end_char(parser->curline->ptr[bytes - 1])) { - cmark_strbuf_putc(parser->curline, '\n'); + cmark_strbuf_putc(parser->curline, '\n'); } parser->offset = 0; parser->column = 0; @@ -623,7 +626,7 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, S_find_first_nonspace(parser, &input); - if (container->type == NODE_BLOCK_QUOTE) { + if (container->type == CMARK_NODE_BLOCK_QUOTE) { matched = parser->indent <= 3 && peek_at(&input, parser->first_nonspace) == '>'; if (matched) { @@ -634,7 +637,7 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, all_matched = false; } - } else if (container->type == NODE_ITEM) { + } else if (container->type == CMARK_NODE_ITEM) { if (parser->indent >= container->as.list.marker_offset + container->as.list.padding) { S_advance_offset(parser, &input, container->as.list.marker_offset + @@ -650,7 +653,7 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, all_matched = false; } - } else if (container->type == NODE_CODE_BLOCK) { + } else if (container->type == CMARK_NODE_CODE_BLOCK) { if (!container->as.code.fenced) { // indented if (parser->indent >= CODE_INDENT) { @@ -683,12 +686,12 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, } } } - } else if (container->type == NODE_HEADER) { + } else if (container->type == CMARK_NODE_HEADING) { - // a header can never contain more than one line + // a heading can never contain more than one line all_matched = false; - } else if (container->type == NODE_HTML) { + } else if (container->type == CMARK_NODE_HTML_BLOCK) { switch (container->as.html_block_type) { case 1: @@ -710,7 +713,7 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, exit(1); } - } else if (container->type == NODE_PARAGRAPH) { + } else if (container->type == CMARK_NODE_PARAGRAPH) { if (parser->blank) { all_matched = false; @@ -730,9 +733,10 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, break_out_of_lists(parser, &container); } - maybe_lazy = parser->current->type == NODE_PARAGRAPH; + maybe_lazy = parser->current->type == CMARK_NODE_PARAGRAPH; // try new container starts: - while (container->type != NODE_CODE_BLOCK && container->type != NODE_HTML) { + while (container->type != CMARK_NODE_CODE_BLOCK && + container->type != CMARK_NODE_HTML_BLOCK) { S_find_first_nonspace(parser, &input); indented = parser->indent >= CODE_INDENT; @@ -744,16 +748,17 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, // optional following character if (peek_at(&input, parser->offset) == ' ') S_advance_offset(parser, &input, 1, false); - container = - add_child(parser, container, NODE_BLOCK_QUOTE, parser->offset + 1); + container = add_child(parser, container, CMARK_NODE_BLOCK_QUOTE, + parser->offset + 1); - } else if (!indented && (matched = scan_atx_header_start( + } else if (!indented && (matched = scan_atx_heading_start( &input, parser->first_nonspace))) { S_advance_offset(parser, &input, parser->first_nonspace + matched - parser->offset, false); - container = add_child(parser, container, NODE_HEADER, parser->offset + 1); + container = + add_child(parser, container, CMARK_NODE_HEADING, parser->offset + 1); bufsize_t hashpos = cmark_chunk_strchr(&input, '#', parser->first_nonspace); @@ -763,18 +768,19 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, level++; hashpos++; } - container->as.header.level = level; - container->as.header.setext = false; + container->as.heading.level = level; + container->as.heading.setext = false; } else if (!indented && (matched = scan_open_code_fence( &input, parser->first_nonspace))) { - container = add_child(parser, container, NODE_CODE_BLOCK, + container = add_child(parser, container, CMARK_NODE_CODE_BLOCK, parser->first_nonspace + 1); container->as.code.fenced = true; container->as.code.fence_char = peek_at(&input, parser->first_nonspace); container->as.code.fence_length = matched; - container->as.code.fence_offset = (int8_t)(parser->first_nonspace - parser->offset); + container->as.code.fence_offset = + (int8_t)(parser->first_nonspace - parser->offset); container->as.code.info = cmark_chunk_literal(""); S_advance_offset(parser, &input, parser->first_nonspace + matched - parser->offset, @@ -782,41 +788,42 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, } else if (!indented && ((matched = scan_html_block_start( &input, parser->first_nonspace)) || - (container->type != NODE_PARAGRAPH && + (container->type != CMARK_NODE_PARAGRAPH && (matched = scan_html_block_start_7( &input, parser->first_nonspace))))) { - container = - add_child(parser, container, NODE_HTML, parser->first_nonspace + 1); + container = add_child(parser, container, CMARK_NODE_HTML_BLOCK, + parser->first_nonspace + 1); container->as.html_block_type = matched; // note, we don't adjust parser->offset because the tag is part of the // text - } else if (!indented && container->type == NODE_PARAGRAPH && + } else if (!indented && container->type == CMARK_NODE_PARAGRAPH && (lev = - scan_setext_header_line(&input, parser->first_nonspace)) && + scan_setext_heading_line(&input, parser->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; + container->type = CMARK_NODE_HEADING; + container->as.heading.level = lev; + container->as.heading.setext = true; S_advance_offset(parser, &input, input.len - 1 - parser->offset, false); } else if (!indented && - !(container->type == NODE_PARAGRAPH && !all_matched) && - (matched = scan_hrule(&input, parser->first_nonspace))) { + !(container->type == CMARK_NODE_PARAGRAPH && !all_matched) && + (matched = + scan_thematic_break(&input, parser->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, parser->first_nonspace + 1); + // it's only now that we know the line is not part of a setext heading: + container = add_child(parser, container, CMARK_NODE_THEMATIC_BREAK, + parser->first_nonspace + 1); S_advance_offset(parser, &input, input.len - 1 - parser->offset, false); } else if ((matched = parse_list_marker(&input, parser->first_nonspace, &data)) && - (!indented || container->type == NODE_LIST)) { + (!indented || container->type == CMARK_NODE_LIST)) { // Note that we can have new list items starting with >= 4 // spaces indent, as long as the list container is still open. @@ -845,25 +852,25 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, data->marker_offset = parser->indent; - if (container->type != NODE_LIST || + if (container->type != CMARK_NODE_LIST || !lists_match(&container->as.list, data)) { - container = - add_child(parser, container, NODE_LIST, parser->first_nonspace + 1); + container = add_child(parser, container, CMARK_NODE_LIST, + parser->first_nonspace + 1); memcpy(&container->as.list, data, sizeof(*data)); } // add the list item - container = - add_child(parser, container, NODE_ITEM, parser->first_nonspace + 1); + container = add_child(parser, container, CMARK_NODE_ITEM, + parser->first_nonspace + 1); /* TODO: static */ memcpy(&container->as.list, data, sizeof(*data)); free(data); } else if (indented && !maybe_lazy && !parser->blank) { S_advance_offset(parser, &input, CODE_INDENT, true); - container = - add_child(parser, container, NODE_CODE_BLOCK, parser->offset + 1); + container = add_child(parser, container, CMARK_NODE_CODE_BLOCK, + parser->offset + 1); container->as.code.fenced = false; container->as.code.fence_char = 0; container->as.code.fence_length = 0; @@ -895,11 +902,12 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, // lists or breaking out of lists. we also don't set last_line_blank // on an empty list item. container->last_line_blank = - (parser->blank && container->type != NODE_BLOCK_QUOTE && - container->type != NODE_HEADER && - container->type != NODE_HRULE && - !(container->type == NODE_CODE_BLOCK && container->as.code.fenced) && - !(container->type == NODE_ITEM && container->first_child == NULL && + (parser->blank && container->type != CMARK_NODE_BLOCK_QUOTE && + container->type != CMARK_NODE_HEADING && + container->type != CMARK_NODE_THEMATIC_BREAK && + !(container->type == CMARK_NODE_CODE_BLOCK && + container->as.code.fenced) && + !(container->type == CMARK_NODE_ITEM && container->first_child == NULL && container->start_line == parser->line_number)); cmark_node *cont = container; @@ -910,7 +918,7 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, if (parser->current != last_matched_container && container == last_matched_container && !parser->blank && - parser->current->type == NODE_PARAGRAPH && + parser->current->type == CMARK_NODE_PARAGRAPH && cmark_strbuf_len(&parser->current->string_content) > 0) { add_line(parser->current, &input, parser->offset); @@ -923,11 +931,11 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, assert(parser->current != NULL); } - if (container->type == NODE_CODE_BLOCK) { + if (container->type == CMARK_NODE_CODE_BLOCK) { add_line(container, &input, parser->offset); - } else if (container->type == NODE_HTML) { + } else if (container->type == CMARK_NODE_HTML_BLOCK) { add_line(container, &input, parser->offset); @@ -974,15 +982,15 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, } else if (accepts_lines(container->type)) { - if (container->type == NODE_HEADER && - container->as.header.setext == false) { + if (container->type == CMARK_NODE_HEADING && + container->as.heading.setext == false) { chop_trailing_hashtags(&input); } add_line(container, &input, parser->first_nonspace); } else { // create paragraph container for line - container = add_child(parser, container, NODE_PARAGRAPH, + container = add_child(parser, container, CMARK_NODE_PARAGRAPH, parser->first_nonspace + 1); add_line(container, &input, parser->first_nonspace); } @@ -990,12 +998,12 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, parser->current = container; } finished: - parser->last_line_length = parser->curline->size; + parser->last_line_length = input.len; if (parser->last_line_length && - parser->curline->ptr[parser->last_line_length - 1] == '\n') + input.data[parser->last_line_length - 1] == '\n') parser->last_line_length -= 1; if (parser->last_line_length && - parser->curline->ptr[parser->last_line_length - 1] == '\r') + input.data[parser->last_line_length - 1] == '\r') parser->last_line_length -= 1; cmark_strbuf_clear(parser->curline); diff --git a/chunk.h b/chunk.h index a8a11f6..7007492 100644 --- a/chunk.h +++ b/chunk.h @@ -48,8 +48,8 @@ static CMARK_INLINE void cmark_chunk_trim(cmark_chunk *c) { cmark_chunk_rtrim(c); } -static CMARK_INLINE bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c, - bufsize_t offset) { +static CMARK_INLINE bufsize_t + cmark_chunk_strchr(cmark_chunk *ch, int c, bufsize_t offset) { const unsigned char *p = (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); return p ? (bufsize_t)(p - ch->data) : ch->len; @@ -74,8 +74,7 @@ static CMARK_INLINE const char *cmark_chunk_to_cstr(cmark_chunk *c) { return (char *)str; } -static CMARK_INLINE void -cmark_chunk_set_cstr(cmark_chunk *c, const char *str) { +static CMARK_INLINE void cmark_chunk_set_cstr(cmark_chunk *c, const char *str) { if (c->alloc) { free(c->data); } @@ -97,9 +96,8 @@ static CMARK_INLINE cmark_chunk cmark_chunk_literal(const char *data) { return c; } -static CMARK_INLINE -cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, bufsize_t pos, - bufsize_t len) { +static CMARK_INLINE cmark_chunk + cmark_chunk_dup(const cmark_chunk *ch, bufsize_t pos, bufsize_t len) { cmark_chunk c = {ch->data + pos, len, 0}; return c; } diff --git a/cmark.h b/cmark.h index 37cacd3..f9172b0 100644 --- a/cmark.h +++ b/cmark.h @@ -39,20 +39,22 @@ typedef enum { CMARK_NODE_LIST, CMARK_NODE_ITEM, CMARK_NODE_CODE_BLOCK, - CMARK_NODE_HTML, + CMARK_NODE_HTML_BLOCK, + CMARK_NODE_CUSTOM_BLOCK, CMARK_NODE_PARAGRAPH, - CMARK_NODE_HEADER, - CMARK_NODE_HRULE, + CMARK_NODE_HEADING, + CMARK_NODE_THEMATIC_BREAK, CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT, - CMARK_NODE_LAST_BLOCK = CMARK_NODE_HRULE, + CMARK_NODE_LAST_BLOCK = CMARK_NODE_THEMATIC_BREAK, /* Inline */ CMARK_NODE_TEXT, CMARK_NODE_SOFTBREAK, CMARK_NODE_LINEBREAK, CMARK_NODE_CODE, - CMARK_NODE_INLINE_HTML, + CMARK_NODE_HTML_INLINE, + CMARK_NODE_CUSTOM_INLINE, CMARK_NODE_EMPH, CMARK_NODE_STRONG, CMARK_NODE_LINK, @@ -62,6 +64,12 @@ typedef enum { CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE, } cmark_node_type; +/* For backwards compatibility: */ +#define CMARK_NODE_HEADER CMARK_NODE_HEADING +#define CMARK_NODE_HRULE CMARK_NODE_THEMATIC_BREAK +#define CMARK_NODE_HTML CMARK_NODE_HTML_BLOCK +#define CMARK_NODE_INLINE_HTML CMARK_NODE_HTML_INLINE + typedef enum { CMARK_NO_LIST, CMARK_BULLET_LIST, @@ -139,7 +147,7 @@ CMARK_EXPORT cmark_node *cmark_node_last_child(cmark_node *node); * 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. + * way, for example, turning all level-3 headings into regular paragraphs. * * void * usage_example(cmark_node *root) { @@ -157,14 +165,14 @@ CMARK_EXPORT cmark_node *cmark_node_last_child(cmark_node *node); * Iterators will never return `EXIT` events for leaf nodes, which are nodes * of type: * - * * CMARK_NODE_HTML - * * CMARK_NODE_HRULE + * * CMARK_NODE_HTML_BLOCK + * * CMARK_NODE_THEMATIC_BREAK * * CMARK_NODE_CODE_BLOCK * * CMARK_NODE_TEXT * * CMARK_NODE_SOFTBREAK * * CMARK_NODE_LINEBREAK * * CMARK_NODE_CODE - * * CMARK_NODE_INLINE_HTML + * * CMARK_NODE_HTML_INLINE * * Nodes must only be modified after an `EXIT` event, or an `ENTER` event for * leaf nodes. @@ -233,7 +241,8 @@ CMARK_EXPORT cmark_node_type cmark_node_get_type(cmark_node *node); CMARK_EXPORT const char *cmark_node_get_type_string(cmark_node *node); -/** Returns the string contents of 'node', or NULL if none. +/** Returns the string contents of 'node', or an empty + string if none is set. */ CMARK_EXPORT const char *cmark_node_get_literal(cmark_node *node); @@ -242,13 +251,17 @@ CMARK_EXPORT const char *cmark_node_get_literal(cmark_node *node); */ 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. +/** Returns the heading level of 'node', or 0 if 'node' is not a heading. */ -CMARK_EXPORT int cmark_node_get_header_level(cmark_node *node); +CMARK_EXPORT int cmark_node_get_heading_level(cmark_node *node); + +/* For backwards compatibility */ +#define cmark_node_get_header_level cmark_node_get_heading_level +#define cmark_node_set_header_level cmark_node_set_heading_level -/** Sets the header level of 'node', returning 1 on success and 0 on error. +/** Sets the heading level of 'node', returning 1 on success and 0 on error. */ -CMARK_EXPORT int cmark_node_set_header_level(cmark_node *node, int level); +CMARK_EXPORT int cmark_node_set_heading_level(cmark_node *node, int level); /** Returns the list type of 'node', or `CMARK_NO_LIST` if 'node' * is not a list. @@ -288,7 +301,7 @@ CMARK_EXPORT int cmark_node_get_list_tight(cmark_node *node); */ 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. +/** Returns the info string from a fenced code block. */ CMARK_EXPORT const char *cmark_node_get_fence_info(cmark_node *node); @@ -297,7 +310,8 @@ CMARK_EXPORT const char *cmark_node_get_fence_info(cmark_node *node); */ 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. +/** Returns the URL of a link or image 'node', or an empty string + if no URL is set. */ CMARK_EXPORT const char *cmark_node_get_url(cmark_node *node); @@ -306,7 +320,8 @@ CMARK_EXPORT const char *cmark_node_get_url(cmark_node *node); */ 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. +/** Returns the title of a link or image 'node', or an empty + string if no title is set. */ CMARK_EXPORT const char *cmark_node_get_title(cmark_node *node); @@ -315,6 +330,29 @@ CMARK_EXPORT const char *cmark_node_get_title(cmark_node *node); */ CMARK_EXPORT int cmark_node_set_title(cmark_node *node, const char *title); +/** Returns the literal "on enter" text for a custom 'node', or + an empty string if no on_enter is set. + */ +CMARK_EXPORT const char *cmark_node_get_on_enter(cmark_node *node); + +/** Sets the literal text to render "on enter" for a custom 'node'. + Any children of the node will be rendered after this text. + Returns 1 on success 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_on_enter(cmark_node *node, + const char *on_enter); + +/** Returns the literal "on exit" text for a custom 'node', or + an empty string if no on_exit is set. + */ +CMARK_EXPORT const char *cmark_node_get_on_exit(cmark_node *node); + +/** Sets the literal text to render "on exit" for a custom 'node'. + Any children of the node will be rendered before this text. + Returns 1 on success 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_on_exit(cmark_node *node, const char *on_exit); + /** Returns the line on which 'node' begins. */ CMARK_EXPORT int cmark_node_get_start_line(cmark_node *node); @@ -368,7 +406,7 @@ CMARK_EXPORT void cmark_consolidate_text_nodes(cmark_node *root); * * Simple interface: * - * cmark_node *document = cmark_parse_document("Hello *world*", 12, + * cmark_node *document = cmark_parse_document("Hello *world*", 13, * CMARK_OPT_DEFAULT); * * Streaming interface: @@ -447,38 +485,50 @@ char *cmark_render_commonmark(cmark_node *root, int options, int width); CMARK_EXPORT char *cmark_render_latex(cmark_node *root, int options, int width); -/** Default writer options. +/** + * ## Options + */ + +/** Default options. */ #define CMARK_OPT_DEFAULT 0 +/** + * ### Options affecting rendering + */ + /** Include a `data-sourcepos` attribute on all block elements. */ -#define CMARK_OPT_SOURCEPOS 1 +#define CMARK_OPT_SOURCEPOS (1 << 1) /** Render `softbreak` elements as hard line breaks. */ -#define CMARK_OPT_HARDBREAKS 2 +#define CMARK_OPT_HARDBREAKS (1 << 2) -/** Normalize tree by consolidating adjacent text nodes. +/** Suppress raw HTML and unsafe links (`javascript:`, `vbscript:`, + * `file:`, and `data:`, except for `image/png`, `image/gif`, + * `image/jpeg`, or `image/webp` mime types). Raw HTML is replaced + * by a placeholder HTML comment. Unsafe links are replaced by + * empty strings. */ -#define CMARK_OPT_NORMALIZE 4 +#define CMARK_OPT_SAFE (1 << 3) -/** Convert straight quotes to curly, --- to em dashes, -- to en dashes. +/** + * ### Options affecting parsing + */ + +/** Normalize tree by consolidating adjacent text nodes. */ -#define CMARK_OPT_SMART 8 +#define CMARK_OPT_NORMALIZE (1 << 8) /** Validate UTF-8 in the input before parsing, replacing illegal * sequences with the replacement character U+FFFD. */ -#define CMARK_OPT_VALIDATE_UTF8 16 +#define CMARK_OPT_VALIDATE_UTF8 (1 << 9) -/** Suppress raw HTML and unsafe links (`javascript:`, `vbscript:`, - * `file:`, and `data:`, except for `image/png`, `image/gif`, - * `image/jpeg`, or `image/webp` mime types). Raw HTML is replaced - * by a placeholder HTML comment. Unsafe links are replaced by - * empty strings. +/** Convert straight quotes to curly, --- to em dashes, -- to en dashes. */ -#define CMARK_OPT_SAFE 32 +#define CMARK_OPT_SMART (1 << 10) /** * ## Version information @@ -513,15 +563,19 @@ const char *cmark_version_string(); #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_HTML_BLOCK CMARK_NODE_HTML_BLOCK +#define NODE_CUSTOM_BLOCK CMARK_NODE_CUSTOM_BLOCK #define NODE_PARAGRAPH CMARK_NODE_PARAGRAPH +#define NODE_HEADING CMARK_NODE_HEADING #define NODE_HEADER CMARK_NODE_HEADER +#define NODE_THEMATIC_BREAK CMARK_NODE_THEMATIC_BREAK #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_HTML_INLINE CMARK_NODE_HTML_INLINE +#define NODE_CUSTOM_INLINE CMARK_NODE_CUSTOM_INLINE #define NODE_EMPH CMARK_NODE_EMPH #define NODE_STRONG CMARK_NODE_STRONG #define NODE_LINK CMARK_NODE_LINK diff --git a/cmark_ctype.c b/cmark_ctype.c index 863c35e..c9a9b0e 100644 --- a/cmark_ctype.c +++ b/cmark_ctype.c @@ -4,7 +4,7 @@ /** 1 = space, 2 = punct, 3 = digit, 4 = alpha, 0 = other */ -static const int8_t cmark_ctype_class[256] = { +static const uint8_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, @@ -26,17 +26,17 @@ static const int8_t cmark_ctype_class[256] = { /** * 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; } +int cmark_isspace(char c) { return cmark_ctype_class[(uint8_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_ispunct(char c) { return cmark_ctype_class[(uint8_t)c] == 2; } int cmark_isalnum(char c) { - int8_t result; - result = cmark_ctype_class[(int8_t)c]; + uint8_t result; + result = cmark_ctype_class[(uint8_t)c]; return (result == 3 || result == 4); } -int cmark_isdigit(char c) { return cmark_ctype_class[(int8_t)c] == 3; } +int cmark_isdigit(char c) { return cmark_ctype_class[(uint8_t)c] == 3; } diff --git a/cmark_version.h b/cmark_version.h index 2084b2c..434eb00 100644 --- a/cmark_version.h +++ b/cmark_version.h @@ -1,7 +1,7 @@ #ifndef CMARK_VERSION_H #define CMARK_VERSION_H -#define CMARK_VERSION ((0 << 16) | (22 << 8) | 0) -#define CMARK_VERSION_STRING "0.22.0" +#define CMARK_VERSION ((0 << 16) | (23 << 8) | 0) +#define CMARK_VERSION_STRING "0.23.0" #endif diff --git a/commonmark.c b/commonmark.c index da81623..69bd2b1 100644 --- a/commonmark.c +++ b/commonmark.c @@ -31,7 +31,7 @@ static inline void outc(cmark_renderer *renderer, cmark_escaping escape, (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' || c == '>' || c == '\\' || c == '`' || c == '!' || (c == '&' && isalpha(nextc)) || (c == '!' && nextc == '[') || - (renderer->begin_line && (c == '-' || c == '+' || c == '=')) || + (renderer->begin_content && (c == '-' || c == '+' || c == '=')) || ((c == '.' || c == ')') && isdigit(renderer->buffer->ptr[renderer->buffer->size - 1])))) || (escape == URL && (c == '`' || c == '<' || c == '>' || isspace(c) || @@ -95,7 +95,7 @@ static int shortest_unused_backtick_sequence(const char *code) { used = used >> 1; i++; } - return i; + return (int)i; } static bool is_autolink(cmark_node *node) { @@ -176,6 +176,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, case CMARK_NODE_BLOCK_QUOTE: if (entering) { LIT("> "); + renderer->begin_content = true; cmark_strbuf_puts(renderer->prefix, "> "); } else { cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 2); @@ -214,9 +215,11 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, if (entering) { if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { LIT("* "); + renderer->begin_content = true; cmark_strbuf_puts(renderer->prefix, " "); } else { LIT(listmarker); + renderer->begin_content = true; for (i = marker_width; i--;) { cmark_strbuf_putc(renderer->prefix, ' '); } @@ -228,12 +231,13 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, } break; - case CMARK_NODE_HEADER: + case CMARK_NODE_HEADING: if (entering) { - for (int i = cmark_node_get_header_level(node); i > 0; i--) { + for (i = cmark_node_get_heading_level(node); i > 0; i--) { LIT("#"); } LIT(" "); + renderer->begin_content = true; renderer->no_wrap = true; } else { renderer->no_wrap = false; @@ -279,13 +283,20 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, BLANKLINE(); break; - case CMARK_NODE_HTML: + case CMARK_NODE_HTML_BLOCK: BLANKLINE(); OUT(cmark_node_get_literal(node), false, LITERAL); BLANKLINE(); break; - case CMARK_NODE_HRULE: + case CMARK_NODE_CUSTOM_BLOCK: + BLANKLINE(); + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); + BLANKLINE(); + break; + + case CMARK_NODE_THEMATIC_BREAK: BLANKLINE(); LIT("-----"); BLANKLINE(); @@ -335,10 +346,15 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, } break; - case CMARK_NODE_INLINE_HTML: + case CMARK_NODE_HTML_INLINE: OUT(cmark_node_get_literal(node), false, LITERAL); break; + case CMARK_NODE_CUSTOM_INLINE: + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); + break; + case CMARK_NODE_STRONG: if (entering) { LIT("**"); @@ -368,9 +384,9 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, if (entering) { LIT("<"); if (strncmp(cmark_node_get_url(node), "mailto:", 7) == 0) { - LIT((char *)cmark_node_get_url(node) + 7); + LIT((const char *)cmark_node_get_url(node) + 7); } else { - LIT((char *)cmark_node_get_url(node)); + LIT((const char *)cmark_node_get_url(node)); } LIT(">"); // return signal to skip contents of node... diff --git a/commonmark_test.go b/commonmark_test.go index c9a8728..332e21d 100644 --- a/commonmark_test.go +++ b/commonmark_test.go @@ -88,8 +88,8 @@ func TestCMarkNodeOps(t *testing.T) { if root.GetNodeTypeString() != "document" { t.Error("Root is wrong type string!") } - header1 := commonmark.NewCMarkNode(commonmark.CMARK_NODE_HEADER) - if header1.GetNodeType() != commonmark.CMARK_NODE_HEADER { + header1 := commonmark.NewCMarkNode(commonmark.CMARK_NODE_HEADING) + if header1.GetNodeType() != commonmark.CMARK_NODE_HEADING { t.Error("header1 is wrong type!") } header1.SetHeaderLevel(1) @@ -102,7 +102,7 @@ func TestCMarkNodeOps(t *testing.T) { t.Error("header1str content is wrong!") } header1.AppendChild(header1str) - header2 := commonmark.NewCMarkNode(commonmark.CMARK_NODE_HEADER) + header2 := commonmark.NewCMarkNode(commonmark.CMARK_NODE_HEADING) header2str := commonmark.NewCMarkNode(commonmark.CMARK_NODE_TEXT) if header2str.SetLiteral("Another header!") == false { t.Error("SetLiteral returned false for valid input") @@ -113,6 +113,15 @@ func TestCMarkNodeOps(t *testing.T) { t.Error("Couldn't prepend header to root") } root.AppendChild(header2) + custom := commonmark.NewCMarkNode(commonmark.CMARK_NODE_CUSTOM_BLOCK) + custom.SetOnEnter("ENTER") + custom.SetOnExit("EXIT") + if custom.GetOnEnter() != "ENTER" { + t.Errorf("OnEnter not set correctly: %v", custom.GetOnEnter()) + } + if custom.GetOnExit() != "EXIT" { + t.Errorf("OnExit not set correctly: %v", custom.GetOnExit()) + } t.Logf("\nXML: %v", root.RenderXML(commonmark.CMARK_OPT_DEFAULT)) htmlStr := root.RenderHtml(commonmark.CMARK_OPT_DEFAULT) @@ -262,8 +271,8 @@ func TestCMarkIter(t *testing.T) { func createTree() *commonmark.CMarkNode { root := commonmark.NewCMarkNode(commonmark.CMARK_NODE_DOCUMENT) - header1 := commonmark.NewCMarkNode(commonmark.CMARK_NODE_HEADER) - header2 := commonmark.NewCMarkNode(commonmark.CMARK_NODE_HEADER) + header1 := commonmark.NewCMarkNode(commonmark.CMARK_NODE_HEADING) + header2 := commonmark.NewCMarkNode(commonmark.CMARK_NODE_HEADING) header1str := commonmark.NewCMarkNode(commonmark.CMARK_NODE_TEXT) header2str := commonmark.NewCMarkNode(commonmark.CMARK_NODE_TEXT) header1str.SetLiteral("Header 1!") diff --git a/houdini_html_u.c b/houdini_html_u.c index a2d927b..6e8d620 100644 --- a/houdini_html_u.c +++ b/houdini_html_u.c @@ -9,12 +9,13 @@ /* Binary tree lookup code for entities added by JGM */ -static unsigned char *S_lookup(int i, int low, int hi, const unsigned char *s, - int len) { +static const unsigned char *S_lookup(int i, int low, int hi, + const unsigned char *s, int len) { int j; - int cmp = strncmp((char *)s, (char *)cmark_entities[i].entity, len); + int cmp = + strncmp((const char *)s, (const char *)cmark_entities[i].entity, len); if (cmp == 0 && cmark_entities[i].entity[len] == 0) { - return (unsigned char *)cmark_entities[i].bytes; + return (const unsigned char *)cmark_entities[i].bytes; } else if (cmp < 0 && i > low) { j = i - ((i - low) / 2); if (j == i) @@ -30,7 +31,7 @@ static unsigned char *S_lookup(int i, int low, int hi, const unsigned char *s, } } -static unsigned char *S_lookup_entity(const unsigned char *s, int len) { +static const unsigned char *S_lookup_entity(const unsigned char *s, int len) { return S_lookup(CMARK_NUM_ENTITIES / 2, 0, CMARK_NUM_ENTITIES - 1, s, len); } diff --git a/html.c b/html.c index dfe2aec..7493596 100644 --- a/html.c +++ b/html.c @@ -43,8 +43,8 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, cmark_node *parent; cmark_node *grandparent; cmark_strbuf *html = state->html; - char start_header[] = "type) { case CMARK_NODE_TEXT: case CMARK_NODE_CODE: - case CMARK_NODE_INLINE_HTML: + case CMARK_NODE_HTML_INLINE: escape_html(html, node->as.literal.data, node->as.literal.len); break; @@ -127,16 +127,16 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, } break; - case CMARK_NODE_HEADER: + case CMARK_NODE_HEADING: if (entering) { cr(html); - start_header[2] = (char)('0' + node->as.header.level); - cmark_strbuf_puts(html, start_header); + start_heading[2] = (char)('0' + node->as.heading.level); + cmark_strbuf_puts(html, start_heading); S_render_sourcepos(node, html, options); cmark_strbuf_putc(html, '>'); } else { - end_header[3] = (char)('0' + node->as.header.level); - cmark_strbuf_puts(html, end_header); + end_heading[3] = (char)('0' + node->as.heading.level); + cmark_strbuf_puts(html, end_heading); cmark_strbuf_puts(html, ">\n"); } break; @@ -166,7 +166,7 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, cmark_strbuf_puts(html, "\n"); break; - case CMARK_NODE_HTML: + case CMARK_NODE_HTML_BLOCK: cr(html); if (options & CMARK_OPT_SAFE) { cmark_strbuf_puts(html, ""); @@ -176,7 +176,19 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, cr(html); break; - case CMARK_NODE_HRULE: + case CMARK_NODE_CUSTOM_BLOCK: + cr(html); + if (entering) { + cmark_strbuf_put(html, node->as.custom.on_enter.data, + node->as.custom.on_enter.len); + } else { + cmark_strbuf_put(html, node->as.custom.on_exit.data, + node->as.custom.on_exit.len); + } + cr(html); + break; + + case CMARK_NODE_THEMATIC_BREAK: cr(html); cmark_strbuf_puts(html, ""); break; - case CMARK_NODE_INLINE_HTML: + case CMARK_NODE_HTML_INLINE: if (options & CMARK_OPT_SAFE) { cmark_strbuf_puts(html, ""); } else { @@ -233,6 +245,16 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, } break; + case CMARK_NODE_CUSTOM_INLINE: + if (entering) { + cmark_strbuf_put(html, node->as.custom.on_enter.data, + node->as.custom.on_enter.len); + } else { + cmark_strbuf_put(html, node->as.custom.on_exit.data, + node->as.custom.on_exit.len); + } + break; + case CMARK_NODE_STRONG: if (entering) { cmark_strbuf_puts(html, ""); diff --git a/inlines.c b/inlines.c index 3275ddd..1199831 100644 --- a/inlines.c +++ b/inlines.c @@ -24,7 +24,7 @@ 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_raw_html(s) make_literal(CMARK_NODE_HTML_INLINE, 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) @@ -284,7 +284,7 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open, before_char_pos -= 1; } len = cmark_utf8proc_iterate(subj->input.data + before_char_pos, - subj->pos - before_char_pos, &before_char); + subj->pos - before_char_pos, &before_char); if (len == -1) { before_char = 10; } @@ -301,7 +301,7 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open, } len = cmark_utf8proc_iterate(subj->input.data + subj->pos, - subj->input.len - subj->pos, &after_char); + subj->input.len - subj->pos, &after_char); if (len == -1) { after_char = 10; } @@ -309,10 +309,10 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open, !(cmark_utf8proc_is_punctuation(after_char) && !cmark_utf8proc_is_space(before_char) && !cmark_utf8proc_is_punctuation(before_char)); - right_flanking = - numdelims > 0 && !cmark_utf8proc_is_space(before_char) && - !(cmark_utf8proc_is_punctuation(before_char) && - !cmark_utf8proc_is_space(after_char) && !cmark_utf8proc_is_punctuation(after_char)); + right_flanking = numdelims > 0 && !cmark_utf8proc_is_space(before_char) && + !(cmark_utf8proc_is_punctuation(before_char) && + !cmark_utf8proc_is_space(after_char) && + !cmark_utf8proc_is_punctuation(after_char)); if (c == '_') { *can_open = left_flanking && (!right_flanking || cmark_utf8proc_is_punctuation(before_char)); @@ -865,7 +865,6 @@ static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) { // 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) { @@ -944,10 +943,10 @@ static cmark_node *handle_newline(subject *subj) { bufsize_t nlpos = subj->pos; // skip over cr, crlf, or lf: if (peek_at(subj, subj->pos) == '\r') { - advance(subj); + advance(subj); } if (peek_at(subj, subj->pos) == '\n') { - advance(subj); + advance(subj); } // skip spaces at beginning of line skip_spaces(subj); diff --git a/iterator.c b/iterator.c index 19dfff8..c477f01 100644 --- a/iterator.c +++ b/iterator.c @@ -7,10 +7,10 @@ #include "iterator.h" static const int S_leaf_mask = - (1 << CMARK_NODE_HTML) | (1 << CMARK_NODE_HRULE) | + (1 << CMARK_NODE_HTML_BLOCK) | (1 << CMARK_NODE_THEMATIC_BREAK) | (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); + (1 << CMARK_NODE_CODE) | (1 << CMARK_NODE_HTML_INLINE); cmark_iter *cmark_iter_new(cmark_node *root) { if (root == NULL) { diff --git a/latex.c b/latex.c index 146062e..57d474c 100644 --- a/latex.c +++ b/latex.c @@ -142,7 +142,13 @@ static inline void outc(cmark_renderer *renderer, cmark_escaping escape, } } -typedef enum { NO_LINK, URL_AUTOLINK, EMAIL_AUTOLINK, NORMAL_LINK } link_type; +typedef enum { + NO_LINK, + URL_AUTOLINK, + EMAIL_AUTOLINK, + NORMAL_LINK, + INTERNAL_LINK +} link_type; static link_type get_link_type(cmark_node *node) { size_t title_len, url_len; @@ -158,6 +164,10 @@ static link_type get_link_type(cmark_node *node) { const char *url = cmark_node_get_url(node); cmark_chunk url_chunk = cmark_chunk_literal(url); + if (url && *url == '#') { + return INTERNAL_LINK; + } + url_len = safe_strlen(url); if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) { return NO_LINK; @@ -166,30 +176,29 @@ static link_type get_link_type(cmark_node *node) { const char *title = cmark_node_get_title(node); title_len = safe_strlen(title); // if it has a title, we can't treat it as an autolink: - if (title_len > 0) { - return NORMAL_LINK; - } - - link_text = node->first_child; - cmark_consolidate_text_nodes(link_text); - realurl = (char *)url; - realurllen = url_len; - if (strncmp(realurl, "mailto:", 7) == 0) { - realurl += 7; - realurllen -= 7; - isemail = true; - } - if (realurllen == link_text->as.literal.len && - strncmp(realurl, (char *)link_text->as.literal.data, - link_text->as.literal.len) == 0) { - if (isemail) { - return EMAIL_AUTOLINK; - } else { - return URL_AUTOLINK; + if (title_len == 0) { + + link_text = node->first_child; + cmark_consolidate_text_nodes(link_text); + realurl = (char *)url; + realurllen = url_len; + if (strncmp(realurl, "mailto:", 7) == 0) { + realurl += 7; + realurllen -= 7; + isemail = true; + } + if (realurllen == link_text->as.literal.len && + strncmp(realurl, (char *)link_text->as.literal.data, + link_text->as.literal.len) == 0) { + if (isemail) { + return EMAIL_AUTOLINK; + } else { + return URL_AUTOLINK; + } } - } else { - return NORMAL_LINK; } + + return NORMAL_LINK; } static int S_get_enumlevel(cmark_node *node) { @@ -264,9 +273,9 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, } break; - case CMARK_NODE_HEADER: + case CMARK_NODE_HEADING: if (entering) { - switch (cmark_node_get_header_level(node)) { + switch (cmark_node_get_heading_level(node)) { case 1: LIT("\\section"); break; @@ -300,10 +309,17 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, BLANKLINE(); break; - case CMARK_NODE_HTML: + case CMARK_NODE_HTML_BLOCK: break; - case CMARK_NODE_HRULE: + case CMARK_NODE_CUSTOM_BLOCK: + CR(); + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); + CR(); + break; + + case CMARK_NODE_THEMATIC_BREAK: BLANKLINE(); LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}"); BLANKLINE(); @@ -338,7 +354,12 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, LIT("}"); break; - case CMARK_NODE_INLINE_HTML: + case CMARK_NODE_HTML_INLINE: + break; + + case CMARK_NODE_CUSTOM_INLINE: + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); break; case CMARK_NODE_STRONG: @@ -376,6 +397,11 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, OUT(url, false, URL); LIT("}{"); break; + case INTERNAL_LINK: + LIT("\\protect\\hyperlink{"); + OUT(url + 1, false, URL); + LIT("}{"); + break; case NO_LINK: LIT("{"); // error? } diff --git a/man.c b/man.c index 8e3913e..99a2803 100644 --- a/man.c +++ b/man.c @@ -120,10 +120,10 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, } break; - case CMARK_NODE_HEADER: + case CMARK_NODE_HEADING: if (entering) { CR(); - LIT(cmark_node_get_header_level(node) == 1 ? ".SH" : ".SS"); + LIT(cmark_node_get_heading_level(node) == 1 ? ".SH" : ".SS"); CR(); } else { CR(); @@ -139,10 +139,17 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, CR(); break; - case CMARK_NODE_HTML: + case CMARK_NODE_HTML_BLOCK: break; - case CMARK_NODE_HRULE: + case CMARK_NODE_CUSTOM_BLOCK: + CR(); + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); + CR(); + break; + + case CMARK_NODE_THEMATIC_BREAK: CR(); LIT(".PP\n * * * * *"); CR(); @@ -187,7 +194,12 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, LIT("\\f[]"); break; - case CMARK_NODE_INLINE_HTML: + case CMARK_NODE_HTML_INLINE: + break; + + case CMARK_NODE_CUSTOM_INLINE: + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); break; case CMARK_NODE_STRONG: diff --git a/node.c b/node.c index 46d234a..d4c39cc 100644 --- a/node.c +++ b/node.c @@ -46,17 +46,19 @@ static bool S_can_contain(cmark_node *node, cmark_node *child) { case CMARK_NODE_DOCUMENT: case CMARK_NODE_BLOCK_QUOTE: case CMARK_NODE_ITEM: + case CMARK_NODE_CUSTOM_BLOCK: 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_HEADING: case CMARK_NODE_EMPH: case CMARK_NODE_STRONG: case CMARK_NODE_LINK: case CMARK_NODE_IMAGE: + case CMARK_NODE_CUSTOM_INLINE: return S_is_inline(child); default: @@ -71,8 +73,8 @@ cmark_node *cmark_node_new(cmark_node_type type) { node->type = type; switch (node->type) { - case CMARK_NODE_HEADER: - node->as.header.level = 1; + case CMARK_NODE_HEADING: + node->as.heading.level = 1; break; case CMARK_NODE_LIST: { @@ -98,21 +100,26 @@ static void S_free_nodes(cmark_node *e) { cmark_strbuf_free(&e->string_content); } switch (e->type) { - case NODE_CODE_BLOCK: + case CMARK_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: + case CMARK_NODE_TEXT: + case CMARK_NODE_HTML_INLINE: + case CMARK_NODE_CODE: + case CMARK_NODE_HTML_BLOCK: cmark_chunk_free(&e->as.literal); break; - case NODE_LINK: - case NODE_IMAGE: + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: cmark_chunk_free(&e->as.link.url); cmark_chunk_free(&e->as.link.title); break; + case CMARK_NODE_CUSTOM_BLOCK: + case CMARK_NODE_CUSTOM_INLINE: + cmark_chunk_free(&e->as.custom.on_enter); + cmark_chunk_free(&e->as.custom.on_exit); + break; default: break; } @@ -159,14 +166,16 @@ const char *cmark_node_get_type_string(cmark_node *node) { return "item"; case CMARK_NODE_CODE_BLOCK: return "code_block"; - case CMARK_NODE_HTML: - return "html"; + case CMARK_NODE_HTML_BLOCK: + return "html_block"; + case CMARK_NODE_CUSTOM_BLOCK: + return "raw_block"; case CMARK_NODE_PARAGRAPH: return "paragraph"; - case CMARK_NODE_HEADER: - return "header"; - case CMARK_NODE_HRULE: - return "hrule"; + case CMARK_NODE_HEADING: + return "heading"; + case CMARK_NODE_THEMATIC_BREAK: + return "thematic_break"; case CMARK_NODE_TEXT: return "text"; case CMARK_NODE_SOFTBREAK: @@ -175,8 +184,10 @@ const char *cmark_node_get_type_string(cmark_node *node) { return "linebreak"; case CMARK_NODE_CODE: return "code"; - case CMARK_NODE_INLINE_HTML: - return "inline_html"; + case CMARK_NODE_HTML_INLINE: + return "html_inline"; + case CMARK_NODE_CUSTOM_INLINE: + return "raw_inline"; case CMARK_NODE_EMPH: return "emph"; case CMARK_NODE_STRONG: @@ -252,13 +263,13 @@ const char *cmark_node_get_literal(cmark_node *node) { } switch (node->type) { - case NODE_HTML: - case NODE_TEXT: - case NODE_INLINE_HTML: - case NODE_CODE: + case CMARK_NODE_HTML_BLOCK: + case CMARK_NODE_TEXT: + case CMARK_NODE_HTML_INLINE: + case CMARK_NODE_CODE: return cmark_chunk_to_cstr(&node->as.literal); - case NODE_CODE_BLOCK: + case CMARK_NODE_CODE_BLOCK: return cmark_chunk_to_cstr(&node->as.code.literal); default: @@ -274,14 +285,14 @@ int cmark_node_set_literal(cmark_node *node, const char *content) { } switch (node->type) { - case NODE_HTML: - case NODE_TEXT: - case NODE_INLINE_HTML: - case NODE_CODE: + case CMARK_NODE_HTML_BLOCK: + case CMARK_NODE_TEXT: + case CMARK_NODE_HTML_INLINE: + case CMARK_NODE_CODE: cmark_chunk_set_cstr(&node->as.literal, content); return 1; - case NODE_CODE_BLOCK: + case CMARK_NODE_CODE_BLOCK: cmark_chunk_set_cstr(&node->as.code.literal, content); return 1; @@ -292,14 +303,14 @@ int cmark_node_set_literal(cmark_node *node, const char *content) { return 0; } -int cmark_node_get_header_level(cmark_node *node) { +int cmark_node_get_heading_level(cmark_node *node) { if (node == NULL) { return 0; } switch (node->type) { - case CMARK_NODE_HEADER: - return node->as.header.level; + case CMARK_NODE_HEADING: + return node->as.heading.level; default: break; @@ -308,14 +319,14 @@ int cmark_node_get_header_level(cmark_node *node) { return 0; } -int cmark_node_set_header_level(cmark_node *node, int level) { +int cmark_node_set_heading_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; + case CMARK_NODE_HEADING: + node->as.heading.level = level; return 1; default: @@ -438,7 +449,7 @@ const char *cmark_node_get_fence_info(cmark_node *node) { return NULL; } - if (node->type == NODE_CODE_BLOCK) { + if (node->type == CMARK_NODE_CODE_BLOCK) { return cmark_chunk_to_cstr(&node->as.code.info); } else { return NULL; @@ -450,7 +461,7 @@ int cmark_node_set_fence_info(cmark_node *node, const char *info) { return 0; } - if (node->type == NODE_CODE_BLOCK) { + if (node->type == CMARK_NODE_CODE_BLOCK) { cmark_chunk_set_cstr(&node->as.code.info, info); return 1; } else { @@ -464,8 +475,8 @@ const char *cmark_node_get_url(cmark_node *node) { } switch (node->type) { - case NODE_LINK: - case NODE_IMAGE: + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: return cmark_chunk_to_cstr(&node->as.link.url); default: break; @@ -480,8 +491,8 @@ int cmark_node_set_url(cmark_node *node, const char *url) { } switch (node->type) { - case NODE_LINK: - case NODE_IMAGE: + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: cmark_chunk_set_cstr(&node->as.link.url, url); return 1; default: @@ -497,8 +508,8 @@ const char *cmark_node_get_title(cmark_node *node) { } switch (node->type) { - case NODE_LINK: - case NODE_IMAGE: + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: return cmark_chunk_to_cstr(&node->as.link.title); default: break; @@ -513,8 +524,8 @@ int cmark_node_set_title(cmark_node *node, const char *title) { } switch (node->type) { - case NODE_LINK: - case NODE_IMAGE: + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: cmark_chunk_set_cstr(&node->as.link.title, title); return 1; default: @@ -524,6 +535,72 @@ int cmark_node_set_title(cmark_node *node, const char *title) { return 0; } +const char *cmark_node_get_on_enter(cmark_node *node) { + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case CMARK_NODE_CUSTOM_INLINE: + case CMARK_NODE_CUSTOM_BLOCK: + return cmark_chunk_to_cstr(&node->as.custom.on_enter); + default: + break; + } + + return NULL; +} + +int cmark_node_set_on_enter(cmark_node *node, const char *on_enter) { + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_CUSTOM_INLINE: + case CMARK_NODE_CUSTOM_BLOCK: + cmark_chunk_set_cstr(&node->as.custom.on_enter, on_enter); + return 1; + default: + break; + } + + return 0; +} + +const char *cmark_node_get_on_exit(cmark_node *node) { + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case CMARK_NODE_CUSTOM_INLINE: + case CMARK_NODE_CUSTOM_BLOCK: + return cmark_chunk_to_cstr(&node->as.custom.on_exit); + default: + break; + } + + return NULL; +} + +int cmark_node_set_on_exit(cmark_node *node, const char *on_exit) { + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_CUSTOM_INLINE: + case CMARK_NODE_CUSTOM_BLOCK: + cmark_chunk_set_cstr(&node->as.custom.on_exit, on_exit); + return 1; + default: + break; + } + + return 0; +} + int cmark_node_get_start_line(cmark_node *node) { if (node == NULL) { return 0; diff --git a/node.go b/node.go index 56c402a..95247b6 100644 --- a/node.go +++ b/node.go @@ -22,24 +22,26 @@ const ( CMARK_NODE_LIST CMARK_NODE_ITEM CMARK_NODE_CODE_BLOCK - CMARK_NODE_HTML + CMARK_NODE_HTML_BLOCK + CMARK_NODE_CUSTOM_BLOCK CMARK_NODE_PARAGRAPH - CMARK_NODE_HEADER - CMARK_NODE_HRULE + CMARK_NODE_HEADING + CMARK_NODE_THEMATIC_BREAK //Inline CMARK_NODE_TEXT CMARK_NODE_SOFTBREAK CMARK_NODE_LINEBREAK CMARK_NODE_CODE - CMARK_NODE_INLINE_HTML + CMARK_NODE_HTML_INLINE + CMARK_NODE_CUSTOM_INLINE CMARK_NODE_EMPH CMARK_NODE_STRONG CMARK_NODE_LINK CMARK_NODE_IMAGE //Block CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT - CMARK_NODE_LAST_BLOCK = CMARK_NODE_HRULE + CMARK_NODE_LAST_BLOCK = CMARK_NODE_THEMATIC_BREAK //Inline CMARK_NODE_FIRST_INLINE = CMARK_NODE_TEXT CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE @@ -314,6 +316,38 @@ func (node *CMarkNode) GetTitle() string { return C.GoString(cstr) } +//Returns the literal "on enter" text for a custom node, or an empty +//string if no on_enter is set +func (node *CMarkNode) GetOnEnter() string { + cstr := C.cmark_node_get_on_enter(node.node) + return C.GoString(cstr) +} + +//Sets the literal text to render "on enter" for a custom node. +//Any children of the node will be rendered after this text. +//Returns true on success and false on failure +func (node *CMarkNode) SetOnEnter(onEnter string) bool { + cstr := C.CString(onEnter) + defer C.free(unsafe.Pointer(cstr)) + return success(C.cmark_node_set_on_enter(node.node, cstr)) +} + +//Returns the literal "on exit" text for a custom node, or an empty +//string if no on_exit is set +func (node *CMarkNode) GetOnExit() string { + cstr := C.cmark_node_get_on_exit(node.node) + return C.GoString(cstr) +} + +//Sets the literal text to render "on exit" for a custom node. +//Any children of the node will be rendered before this text. +//Returns true on success and false on failure +func (node *CMarkNode) SetOnExit(onExit string) bool { + cstr := C.CString(onExit) + defer C.free(unsafe.Pointer(cstr)) + return success(C.cmark_node_set_on_exit(node.node, cstr)) +} + //Returns the line on which 'node' begins func (node *CMarkNode) GetStartLine() int { return int(C.cmark_node_get_start_line(node.node)) diff --git a/node.h b/node.h index 48d12df..397d8e3 100644 --- a/node.h +++ b/node.h @@ -35,13 +35,18 @@ typedef struct { typedef struct { int level; bool setext; -} cmark_header; +} cmark_heading; typedef struct { cmark_chunk url; cmark_chunk title; } cmark_link; +typedef struct { + cmark_chunk on_enter; + cmark_chunk on_exit; +} cmark_custom; + struct cmark_node { struct cmark_node *next; struct cmark_node *prev; @@ -67,8 +72,9 @@ struct cmark_node { cmark_chunk literal; cmark_list list; cmark_code code; - cmark_header header; + cmark_heading heading; cmark_link link; + cmark_custom custom; int html_block_type; } as; }; diff --git a/render.c b/render.c index f1ec672..d477363 100644 --- a/render.c +++ b/render.c @@ -44,6 +44,7 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, } renderer->column = 0; renderer->begin_line = true; + renderer->begin_content = true; renderer->need_cr -= 1; } @@ -65,6 +66,7 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, cmark_strbuf_putc(renderer->buffer, ' '); renderer->column += 1; renderer->begin_line = false; + renderer->begin_content = false; renderer->last_breakable = renderer->buffer->size - 1; // skip following spaces while (source[i + 1] == ' ') { @@ -76,13 +78,16 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, cmark_strbuf_putc(renderer->buffer, '\n'); renderer->column = 0; renderer->begin_line = true; + renderer->begin_content = true; renderer->last_breakable = 0; } else if (escape == LITERAL) { cmark_render_code_point(renderer, c); renderer->begin_line = false; + renderer->begin_content = false; } else { (renderer->outc)(renderer, escape, c, nextc); renderer->begin_line = false; + renderer->begin_content = false; } // If adding the character went beyond width, look for an @@ -104,6 +109,7 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, cmark_chunk_free(&remainder); renderer->last_breakable = 0; renderer->begin_line = false; + renderer->begin_content = false; } i += len; @@ -136,7 +142,8 @@ char *cmark_render(cmark_node *root, int options, int width, cmark_iter *iter = cmark_iter_new(root); cmark_renderer renderer = {&buf, &pref, 0, width, 0, 0, true, - false, false, outc, S_cr, S_blankline, S_out}; + false, false, false, + outc, S_cr, S_blankline, S_out}; while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { cur = cmark_iter_get_node(iter); diff --git a/render.h b/render.h index 9ab347b..479936a 100644 --- a/render.h +++ b/render.h @@ -19,6 +19,7 @@ struct cmark_renderer { int need_cr; bufsize_t last_breakable; bool begin_line; + bool begin_content; bool no_wrap; bool in_tight_list_item; void (*outc)(struct cmark_renderer *, cmark_escaping, int32_t, unsigned char); diff --git a/scanners.c b/scanners.c index 7868e01..ae4125f 100644 --- a/scanners.c +++ b/scanners.c @@ -1,4 +1,4 @@ -/* Generated by re2c 0.14.3 */ +/* Generated by re2c 0.15.3 */ #include #include "chunk.h" #include "scanners.h" @@ -7,11 +7,16 @@ bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, bufsize_t offset) { bufsize_t 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; + if (ptr == NULL || offset > c->len) { + return 0; + } else { + unsigned char lim = ptr[c->len]; + + ptr[c->len] = '\0'; + res = scanner(ptr + offset); + ptr[c->len] = lim; + } return res; } @@ -23,7 +28,6 @@ bufsize_t _scan_scheme(const unsigned char *p) { { unsigned char yych; - yych = *(marker = p); if (yych <= 'c') { if (yych <= 'M') { @@ -493,50 +497,24 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yy15: yych = *(marker = ++p); - if (yych <= 'S') { - if (yych <= 'L') { - if (yych == 'A') - goto yy232; - if (yych <= 'K') - goto yy2; - goto yy231; - } else { - if (yych <= 'O') { - if (yych <= 'N') - goto yy2; - goto yy233; - } else { - if (yych <= 'Q') - goto yy2; - if (yych <= 'R') - goto yy230; - goto yy229; - } - } - } else { - if (yych <= 'n') { - if (yych <= 'a') { - if (yych <= '`') - goto yy2; - goto yy232; - } else { - if (yych == 'l') - goto yy231; - goto yy2; - } - } else { - if (yych <= 'q') { - if (yych <= 'o') - goto yy233; - goto yy2; - } else { - if (yych <= 'r') - goto yy230; - if (yych <= 's') - goto yy229; - goto yy2; - } - } + switch (yych) { + case 'A': + case 'a': + goto yy232; + case 'L': + case 'l': + goto yy231; + case 'O': + case 'o': + goto yy233; + case 'R': + case 'r': + goto yy230; + case 'S': + case 's': + goto yy229; + default: + goto yy2; } yy16: yych = *(marker = ++p); @@ -4693,50 +4671,24 @@ bufsize_t _scan_autolink_uri(const unsigned char *p) { } yy507: yych = *(marker = ++p); - if (yych <= 'S') { - if (yych <= 'L') { - if (yych == 'A') - goto yy733; - if (yych <= 'K') - goto yy494; - goto yy732; - } else { - if (yych <= 'O') { - if (yych <= 'N') - goto yy494; - goto yy734; - } else { - if (yych <= 'Q') - goto yy494; - if (yych <= 'R') - goto yy731; - goto yy730; - } - } - } else { - if (yych <= 'n') { - if (yych <= 'a') { - if (yych <= '`') - goto yy494; - goto yy733; - } else { - if (yych == 'l') - goto yy732; - goto yy494; - } - } else { - if (yych <= 'q') { - if (yych <= 'o') - goto yy734; - goto yy494; - } else { - if (yych <= 'r') - goto yy731; - if (yych <= 's') - goto yy730; - goto yy494; - } - } + switch (yych) { + case 'A': + case 'a': + goto yy733; + case 'L': + case 'l': + goto yy732; + case 'O': + case 'o': + goto yy734; + case 'R': + case 'r': + goto yy731; + case 'S': + case 's': + goto yy730; + default: + goto yy494; } yy508: yych = *(marker = ++p); @@ -8697,14 +8649,14 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1011; + goto yy1012; } else { if (yych <= '/') goto yy999; - if (yych <= '9') - goto yy1011; - goto yy999; + if (yych >= ':') + goto yy999; } } else { if (yych <= 'Z') { @@ -8712,48 +8664,26 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1011; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1011; - goto yy999; - } - } - yych = *++p; - if (yych <= '9') { - if (yych == '-') - goto yy1139; - if (yych <= '/') - goto yy999; - goto yy1140; - } else { - if (yych <= 'Z') { - if (yych <= '@') - goto yy999; - goto yy1140; - } else { - if (yych <= '`') + if (yych >= '{') goto yy999; - if (yych <= 'z') - goto yy1140; - goto yy999; } } - yy1011: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; if (yych <= '-') - goto yy1139; + goto yy1140; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1140; + goto yy1139; goto yy999; } } else { @@ -8762,12 +8692,33 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; + goto yy1139; + } else { + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1139; + goto yy999; + } + } + yy1011: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy1140; + if (yych <= '/') + goto yy999; + goto yy1139; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + goto yy1139; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1140; + goto yy1139; goto yy999; } } @@ -8799,14 +8750,14 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1017; + goto yy1012; } else { if (yych <= '/') goto yy999; - if (yych <= '9') - goto yy1017; - goto yy999; + if (yych >= ':') + goto yy999; } } else { if (yych <= 'Z') { @@ -8814,50 +8765,27 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1017; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1017; - goto yy999; - } - } - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') - goto yy1018; - if (yych <= '/') - goto yy999; - goto yy1019; - } else { - if (yych <= 'Z') { - if (yych <= '@') - goto yy999; - goto yy1019; - } else { - if (yych <= '`') + if (yych >= '{') goto yy999; - if (yych <= 'z') - goto yy1019; - goto yy999; } } - yy1017: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1019; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1019; + goto yy1018; goto yy999; } } else { @@ -8866,51 +8794,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1019; + goto yy1018; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1019; + goto yy1018; goto yy999; } } - yy1018: + yy1017: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1020; + goto yy1019; if (yych <= '/') goto yy999; - goto yy1021; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1021; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1021; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1019: + yy1018: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1021; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1021; + goto yy1020; goto yy999; } } else { @@ -8919,51 +8845,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1021; + goto yy1020; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1021; + goto yy1020; goto yy999; } } - yy1020: + yy1019: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1022; + goto yy1021; if (yych <= '/') goto yy999; - goto yy1023; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1023; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1023; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1021: + yy1020: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1023; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1023; + goto yy1022; goto yy999; } } else { @@ -8972,51 +8896,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1023; + goto yy1022; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1023; + goto yy1022; goto yy999; } } - yy1022: + yy1021: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1024; + goto yy1023; if (yych <= '/') goto yy999; - goto yy1025; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1025; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1025; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1023: + yy1022: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1025; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1025; + goto yy1024; goto yy999; } } else { @@ -9025,51 +8947,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1025; + goto yy1024; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1025; + goto yy1024; goto yy999; } } - yy1024: + yy1023: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1026; + goto yy1025; if (yych <= '/') goto yy999; - goto yy1027; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1027; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1027; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1025: + yy1024: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1027; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1027; + goto yy1026; goto yy999; } } else { @@ -9078,51 +8998,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1027; + goto yy1026; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1027; + goto yy1026; goto yy999; } } - yy1026: + yy1025: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1028; + goto yy1027; if (yych <= '/') goto yy999; - goto yy1029; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1029; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1029; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1027: + yy1026: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1029; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1029; + goto yy1028; goto yy999; } } else { @@ -9131,51 +9049,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1029; + goto yy1028; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1029; + goto yy1028; goto yy999; } } - yy1028: + yy1027: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1030; + goto yy1029; if (yych <= '/') goto yy999; - goto yy1031; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1031; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1031; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1029: + yy1028: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1031; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1031; + goto yy1030; goto yy999; } } else { @@ -9184,51 +9100,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1031; + goto yy1030; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1031; + goto yy1030; goto yy999; } } - yy1030: + yy1029: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1032; + goto yy1031; if (yych <= '/') goto yy999; - goto yy1033; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1033; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1033; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1031: + yy1030: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1033; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1033; + goto yy1032; goto yy999; } } else { @@ -9237,51 +9151,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1033; + goto yy1032; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1033; + goto yy1032; goto yy999; } } - yy1032: + yy1031: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1034; + goto yy1033; if (yych <= '/') goto yy999; - goto yy1035; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1035; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1035; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1033: + yy1032: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1035; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1035; + goto yy1034; goto yy999; } } else { @@ -9290,51 +9202,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1035; + goto yy1034; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1035; + goto yy1034; goto yy999; } } - yy1034: + yy1033: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1036; + goto yy1035; if (yych <= '/') goto yy999; - goto yy1037; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1037; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1037; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1035: + yy1034: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1037; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1037; + goto yy1036; goto yy999; } } else { @@ -9343,51 +9253,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1037; + goto yy1036; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1037; + goto yy1036; goto yy999; } } - yy1036: + yy1035: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1038; + goto yy1037; if (yych <= '/') goto yy999; - goto yy1039; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1039; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1039; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1037: + yy1036: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1039; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1039; + goto yy1038; goto yy999; } } else { @@ -9396,51 +9304,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1039; + goto yy1038; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1039; + goto yy1038; goto yy999; } } - yy1038: + yy1037: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1040; + goto yy1039; if (yych <= '/') goto yy999; - goto yy1041; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1041; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1041; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1039: + yy1038: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1041; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1041; + goto yy1040; goto yy999; } } else { @@ -9449,51 +9355,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1041; + goto yy1040; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1041; + goto yy1040; goto yy999; } } - yy1040: + yy1039: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1042; + goto yy1041; if (yych <= '/') goto yy999; - goto yy1043; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1043; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1043; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1041: + yy1040: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1043; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1043; + goto yy1042; goto yy999; } } else { @@ -9502,51 +9406,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1043; + goto yy1042; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1043; + goto yy1042; goto yy999; } } - yy1042: + yy1041: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1044; + goto yy1043; if (yych <= '/') goto yy999; - goto yy1045; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1045; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1045; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1043: + yy1042: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1045; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1045; + goto yy1044; goto yy999; } } else { @@ -9555,51 +9457,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1045; + goto yy1044; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1045; + goto yy1044; goto yy999; } } - yy1044: + yy1043: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1046; + goto yy1045; if (yych <= '/') goto yy999; - goto yy1047; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1047; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1047; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1045: + yy1044: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1047; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1047; + goto yy1046; goto yy999; } } else { @@ -9608,51 +9508,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1047; + goto yy1046; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1047; + goto yy1046; goto yy999; } } - yy1046: + yy1045: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1048; + goto yy1047; if (yych <= '/') goto yy999; - goto yy1049; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1049; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1049; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1047: + yy1046: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1049; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1049; + goto yy1048; goto yy999; } } else { @@ -9661,51 +9559,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1049; + goto yy1048; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1049; + goto yy1048; goto yy999; } } - yy1048: + yy1047: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1050; + goto yy1049; if (yych <= '/') goto yy999; - goto yy1051; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1051; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1051; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1049: + yy1048: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1051; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1051; + goto yy1050; goto yy999; } } else { @@ -9714,51 +9610,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1051; + goto yy1050; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1051; + goto yy1050; goto yy999; } } - yy1050: + yy1049: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1052; + goto yy1051; if (yych <= '/') goto yy999; - goto yy1053; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1053; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1053; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1051: + yy1050: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1053; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1053; + goto yy1052; goto yy999; } } else { @@ -9767,51 +9661,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1053; + goto yy1052; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1053; + goto yy1052; goto yy999; } } - yy1052: + yy1051: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1054; + goto yy1053; if (yych <= '/') goto yy999; - goto yy1055; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1055; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1055; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1053: + yy1052: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1055; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1055; + goto yy1054; goto yy999; } } else { @@ -9820,51 +9712,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1055; + goto yy1054; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1055; + goto yy1054; goto yy999; } } - yy1054: + yy1053: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1056; + goto yy1055; if (yych <= '/') goto yy999; - goto yy1057; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1057; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1057; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1055: + yy1054: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1057; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1057; + goto yy1056; goto yy999; } } else { @@ -9873,51 +9763,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1057; + goto yy1056; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1057; + goto yy1056; goto yy999; } } - yy1056: + yy1055: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1058; + goto yy1057; if (yych <= '/') goto yy999; - goto yy1059; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1059; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1059; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1057: + yy1056: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1059; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1059; + goto yy1058; goto yy999; } } else { @@ -9926,51 +9814,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1059; + goto yy1058; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1059; + goto yy1058; goto yy999; } } - yy1058: + yy1057: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1060; + goto yy1059; if (yych <= '/') goto yy999; - goto yy1061; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1061; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1061; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1059: + yy1058: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1061; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1061; + goto yy1060; goto yy999; } } else { @@ -9979,51 +9865,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1061; + goto yy1060; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1061; + goto yy1060; goto yy999; } } - yy1060: + yy1059: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1062; + goto yy1061; if (yych <= '/') goto yy999; - goto yy1063; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1063; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1063; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1061: + yy1060: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1063; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1063; + goto yy1062; goto yy999; } } else { @@ -10032,51 +9916,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1063; + goto yy1062; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1063; + goto yy1062; goto yy999; } } - yy1062: + yy1061: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1064; + goto yy1063; if (yych <= '/') goto yy999; - goto yy1065; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1065; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1065; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1063: + yy1062: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1065; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1065; + goto yy1064; goto yy999; } } else { @@ -10085,51 +9967,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1065; + goto yy1064; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1065; + goto yy1064; goto yy999; } } - yy1064: + yy1063: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1066; + goto yy1065; if (yych <= '/') goto yy999; - goto yy1067; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1067; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1067; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1065: + yy1064: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1067; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1067; + goto yy1066; goto yy999; } } else { @@ -10138,51 +10018,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1067; + goto yy1066; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1067; + goto yy1066; goto yy999; } } - yy1066: + yy1065: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1068; + goto yy1067; if (yych <= '/') goto yy999; - goto yy1069; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1069; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1069; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1067: + yy1066: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1069; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1069; + goto yy1068; goto yy999; } } else { @@ -10191,51 +10069,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1069; + goto yy1068; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1069; + goto yy1068; goto yy999; } } - yy1068: + yy1067: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1070; + goto yy1069; if (yych <= '/') goto yy999; - goto yy1071; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1071; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1071; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1069: + yy1068: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1071; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1071; + goto yy1070; goto yy999; } } else { @@ -10244,51 +10120,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1071; + goto yy1070; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1071; + goto yy1070; goto yy999; } } - yy1070: + yy1069: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1072; + goto yy1071; if (yych <= '/') goto yy999; - goto yy1073; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1073; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1073; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1071: + yy1070: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1073; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1073; + goto yy1072; goto yy999; } } else { @@ -10297,51 +10171,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1073; + goto yy1072; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1073; + goto yy1072; goto yy999; } } - yy1072: + yy1071: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1074; + goto yy1073; if (yych <= '/') goto yy999; - goto yy1075; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1075; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1075; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1073: + yy1072: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1075; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1075; + goto yy1074; goto yy999; } } else { @@ -10350,51 +10222,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1075; + goto yy1074; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1075; + goto yy1074; goto yy999; } } - yy1074: + yy1073: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1076; + goto yy1075; if (yych <= '/') goto yy999; - goto yy1077; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1077; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1077; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1075: + yy1074: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1077; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1077; + goto yy1076; goto yy999; } } else { @@ -10403,51 +10273,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1077; + goto yy1076; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1077; + goto yy1076; goto yy999; } } - yy1076: + yy1075: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1078; + goto yy1077; if (yych <= '/') goto yy999; - goto yy1079; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1079; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1079; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1077: + yy1076: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1079; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1079; + goto yy1078; goto yy999; } } else { @@ -10456,51 +10324,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1079; + goto yy1078; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1079; + goto yy1078; goto yy999; } } - yy1078: + yy1077: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1080; + goto yy1079; if (yych <= '/') goto yy999; - goto yy1081; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1081; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1081; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1079: + yy1078: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1081; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1081; + goto yy1080; goto yy999; } } else { @@ -10509,51 +10375,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1081; + goto yy1080; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1081; + goto yy1080; goto yy999; } } - yy1080: + yy1079: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1082; + goto yy1081; if (yych <= '/') goto yy999; - goto yy1083; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1083; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1083; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1081: + yy1080: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1083; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1083; + goto yy1082; goto yy999; } } else { @@ -10562,51 +10426,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1083; + goto yy1082; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1083; + goto yy1082; goto yy999; } } - yy1082: + yy1081: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1084; + goto yy1083; if (yych <= '/') goto yy999; - goto yy1085; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1085; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1085; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1083: + yy1082: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1085; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1085; + goto yy1084; goto yy999; } } else { @@ -10615,51 +10477,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1085; + goto yy1084; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1085; + goto yy1084; goto yy999; } } - yy1084: + yy1083: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1086; + goto yy1085; if (yych <= '/') goto yy999; - goto yy1087; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1087; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1087; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1085: + yy1084: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1087; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1087; + goto yy1086; goto yy999; } } else { @@ -10668,51 +10528,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1087; + goto yy1086; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1087; + goto yy1086; goto yy999; } } - yy1086: + yy1085: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1088; + goto yy1087; if (yych <= '/') goto yy999; - goto yy1089; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1089; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1089; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1087: + yy1086: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1089; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1089; + goto yy1088; goto yy999; } } else { @@ -10721,51 +10579,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1089; + goto yy1088; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1089; + goto yy1088; goto yy999; } } - yy1088: + yy1087: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1090; + goto yy1089; if (yych <= '/') goto yy999; - goto yy1091; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1091; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1091; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1089: + yy1088: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1091; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1091; + goto yy1090; goto yy999; } } else { @@ -10774,51 +10630,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1091; + goto yy1090; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1091; + goto yy1090; goto yy999; } } - yy1090: + yy1089: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1092; + goto yy1091; if (yych <= '/') goto yy999; - goto yy1093; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1093; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1093; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1091: + yy1090: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1093; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1093; + goto yy1092; goto yy999; } } else { @@ -10827,51 +10681,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1093; + goto yy1092; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1093; + goto yy1092; goto yy999; } } - yy1092: + yy1091: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1094; + goto yy1093; if (yych <= '/') goto yy999; - goto yy1095; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1095; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1095; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1093: + yy1092: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1095; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1095; + goto yy1094; goto yy999; } } else { @@ -10880,51 +10732,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1095; + goto yy1094; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1095; + goto yy1094; goto yy999; } } - yy1094: + yy1093: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1096; + goto yy1095; if (yych <= '/') goto yy999; - goto yy1097; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1097; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1097; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1095: + yy1094: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1097; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1097; + goto yy1096; goto yy999; } } else { @@ -10933,51 +10783,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1097; + goto yy1096; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1097; + goto yy1096; goto yy999; } } - yy1096: + yy1095: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1098; + goto yy1097; if (yych <= '/') goto yy999; - goto yy1099; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1099; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1099; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1097: + yy1096: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1099; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1099; + goto yy1098; goto yy999; } } else { @@ -10986,51 +10834,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1099; + goto yy1098; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1099; + goto yy1098; goto yy999; } } - yy1098: + yy1097: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1100; + goto yy1099; if (yych <= '/') goto yy999; - goto yy1101; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1101; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1101; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1099: + yy1098: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1101; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1101; + goto yy1100; goto yy999; } } else { @@ -11039,51 +10885,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1101; + goto yy1100; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1101; + goto yy1100; goto yy999; } } - yy1100: + yy1099: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1102; + goto yy1101; if (yych <= '/') goto yy999; - goto yy1103; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1103; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1103; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1101: + yy1100: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1103; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1103; + goto yy1102; goto yy999; } } else { @@ -11092,51 +10936,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1103; + goto yy1102; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1103; + goto yy1102; goto yy999; } } - yy1102: + yy1101: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1104; + goto yy1103; if (yych <= '/') goto yy999; - goto yy1105; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1105; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1105; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1103: + yy1102: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1105; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1105; + goto yy1104; goto yy999; } } else { @@ -11145,51 +10987,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1105; + goto yy1104; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1105; + goto yy1104; goto yy999; } } - yy1104: + yy1103: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1106; + goto yy1105; if (yych <= '/') goto yy999; - goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1107; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1107; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1105: + yy1104: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1107; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1107; + goto yy1106; goto yy999; } } else { @@ -11198,51 +11038,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1107; + goto yy1106; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1107; + goto yy1106; goto yy999; } } - yy1106: + yy1105: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1108; + goto yy1107; if (yych <= '/') goto yy999; - goto yy1109; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1109; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1109; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1107: + yy1106: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1109; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1109; + goto yy1108; goto yy999; } } else { @@ -11251,51 +11089,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1109; + goto yy1108; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1109; + goto yy1108; goto yy999; } } - yy1108: + yy1107: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1110; + goto yy1109; if (yych <= '/') goto yy999; - goto yy1111; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1111; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1111; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1109: + yy1108: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1111; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1111; + goto yy1110; goto yy999; } } else { @@ -11304,51 +11140,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1111; + goto yy1110; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1111; + goto yy1110; goto yy999; } } - yy1110: + yy1109: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1112; + goto yy1111; if (yych <= '/') goto yy999; - goto yy1113; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1113; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1113; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1111: + yy1110: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1113; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1113; + goto yy1112; goto yy999; } } else { @@ -11357,51 +11191,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1113; + goto yy1112; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1113; + goto yy1112; goto yy999; } } - yy1112: + yy1111: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1114; + goto yy1113; if (yych <= '/') goto yy999; - goto yy1115; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1115; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1115; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1113: + yy1112: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1115; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1115; + goto yy1114; goto yy999; } } else { @@ -11410,51 +11242,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1115; + goto yy1114; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1115; + goto yy1114; goto yy999; } } - yy1114: + yy1113: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1116; + goto yy1115; if (yych <= '/') goto yy999; - goto yy1117; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1117; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1117; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1115: + yy1114: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1117; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1117; + goto yy1116; goto yy999; } } else { @@ -11463,51 +11293,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1117; + goto yy1116; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1117; + goto yy1116; goto yy999; } } - yy1116: + yy1115: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1118; + goto yy1117; if (yych <= '/') goto yy999; - goto yy1119; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1119; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1119; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1117: + yy1116: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1119; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1119; + goto yy1118; goto yy999; } } else { @@ -11516,51 +11344,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1119; + goto yy1118; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1119; + goto yy1118; goto yy999; } } - yy1118: + yy1117: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1120; + goto yy1119; if (yych <= '/') goto yy999; - goto yy1121; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1121; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1121; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1119: + yy1118: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1121; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1121; + goto yy1120; goto yy999; } } else { @@ -11569,51 +11395,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1121; + goto yy1120; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1121; + goto yy1120; goto yy999; } } - yy1120: + yy1119: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1122; + goto yy1121; if (yych <= '/') goto yy999; - goto yy1123; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1123; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1123; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1121: + yy1120: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1123; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1123; + goto yy1122; goto yy999; } } else { @@ -11622,51 +11446,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1123; + goto yy1122; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1123; + goto yy1122; goto yy999; } } - yy1122: + yy1121: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1124; + goto yy1123; if (yych <= '/') goto yy999; - goto yy1125; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1125; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1125; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1123: + yy1122: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1125; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1125; + goto yy1124; goto yy999; } } else { @@ -11675,51 +11497,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1125; + goto yy1124; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1125; + goto yy1124; goto yy999; } } - yy1124: + yy1123: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1126; + goto yy1125; if (yych <= '/') goto yy999; - goto yy1127; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1127; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1127; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1125: + yy1124: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1127; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1127; + goto yy1126; goto yy999; } } else { @@ -11728,51 +11548,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1127; + goto yy1126; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1127; + goto yy1126; goto yy999; } } - yy1126: + yy1125: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1128; + goto yy1127; if (yych <= '/') goto yy999; - goto yy1129; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1129; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1129; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1127: + yy1126: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1129; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1129; + goto yy1128; goto yy999; } } else { @@ -11781,51 +11599,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1129; + goto yy1128; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1129; + goto yy1128; goto yy999; } } - yy1128: + yy1127: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1130; + goto yy1129; if (yych <= '/') goto yy999; - goto yy1131; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1131; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1131; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1129: + yy1128: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1131; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1131; + goto yy1130; goto yy999; } } else { @@ -11834,51 +11650,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1131; + goto yy1130; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1131; + goto yy1130; goto yy999; } } - yy1130: + yy1129: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1132; + goto yy1131; if (yych <= '/') goto yy999; - goto yy1133; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1133; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1133; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1131: + yy1130: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1133; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1133; + goto yy1132; goto yy999; } } else { @@ -11887,51 +11701,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1133; + goto yy1132; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1133; + goto yy1132; goto yy999; } } - yy1132: + yy1131: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1134; + goto yy1133; if (yych <= '/') goto yy999; - goto yy1135; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1135; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1135; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1133: + yy1132: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1135; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1135; + goto yy1134; goto yy999; } } else { @@ -11940,51 +11752,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1135; + goto yy1134; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1135; + goto yy1134; goto yy999; } } - yy1134: + yy1133: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1136; + goto yy1135; if (yych <= '/') goto yy999; - goto yy1137; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1137; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1137; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1135: + yy1134: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1137; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1137; + goto yy1136; goto yy999; } } else { @@ -11993,34 +11803,35 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1137; + goto yy1136; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1137; + goto yy1136; goto yy999; } } - yy1136: + yy1135: ++p; yych = *p; - if (yych <= '@') { + if (yych <= '9') { + if (yych == '-') + goto yy1137; if (yych <= '/') goto yy999; - if (yych <= '9') - goto yy1138; - goto yy999; } else { - if (yych <= 'Z') - goto yy1138; - if (yych <= '`') - goto yy999; - if (yych <= 'z') - goto yy1138; - goto yy999; + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + } else { + if (yych <= '`') + goto yy999; + if (yych >= '{') + goto yy999; + } } - yy1137: + yy1136: ++p; yych = *p; if (yych <= '=') { @@ -12031,8 +11842,9 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { } else { if (yych <= '/') goto yy999; - if (yych >= ':') - goto yy999; + if (yych <= '9') + goto yy1138; + goto yy999; } } else { if (yych <= 'Z') { @@ -12040,13 +11852,31 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; + goto yy1138; } else { if (yych <= '`') goto yy999; - if (yych >= '{') - goto yy999; + if (yych <= 'z') + goto yy1138; + goto yy999; } } + yy1137: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') + goto yy999; + if (yych >= ':') + goto yy999; + } else { + if (yych <= 'Z') + goto yy1138; + if (yych <= '`') + goto yy999; + if (yych >= '{') + goto yy999; + } yy1138: ++p; yych = *p; @@ -12056,39 +11886,19 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; goto yy999; yy1139: - yych = *++p; - if (yych <= '9') { - if (yych == '-') - goto yy1141; - if (yych <= '/') - goto yy999; - goto yy1142; - } else { - if (yych <= 'Z') { - if (yych <= '@') - goto yy999; - goto yy1142; - } else { - if (yych <= '`') - goto yy999; - if (yych <= 'z') - goto yy1142; - goto yy999; - } - } - yy1140: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1142; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1142; + goto yy1141; goto yy999; } } else { @@ -12097,49 +11907,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1142; + goto yy1141; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1142; + goto yy1141; goto yy999; } } - yy1141: + yy1140: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1143; + goto yy1142; if (yych <= '/') goto yy999; - goto yy1144; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1144; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1144; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1142: + yy1141: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1144; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1144; + goto yy1143; goto yy999; } } else { @@ -12148,49 +11956,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1144; + goto yy1143; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1144; + goto yy1143; goto yy999; } } - yy1143: + yy1142: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1145; + goto yy1144; if (yych <= '/') goto yy999; - goto yy1146; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1146; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1146; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1144: + yy1143: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1146; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1146; + goto yy1145; goto yy999; } } else { @@ -12199,49 +12005,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1146; + goto yy1145; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1146; + goto yy1145; goto yy999; } } - yy1145: + yy1144: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1147; + goto yy1146; if (yych <= '/') goto yy999; - goto yy1148; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1148; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1148; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1146: + yy1145: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1148; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1148; + goto yy1147; goto yy999; } } else { @@ -12250,49 +12054,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1148; + goto yy1147; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1148; + goto yy1147; goto yy999; } } - yy1147: + yy1146: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1149; + goto yy1148; if (yych <= '/') goto yy999; - goto yy1150; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1150; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1150; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1148: + yy1147: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1150; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1150; + goto yy1149; goto yy999; } } else { @@ -12301,49 +12103,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1150; + goto yy1149; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1150; + goto yy1149; goto yy999; } } - yy1149: + yy1148: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1151; + goto yy1150; if (yych <= '/') goto yy999; - goto yy1152; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1152; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1152; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1150: + yy1149: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1152; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1152; + goto yy1151; goto yy999; } } else { @@ -12352,49 +12152,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1152; + goto yy1151; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1152; + goto yy1151; goto yy999; } } - yy1151: + yy1150: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1153; + goto yy1152; if (yych <= '/') goto yy999; - goto yy1154; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1154; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1154; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1152: + yy1151: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1154; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1154; + goto yy1153; goto yy999; } } else { @@ -12403,49 +12201,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1154; + goto yy1153; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1154; + goto yy1153; goto yy999; } } - yy1153: + yy1152: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1155; + goto yy1154; if (yych <= '/') goto yy999; - goto yy1156; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1156; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1156; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1154: + yy1153: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1156; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1156; + goto yy1155; goto yy999; } } else { @@ -12454,49 +12250,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1156; + goto yy1155; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1156; + goto yy1155; goto yy999; } } - yy1155: + yy1154: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1157; + goto yy1156; if (yych <= '/') goto yy999; - goto yy1158; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1158; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1158; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1156: + yy1155: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1158; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1158; + goto yy1157; goto yy999; } } else { @@ -12505,49 +12299,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1158; + goto yy1157; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1158; + goto yy1157; goto yy999; } } - yy1157: + yy1156: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1159; + goto yy1158; if (yych <= '/') goto yy999; - goto yy1160; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1160; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1160; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1158: + yy1157: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1160; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1160; + goto yy1159; goto yy999; } } else { @@ -12556,49 +12348,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1160; + goto yy1159; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1160; + goto yy1159; goto yy999; } } - yy1159: + yy1158: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1161; + goto yy1160; if (yych <= '/') goto yy999; - goto yy1162; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1162; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1162; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1160: + yy1159: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1162; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1162; + goto yy1161; goto yy999; } } else { @@ -12607,49 +12397,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1162; + goto yy1161; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1162; + goto yy1161; goto yy999; } } - yy1161: + yy1160: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1163; + goto yy1162; if (yych <= '/') goto yy999; - goto yy1164; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1164; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1164; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1162: + yy1161: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1164; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1164; + goto yy1163; goto yy999; } } else { @@ -12658,49 +12446,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1164; + goto yy1163; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1164; + goto yy1163; goto yy999; } } - yy1163: + yy1162: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1165; + goto yy1164; if (yych <= '/') goto yy999; - goto yy1166; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1166; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1166; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1164: + yy1163: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1166; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1166; + goto yy1165; goto yy999; } } else { @@ -12709,49 +12495,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1166; + goto yy1165; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1166; + goto yy1165; goto yy999; } } - yy1165: + yy1164: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1167; + goto yy1166; if (yych <= '/') goto yy999; - goto yy1168; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1168; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1168; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1166: + yy1165: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1168; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1168; + goto yy1167; goto yy999; } } else { @@ -12760,49 +12544,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1168; + goto yy1167; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1168; + goto yy1167; goto yy999; } } - yy1167: + yy1166: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1169; + goto yy1168; if (yych <= '/') goto yy999; - goto yy1170; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1170; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1170; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1168: + yy1167: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1170; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1170; + goto yy1169; goto yy999; } } else { @@ -12811,49 +12593,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1170; + goto yy1169; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1170; + goto yy1169; goto yy999; } } - yy1169: + yy1168: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1171; + goto yy1170; if (yych <= '/') goto yy999; - goto yy1172; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1172; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1172; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1170: + yy1169: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1172; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1172; + goto yy1171; goto yy999; } } else { @@ -12862,49 +12642,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1172; + goto yy1171; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1172; + goto yy1171; goto yy999; } } - yy1171: + yy1170: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1173; + goto yy1172; if (yych <= '/') goto yy999; - goto yy1174; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1174; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1174; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1172: + yy1171: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1174; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1174; + goto yy1173; goto yy999; } } else { @@ -12913,49 +12691,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1174; + goto yy1173; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1174; + goto yy1173; goto yy999; } } - yy1173: + yy1172: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1175; + goto yy1174; if (yych <= '/') goto yy999; - goto yy1176; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1176; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1176; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1174: + yy1173: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1176; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1176; + goto yy1175; goto yy999; } } else { @@ -12964,49 +12740,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1176; + goto yy1175; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1176; + goto yy1175; goto yy999; } } - yy1175: + yy1174: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1177; + goto yy1176; if (yych <= '/') goto yy999; - goto yy1178; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1178; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1178; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1176: + yy1175: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1178; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1178; + goto yy1177; goto yy999; } } else { @@ -13015,49 +12789,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1178; + goto yy1177; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1178; + goto yy1177; goto yy999; } } - yy1177: + yy1176: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1179; + goto yy1178; if (yych <= '/') goto yy999; - goto yy1180; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1180; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1180; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1178: + yy1177: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1180; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1180; + goto yy1179; goto yy999; } } else { @@ -13066,49 +12838,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1180; + goto yy1179; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1180; + goto yy1179; goto yy999; } } - yy1179: + yy1178: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1181; + goto yy1180; if (yych <= '/') goto yy999; - goto yy1182; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1182; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1182; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1180: + yy1179: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1182; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1182; + goto yy1181; goto yy999; } } else { @@ -13117,49 +12887,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1182; + goto yy1181; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1182; + goto yy1181; goto yy999; } } - yy1181: + yy1180: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1183; + goto yy1182; if (yych <= '/') goto yy999; - goto yy1184; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1184; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1184; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1182: + yy1181: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1184; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1184; + goto yy1183; goto yy999; } } else { @@ -13168,49 +12936,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1184; + goto yy1183; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1184; + goto yy1183; goto yy999; } } - yy1183: + yy1182: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1185; + goto yy1184; if (yych <= '/') goto yy999; - goto yy1186; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1186; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1186; - goto yy999; - } + if (yych >= '{') + goto yy999; + } } - yy1184: + yy1183: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1186; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1186; + goto yy1185; goto yy999; } } else { @@ -13219,49 +12985,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1186; + goto yy1185; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1186; + goto yy1185; goto yy999; } } - yy1185: + yy1184: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1187; + goto yy1186; if (yych <= '/') goto yy999; - goto yy1188; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1188; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1188; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1186: + yy1185: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1188; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1188; + goto yy1187; goto yy999; } } else { @@ -13270,49 +13034,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1188; + goto yy1187; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1188; + goto yy1187; goto yy999; } } - yy1187: + yy1186: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1189; + goto yy1188; if (yych <= '/') goto yy999; - goto yy1190; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1190; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1190; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1188: + yy1187: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1190; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1190; + goto yy1189; goto yy999; } } else { @@ -13321,49 +13083,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1190; + goto yy1189; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1190; + goto yy1189; goto yy999; } } - yy1189: + yy1188: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1191; + goto yy1190; if (yych <= '/') goto yy999; - goto yy1192; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1192; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1192; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1190: + yy1189: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1192; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1192; + goto yy1191; goto yy999; } } else { @@ -13372,49 +13132,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1192; + goto yy1191; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1192; + goto yy1191; goto yy999; } } - yy1191: + yy1190: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1193; + goto yy1192; if (yych <= '/') goto yy999; - goto yy1194; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1194; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1194; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1192: + yy1191: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1194; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1194; + goto yy1193; goto yy999; } } else { @@ -13423,49 +13181,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1194; + goto yy1193; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1194; + goto yy1193; goto yy999; } } - yy1193: + yy1192: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1195; + goto yy1194; if (yych <= '/') goto yy999; - goto yy1196; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1196; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1196; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1194: + yy1193: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1196; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1196; + goto yy1195; goto yy999; } } else { @@ -13474,49 +13230,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1196; + goto yy1195; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1196; + goto yy1195; goto yy999; } } - yy1195: + yy1194: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1197; + goto yy1196; if (yych <= '/') goto yy999; - goto yy1198; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1198; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1198; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1196: + yy1195: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1198; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1198; + goto yy1197; goto yy999; } } else { @@ -13525,49 +13279,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1198; + goto yy1197; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1198; + goto yy1197; goto yy999; } } - yy1197: + yy1196: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1199; + goto yy1198; if (yych <= '/') goto yy999; - goto yy1200; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1200; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1200; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1198: + yy1197: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1200; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1200; + goto yy1199; goto yy999; } } else { @@ -13576,49 +13328,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1200; + goto yy1199; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1200; + goto yy1199; goto yy999; } } - yy1199: + yy1198: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1201; + goto yy1200; if (yych <= '/') goto yy999; - goto yy1202; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1202; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1202; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1200: + yy1199: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1202; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1202; + goto yy1201; goto yy999; } } else { @@ -13627,49 +13377,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1202; + goto yy1201; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1202; + goto yy1201; goto yy999; } } - yy1201: + yy1200: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1203; + goto yy1202; if (yych <= '/') goto yy999; - goto yy1204; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1204; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1204; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1202: + yy1201: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1204; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1204; + goto yy1203; goto yy999; } } else { @@ -13678,49 +13426,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1204; + goto yy1203; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1204; + goto yy1203; goto yy999; } } - yy1203: + yy1202: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1205; + goto yy1204; if (yych <= '/') goto yy999; - goto yy1206; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1206; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1206; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1204: + yy1203: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1206; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1206; + goto yy1205; goto yy999; } } else { @@ -13729,49 +13475,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1206; + goto yy1205; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1206; + goto yy1205; goto yy999; } } - yy1205: + yy1204: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1207; + goto yy1206; if (yych <= '/') goto yy999; - goto yy1208; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1208; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1208; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1206: + yy1205: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1208; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1208; + goto yy1207; goto yy999; } } else { @@ -13780,49 +13524,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1208; + goto yy1207; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1208; + goto yy1207; goto yy999; } } - yy1207: + yy1206: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1209; + goto yy1208; if (yych <= '/') goto yy999; - goto yy1210; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1210; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1210; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1208: + yy1207: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1210; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1210; + goto yy1209; goto yy999; } } else { @@ -13831,49 +13573,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1210; + goto yy1209; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1210; + goto yy1209; goto yy999; } } - yy1209: + yy1208: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1211; + goto yy1210; if (yych <= '/') goto yy999; - goto yy1212; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1212; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1212; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1210: + yy1209: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1212; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1212; + goto yy1211; goto yy999; } } else { @@ -13882,49 +13622,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1212; + goto yy1211; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1212; + goto yy1211; goto yy999; } } - yy1211: + yy1210: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1213; + goto yy1212; if (yych <= '/') goto yy999; - goto yy1214; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1214; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1214; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1212: + yy1211: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1214; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1214; + goto yy1213; goto yy999; } } else { @@ -13933,49 +13671,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1214; + goto yy1213; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1214; + goto yy1213; goto yy999; } } - yy1213: + yy1212: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1215; + goto yy1214; if (yych <= '/') goto yy999; - goto yy1216; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1216; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1216; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1214: + yy1213: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1216; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1216; + goto yy1215; goto yy999; } } else { @@ -13984,49 +13720,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1216; + goto yy1215; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1216; + goto yy1215; goto yy999; } } - yy1215: + yy1214: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1217; + goto yy1216; if (yych <= '/') goto yy999; - goto yy1218; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1218; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1218; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1216: + yy1215: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1218; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1218; + goto yy1217; goto yy999; } } else { @@ -14035,49 +13769,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1218; + goto yy1217; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1218; + goto yy1217; goto yy999; } } - yy1217: + yy1216: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1219; + goto yy1218; if (yych <= '/') goto yy999; - goto yy1220; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1220; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1220; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1218: + yy1217: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1220; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1220; + goto yy1219; goto yy999; } } else { @@ -14086,49 +13818,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1220; + goto yy1219; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1220; + goto yy1219; goto yy999; } } - yy1219: + yy1218: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1221; + goto yy1220; if (yych <= '/') goto yy999; - goto yy1222; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1222; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1222; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1220: + yy1219: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1222; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1222; + goto yy1221; goto yy999; } } else { @@ -14137,49 +13867,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1222; + goto yy1221; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1222; + goto yy1221; goto yy999; } } - yy1221: + yy1220: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1223; + goto yy1222; if (yych <= '/') goto yy999; - goto yy1224; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1224; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1224; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1222: + yy1221: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1224; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1224; + goto yy1223; goto yy999; } } else { @@ -14188,49 +13916,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1224; + goto yy1223; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1224; + goto yy1223; goto yy999; } } - yy1223: + yy1222: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1225; + goto yy1224; if (yych <= '/') goto yy999; - goto yy1226; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1226; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1226; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1224: + yy1223: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1226; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1226; + goto yy1225; goto yy999; } } else { @@ -14239,49 +13965,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1226; + goto yy1225; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1226; + goto yy1225; goto yy999; } } - yy1225: + yy1224: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1227; + goto yy1226; if (yych <= '/') goto yy999; - goto yy1228; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1228; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1228; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1226: + yy1225: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1228; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1228; + goto yy1227; goto yy999; } } else { @@ -14290,49 +14014,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1228; + goto yy1227; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1228; + goto yy1227; goto yy999; } } - yy1227: + yy1226: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1229; + goto yy1228; if (yych <= '/') goto yy999; - goto yy1230; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1230; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1230; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1228: + yy1227: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1230; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1230; + goto yy1229; goto yy999; } } else { @@ -14341,49 +14063,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1230; + goto yy1229; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1230; + goto yy1229; goto yy999; } } - yy1229: + yy1228: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1231; + goto yy1230; if (yych <= '/') goto yy999; - goto yy1232; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1232; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1232; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1230: + yy1229: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1232; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1232; + goto yy1231; goto yy999; } } else { @@ -14392,49 +14112,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1232; + goto yy1231; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1232; + goto yy1231; goto yy999; } } - yy1231: + yy1230: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1233; + goto yy1232; if (yych <= '/') goto yy999; - goto yy1234; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1234; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1234; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1232: + yy1231: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1234; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1234; + goto yy1233; goto yy999; } } else { @@ -14443,49 +14161,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1234; + goto yy1233; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1234; + goto yy1233; goto yy999; } } - yy1233: + yy1232: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1235; + goto yy1234; if (yych <= '/') goto yy999; - goto yy1236; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1236; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1236; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1234: + yy1233: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1236; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1236; + goto yy1235; goto yy999; } } else { @@ -14494,49 +14210,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1236; + goto yy1235; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1236; + goto yy1235; goto yy999; } } - yy1235: + yy1234: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1237; + goto yy1236; if (yych <= '/') goto yy999; - goto yy1238; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1238; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1238; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1236: + yy1235: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1238; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1238; + goto yy1237; goto yy999; } } else { @@ -14545,49 +14259,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1238; + goto yy1237; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1238; + goto yy1237; goto yy999; } } - yy1237: + yy1236: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1239; + goto yy1238; if (yych <= '/') goto yy999; - goto yy1240; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1240; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1240; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1238: + yy1237: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1240; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1240; + goto yy1239; goto yy999; } } else { @@ -14596,49 +14308,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1240; + goto yy1239; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1240; + goto yy1239; goto yy999; } } - yy1239: + yy1238: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1241; + goto yy1240; if (yych <= '/') goto yy999; - goto yy1242; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1242; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1242; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1240: + yy1239: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1242; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1242; + goto yy1241; goto yy999; } } else { @@ -14647,49 +14357,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1242; + goto yy1241; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1242; + goto yy1241; goto yy999; } } - yy1241: + yy1240: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1243; + goto yy1242; if (yych <= '/') goto yy999; - goto yy1244; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1244; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1244; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1242: + yy1241: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1244; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1244; + goto yy1243; goto yy999; } } else { @@ -14698,49 +14406,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1244; + goto yy1243; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1244; + goto yy1243; goto yy999; } } - yy1243: + yy1242: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1245; + goto yy1244; if (yych <= '/') goto yy999; - goto yy1246; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1246; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1246; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1244: + yy1243: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1246; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1246; + goto yy1245; goto yy999; } } else { @@ -14749,49 +14455,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1246; + goto yy1245; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1246; + goto yy1245; goto yy999; } } - yy1245: + yy1244: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1247; + goto yy1246; if (yych <= '/') goto yy999; - goto yy1248; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1248; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1248; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1246: + yy1245: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1248; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1248; + goto yy1247; goto yy999; } } else { @@ -14800,49 +14504,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1248; + goto yy1247; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1248; + goto yy1247; goto yy999; } } - yy1247: + yy1246: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1249; + goto yy1248; if (yych <= '/') goto yy999; - goto yy1250; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1250; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1250; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1248: + yy1247: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1250; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1250; + goto yy1249; goto yy999; } } else { @@ -14851,49 +14553,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1250; + goto yy1249; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1250; + goto yy1249; goto yy999; } } - yy1249: + yy1248: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1251; + goto yy1250; if (yych <= '/') goto yy999; - goto yy1252; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1252; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1252; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1250: + yy1249: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1252; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1252; + goto yy1251; goto yy999; } } else { @@ -14902,49 +14602,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1252; + goto yy1251; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1252; + goto yy1251; goto yy999; } } - yy1251: + yy1250: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1253; + goto yy1252; if (yych <= '/') goto yy999; - goto yy1254; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1254; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1254; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1252: + yy1251: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1254; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1254; + goto yy1253; goto yy999; } } else { @@ -14953,49 +14651,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1254; + goto yy1253; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1254; + goto yy1253; goto yy999; } } - yy1253: + yy1252: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1255; + goto yy1254; if (yych <= '/') goto yy999; - goto yy1256; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1256; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1256; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1254: + yy1253: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1256; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1256; + goto yy1255; goto yy999; } } else { @@ -15004,49 +14700,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1256; + goto yy1255; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1256; + goto yy1255; goto yy999; } } - yy1255: + yy1254: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1257; + goto yy1256; if (yych <= '/') goto yy999; - goto yy1258; } else { if (yych <= 'Z') { if (yych <= '@') goto yy999; - goto yy1258; } else { if (yych <= '`') goto yy999; - if (yych <= 'z') - goto yy1258; - goto yy999; + if (yych >= '{') + goto yy999; } } - yy1256: + yy1255: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy999; - if (yych >= '.') - goto yy1012; + if (yych <= '-') + goto yy1258; + goto yy1012; } else { if (yych <= '/') goto yy999; if (yych <= '9') - goto yy1258; + goto yy1257; goto yy999; } } else { @@ -15055,35 +14749,36 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy1013; if (yych <= '@') goto yy999; - goto yy1258; + goto yy1257; } else { if (yych <= '`') goto yy999; if (yych <= 'z') - goto yy1258; + goto yy1257; goto yy999; } } - yy1257: + yy1256: yych = *++p; - if (yych <= '@') { + if (yych <= '9') { + if (yych == '-') + goto yy1258; if (yych <= '/') goto yy999; - if (yych <= '9') - goto yy1138; - goto yy999; } else { - if (yych <= 'Z') - goto yy1138; - if (yych <= '`') - goto yy999; - if (yych <= 'z') - goto yy1138; - goto yy999; + if (yych <= 'Z') { + if (yych <= '@') + goto yy999; + } else { + if (yych <= '`') + goto yy999; + if (yych >= '{') + goto yy999; + } } - yy1258: - ++p; - if ((yych = *p) <= '=') { + yy1257: + yych = *++p; + if (yych <= '=') { if (yych <= '.') { if (yych <= '-') goto yy999; @@ -15110,6 +14805,23 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy999; } } + yy1258: + ++p; + if ((yych = *p) <= '@') { + if (yych <= '/') + goto yy999; + if (yych <= '9') + goto yy1138; + goto yy999; + } else { + if (yych <= 'Z') + goto yy1138; + if (yych <= '`') + goto yy999; + if (yych <= 'z') + goto yy1138; + goto yy999; + } } } @@ -17556,50 +17268,24 @@ bufsize_t _scan_html_block_start(const unsigned char *p) { } yy1437: yych = *++p; - if (yych <= 'U') { - if (yych <= 'E') { - if (yych == 'C') - goto yy1479; - if (yych <= 'D') - goto yy1417; - goto yy1482; - } else { - if (yych <= 'O') { - if (yych <= 'N') - goto yy1417; - goto yy1481; - } else { - if (yych <= 'S') - goto yy1417; - if (yych <= 'T') - goto yy1478; - goto yy1480; - } - } - } else { - if (yych <= 'n') { - if (yych <= 'c') { - if (yych <= 'b') - goto yy1417; - goto yy1479; - } else { - if (yych == 'e') - goto yy1482; - goto yy1417; - } - } else { - if (yych <= 's') { - if (yych <= 'o') - goto yy1481; - goto yy1417; - } else { - if (yych <= 't') - goto yy1478; - if (yych <= 'u') - goto yy1480; - goto yy1417; - } - } + switch (yych) { + case 'C': + case 'c': + goto yy1479; + case 'E': + case 'e': + goto yy1482; + case 'O': + case 'o': + goto yy1481; + case 'T': + case 't': + goto yy1478; + case 'U': + case 'u': + goto yy1480; + default: + goto yy1417; } yy1438: yych = *++p; @@ -22298,42 +21984,42 @@ bufsize_t _scan_link_url(const unsigned char *p) { } else { if (yych <= ')') { if (yych <= '\'') - goto yy1848; + goto yy1849; if (yych <= '(') - goto yy1859; + goto yy1858; goto yy1860; } else { if (yych == '<') goto yy1847; - goto yy1848; + goto yy1849; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\\') - goto yy1857; - if (yych <= 0x7F) goto yy1848; + if (yych <= 0x7F) + goto yy1849; } else { if (yych <= 0xDF) - goto yy1849; + goto yy1850; if (yych <= 0xE0) - goto yy1851; - goto yy1852; + goto yy1852; + goto yy1853; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1856; + goto yy1857; if (yych <= 0xEF) - goto yy1852; - goto yy1853; + goto yy1853; + goto yy1854; } else { if (yych <= 0xF3) - goto yy1854; - if (yych <= 0xF4) goto yy1855; + if (yych <= 0xF4) + goto yy1856; } } } @@ -22359,10 +22045,10 @@ bufsize_t _scan_link_url(const unsigned char *p) { if (yych <= '<') { if (yych <= ';') goto yy1872; - goto yy1907; + goto yy1896; } else { if (yych == '\\') - goto yy1881; + goto yy1874; goto yy1872; } } @@ -22371,24 +22057,24 @@ bufsize_t _scan_link_url(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= 0xC1) goto yy1843; - goto yy1874; + goto yy1876; } else { if (yych <= 0xE0) - goto yy1875; + goto yy1877; if (yych <= 0xEC) - goto yy1876; - goto yy1880; + goto yy1878; + goto yy1882; } } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1876; - goto yy1877; + goto yy1878; + goto yy1879; } else { if (yych <= 0xF3) - goto yy1878; + goto yy1880; if (yych <= 0xF4) - goto yy1879; + goto yy1881; goto yy1843; } } @@ -22401,59 +22087,59 @@ bufsize_t _scan_link_url(const unsigned char *p) { yyaccept = 0; yych = *(marker = ++p); if (yybm[0 + yych] & 64) { - goto yy1907; + goto yy1896; } if (yych <= '>') { if (yych <= '\r') { if (yych <= '\t') { if (yych <= 0x00) goto yy1843; - goto yy1921; + goto yy1909; } else { if (yych <= '\n') goto yy1843; if (yych <= '\f') - goto yy1921; + goto yy1909; goto yy1843; } } else { if (yych <= '(') { if (yych <= ' ') - goto yy1921; - goto yy1919; + goto yy1909; + goto yy1907; } else { if (yych <= ')') - goto yy1921; + goto yy1909; if (yych <= '<') goto yy1872; - goto yy1909; + goto yy1898; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\\') - goto yy1918; + goto yy1894; goto yy1843; } else { if (yych <= 0xDF) - goto yy1911; + goto yy1900; if (yych <= 0xE0) - goto yy1912; - goto yy1913; + goto yy1901; + goto yy1902; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1917; + goto yy1906; if (yych <= 0xEF) - goto yy1913; - goto yy1914; + goto yy1902; + goto yy1903; } else { if (yych <= 0xF3) - goto yy1915; + goto yy1904; if (yych <= 0xF4) - goto yy1916; + goto yy1905; goto yy1843; } } @@ -22461,116 +22147,96 @@ bufsize_t _scan_link_url(const unsigned char *p) { yy1848: yyaccept = 0; yych = *(marker = ++p); + if (yych <= '\'') + goto yy1873; + if (yych <= '(') + goto yy1883; + if (yych <= ')') + goto yy1872; goto yy1873; yy1849: + yyaccept = 0; + yych = *(marker = ++p); + goto yy1873; + yy1850: yych = *++p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1848; - yy1850: + goto yy1849; + yy1851: p = marker; if (yyaccept <= 1) { if (yyaccept == 0) { goto yy1843; } else { - goto yy1858; + goto yy1859; } } else { - goto yy1910; + goto yy1899; } - yy1851: + yy1852: yych = *++p; if (yych <= 0x9F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1849; - goto yy1850; - yy1852: + goto yy1850; + goto yy1851; + yy1853: yych = *++p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1849; - goto yy1850; - yy1853: + goto yy1850; + goto yy1851; + yy1854: yych = *++p; if (yych <= 0x8F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1852; - goto yy1850; - yy1854: + goto yy1853; + goto yy1851; + yy1855: yych = *++p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1852; - goto yy1850; - yy1855: + goto yy1853; + goto yy1851; + yy1856: yych = *++p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x8F) - goto yy1852; - goto yy1850; - yy1856: + goto yy1853; + goto yy1851; + yy1857: yych = *++p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x9F) - goto yy1849; - goto yy1850; - yy1857: - yyaccept = 1; - yych = *(marker = ++p); - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) - goto yy1872; - } else { - if (yych <= 0xDF) - goto yy1882; - if (yych <= 0xE0) - goto yy1883; - goto yy1884; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1888; - if (yych <= 0xEF) - goto yy1884; - goto yy1885; - } else { - if (yych <= 0xF3) - goto yy1886; - if (yych <= 0xF4) - goto yy1887; - } - } - yy1858 : { return 0; } - yy1859: + goto yy1850; + goto yy1851; + yy1858: yyaccept = 1; yych = *(marker = ++p); if (yych <= '(') { if (yych <= ' ') - goto yy1858; + goto yy1859; if (yych <= '\'') goto yy1864; - goto yy1858; } else { if (yych <= 0x7F) goto yy1864; if (yych <= 0xC1) - goto yy1858; + goto yy1859; if (yych <= 0xF4) goto yy1864; - goto yy1858; } + yy1859 : { return 0; } yy1860: yych = *++p; - goto yy1858; + goto yy1859; yy1861: ++p; yych = *p; @@ -22580,14 +22246,14 @@ bufsize_t _scan_link_url(const unsigned char *p) { if (yych <= 0xE0) { if (yych <= ')') { if (yych <= ' ') - goto yy1850; + goto yy1851; if (yych >= ')') - goto yy1889; + goto yy1883; } else { if (yych <= 0x7F) goto yy1863; if (yych <= 0xC1) - goto yy1850; + goto yy1851; if (yych <= 0xDF) goto yy1865; goto yy1866; @@ -22604,7 +22270,7 @@ bufsize_t _scan_link_url(const unsigned char *p) { goto yy1869; if (yych <= 0xF4) goto yy1870; - goto yy1850; + goto yy1851; } } yy1863: @@ -22617,13 +22283,13 @@ bufsize_t _scan_link_url(const unsigned char *p) { if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= '(') - goto yy1850; + goto yy1851; if (yych <= ')') goto yy1872; goto yy1861; } else { if (yych <= 0xC1) - goto yy1850; + goto yy1851; if (yych >= 0xE0) goto yy1866; } @@ -22639,65 +22305,65 @@ bufsize_t _scan_link_url(const unsigned char *p) { goto yy1869; if (yych <= 0xF4) goto yy1870; - goto yy1850; + goto yy1851; } } yy1865: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) goto yy1863; - goto yy1850; + goto yy1851; yy1866: ++p; yych = *p; if (yych <= 0x9F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) goto yy1865; - goto yy1850; + goto yy1851; yy1867: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) goto yy1865; - goto yy1850; + goto yy1851; yy1868: ++p; yych = *p; if (yych <= 0x8F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) goto yy1867; - goto yy1850; + goto yy1851; yy1869: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) goto yy1867; - goto yy1850; + goto yy1851; yy1870: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x8F) goto yy1867; - goto yy1850; + goto yy1851; yy1871: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x9F) goto yy1865; - goto yy1850; + goto yy1851; yy1872: yyaccept = 0; marker = ++p; @@ -22714,7 +22380,7 @@ bufsize_t _scan_link_url(const unsigned char *p) { goto yy1843; } else { if (yych == '\\') - goto yy1881; + goto yy1874; if (yych <= 0x7F) goto yy1872; goto yy1843; @@ -22722,421 +22388,338 @@ bufsize_t _scan_link_url(const unsigned char *p) { } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1874; + goto yy1876; if (yych <= 0xE0) - goto yy1875; + goto yy1877; if (yych <= 0xEC) - goto yy1876; - goto yy1880; + goto yy1878; + goto yy1882; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1876; - goto yy1877; + goto yy1878; + goto yy1879; } else { if (yych <= 0xF3) - goto yy1878; + goto yy1880; if (yych <= 0xF4) - goto yy1879; + goto yy1881; goto yy1843; } } } yy1874: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1872; - goto yy1850; - yy1875: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy1850; - if (yych <= 0xBF) - goto yy1874; - goto yy1850; - yy1876: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1874; - goto yy1850; - yy1877: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy1850; - if (yych <= 0xBF) - goto yy1876; - goto yy1850; - yy1878: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1876; - goto yy1850; - yy1879: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0x8F) - goto yy1876; - goto yy1850; - yy1880: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0x9F) - goto yy1874; - goto yy1850; - yy1881: - ++p; + yyaccept = 0; + marker = ++p; yych = *p; - if (yych <= 0xEC) { - if (yych <= 0xC1) { + if (yych <= 0xDF) { + if (yych <= '[') { + if (yych <= ' ') + goto yy1843; + if (yych == '(') + goto yy1883; + goto yy1872; + } else { + if (yych <= '\\') + goto yy1874; if (yych <= 0x7F) goto yy1872; - goto yy1850; - } else { - if (yych <= 0xDF) - goto yy1882; - if (yych <= 0xE0) - goto yy1883; - goto yy1884; + if (yych <= 0xC1) + goto yy1843; } } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1888; - if (yych <= 0xEF) - goto yy1884; - goto yy1885; + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1877; + if (yych == 0xED) + goto yy1882; + goto yy1878; } else { + if (yych <= 0xF0) + goto yy1879; if (yych <= 0xF3) - goto yy1886; + goto yy1880; if (yych <= 0xF4) - goto yy1887; - goto yy1850; + goto yy1881; + goto yy1843; } } - yy1882: + yy1876: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) goto yy1872; - goto yy1850; - yy1883: + goto yy1851; + yy1877: ++p; yych = *p; if (yych <= 0x9F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1882; - goto yy1850; - yy1884: + goto yy1876; + goto yy1851; + yy1878: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1882; - goto yy1850; - yy1885: + goto yy1876; + goto yy1851; + yy1879: ++p; yych = *p; if (yych <= 0x8F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1884; - goto yy1850; - yy1886: + goto yy1878; + goto yy1851; + yy1880: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1884; - goto yy1850; - yy1887: + goto yy1878; + goto yy1851; + yy1881: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x8F) - goto yy1884; - goto yy1850; - yy1888: + goto yy1878; + goto yy1851; + yy1882: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x9F) - goto yy1882; - goto yy1850; - yy1889: + goto yy1876; + goto yy1851; + yy1883: yyaccept = 0; marker = ++p; yych = *p; - yy1890: + yy1884: if (yych <= 0xC1) { if (yych <= ')') { if (yych <= ' ') goto yy1843; if (yych <= '\'') - goto yy1889; + goto yy1883; if (yych <= '(') goto yy1863; goto yy1872; } else { if (yych == '\\') - goto yy1898; + goto yy1885; if (yych <= 0x7F) - goto yy1889; + goto yy1883; goto yy1843; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1891; + goto yy1887; if (yych <= 0xE0) - goto yy1892; + goto yy1888; if (yych <= 0xEC) - goto yy1893; - goto yy1897; + goto yy1889; + goto yy1893; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1893; - goto yy1894; + goto yy1889; + goto yy1890; } else { if (yych <= 0xF3) - goto yy1895; + goto yy1891; if (yych <= 0xF4) - goto yy1896; + goto yy1892; goto yy1843; } } } - yy1891: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1889; - goto yy1850; - yy1892: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy1850; - if (yych <= 0xBF) - goto yy1891; - goto yy1850; - yy1893: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1891; - goto yy1850; - yy1894: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy1850; - if (yych <= 0xBF) - goto yy1893; - goto yy1850; - yy1895: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1893; - goto yy1850; - yy1896: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0x8F) - goto yy1893; - goto yy1850; - yy1897: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0x9F) - goto yy1891; - goto yy1850; - yy1898: - ++p; - yych = *p; - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= ' ') - goto yy1872; - if (yych <= '[') - goto yy1889; - } else { - if (yych <= 0x7F) - goto yy1889; - if (yych <= 0xC1) - goto yy1850; - if (yych <= 0xDF) - goto yy1900; - goto yy1901; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy1906; - goto yy1902; - } else { - if (yych <= 0xF0) - goto yy1903; - if (yych <= 0xF3) - goto yy1904; - if (yych <= 0xF4) - goto yy1905; - goto yy1850; - } - } + yy1885: yyaccept = 0; marker = ++p; yych = *p; - if (yych <= 0xDF) { - if (yych <= '[') { + if (yych <= 0xE0) { + if (yych <= '\\') { if (yych <= ' ') goto yy1843; - if (yych == '(') - goto yy1863; - goto yy1889; + if (yych <= '[') + goto yy1883; + goto yy1885; } else { - if (yych <= '\\') - goto yy1898; if (yych <= 0x7F) - goto yy1889; + goto yy1883; if (yych <= 0xC1) goto yy1843; - goto yy1891; + if (yych >= 0xE0) + goto yy1888; } } else { if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy1892; if (yych == 0xED) - goto yy1897; - goto yy1893; + goto yy1893; + goto yy1889; } else { if (yych <= 0xF0) - goto yy1894; + goto yy1890; if (yych <= 0xF3) - goto yy1895; + goto yy1891; if (yych <= 0xF4) - goto yy1896; + goto yy1892; goto yy1843; } } - yy1900: + yy1887: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1889; - goto yy1850; - yy1901: + goto yy1883; + goto yy1851; + yy1888: ++p; yych = *p; if (yych <= 0x9F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1900; - goto yy1850; - yy1902: + goto yy1887; + goto yy1851; + yy1889: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1900; - goto yy1850; - yy1903: + goto yy1887; + goto yy1851; + yy1890: ++p; yych = *p; if (yych <= 0x8F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1902; - goto yy1850; - yy1904: + goto yy1889; + goto yy1851; + yy1891: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1902; - goto yy1850; - yy1905: + goto yy1889; + goto yy1851; + yy1892: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x8F) - goto yy1902; - goto yy1850; - yy1906: + goto yy1889; + goto yy1851; + yy1893: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x9F) - goto yy1900; - goto yy1850; - yy1907: + goto yy1887; + goto yy1851; + yy1894: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= '[') { + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy1843; + goto yy1909; + } else { + if (yych <= '\n') + goto yy1843; + if (yych <= '\f') + goto yy1909; + goto yy1843; + } + } else { + if (yych <= '(') { + if (yych <= ' ') + goto yy1909; + if (yych >= '(') + goto yy1932; + } else { + if (yych == '>') + goto yy1946; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') + goto yy1894; + if (yych >= 0x80) + goto yy1843; + } else { + if (yych <= 0xDF) + goto yy1900; + if (yych <= 0xE0) + goto yy1901; + goto yy1902; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1906; + if (yych <= 0xEF) + goto yy1902; + goto yy1903; + } else { + if (yych <= 0xF3) + goto yy1904; + if (yych <= 0xF4) + goto yy1905; + goto yy1843; + } + } + } + yy1896: yyaccept = 0; marker = ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1907; + goto yy1896; } if (yych <= '>') { if (yych <= '\r') { if (yych <= '\t') { if (yych <= 0x00) goto yy1843; - goto yy1921; + goto yy1909; } else { if (yych <= '\n') goto yy1843; if (yych <= '\f') - goto yy1921; + goto yy1909; goto yy1843; } } else { if (yych <= '(') { if (yych <= ' ') - goto yy1921; - goto yy1919; + goto yy1909; + goto yy1907; } else { if (yych <= ')') - goto yy1921; + goto yy1909; if (yych <= '<') goto yy1872; } @@ -23145,532 +22728,478 @@ bufsize_t _scan_link_url(const unsigned char *p) { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\\') - goto yy1918; + goto yy1894; goto yy1843; } else { if (yych <= 0xDF) - goto yy1911; + goto yy1900; if (yych <= 0xE0) - goto yy1912; - goto yy1913; + goto yy1901; + goto yy1902; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1917; + goto yy1906; if (yych <= 0xEF) - goto yy1913; - goto yy1914; + goto yy1902; + goto yy1903; } else { if (yych <= 0xF3) - goto yy1915; + goto yy1904; if (yych <= 0xF4) - goto yy1916; + goto yy1905; goto yy1843; } } } - yy1909: + yy1898: yyaccept = 2; yych = *(marker = ++p); if (yych <= ')') { if (yych <= ' ') - goto yy1910; + goto yy1899; if (yych <= '(') goto yy1873; } else { if (yych <= 0x7F) goto yy1873; if (yych <= 0xC1) - goto yy1910; + goto yy1899; if (yych <= 0xF4) goto yy1873; } - yy1910 : { return (bufsize_t)(p - start); } - yy1911: + yy1899 : { return (bufsize_t)(p - start); } + yy1900: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1907; - goto yy1850; - yy1912: + goto yy1896; + goto yy1851; + yy1901: ++p; yych = *p; if (yych <= 0x9F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1911; - goto yy1850; - yy1913: + goto yy1900; + goto yy1851; + yy1902: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1911; - goto yy1850; - yy1914: + goto yy1900; + goto yy1851; + yy1903: ++p; yych = *p; if (yych <= 0x8F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1913; - goto yy1850; - yy1915: + goto yy1902; + goto yy1851; + yy1904: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1913; - goto yy1850; - yy1916: + goto yy1902; + goto yy1851; + yy1905: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x8F) - goto yy1913; - goto yy1850; - yy1917: + goto yy1902; + goto yy1851; + yy1906: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x9F) - goto yy1911; - goto yy1850; - yy1918: - ++p; - yych = *p; - if (yych <= 0x7F) { - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) - goto yy1872; - goto yy1907; - } else { - if (yych <= '\n') - goto yy1872; - if (yych <= '\f') - goto yy1907; - goto yy1872; - } - } else { - if (yych <= '>') { - if (yych <= '=') - goto yy1907; - goto yy1965; - } else { - if (yych == '\\') - goto yy1966; - goto yy1907; - } - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) { - if (yych <= 0xC1) - goto yy1850; - goto yy1967; - } else { - if (yych <= 0xE0) - goto yy1968; - if (yych <= 0xEC) - goto yy1969; - goto yy1973; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy1969; - goto yy1970; - } else { - if (yych <= 0xF3) - goto yy1971; - if (yych <= 0xF4) - goto yy1972; - goto yy1850; - } - } - } - yy1919: + goto yy1900; + goto yy1851; + yy1907: ++p; yych = *p; if (yych <= '>') { if (yych <= ' ') { if (yych <= '\n') { if (yych <= 0x00) - goto yy1850; + goto yy1851; if (yych >= '\n') - goto yy1850; + goto yy1851; } else { if (yych == '\r') - goto yy1850; + goto yy1851; } } else { if (yych <= ')') { if (yych <= '\'') - goto yy1919; - if (yych >= ')') goto yy1907; + if (yych >= ')') + goto yy1896; } else { if (yych == '<') goto yy1863; if (yych <= '=') - goto yy1919; - goto yy1934; + goto yy1907; + goto yy1922; } } } else { if (yych <= 0xE0) { if (yych <= 0x7F) { if (yych == '\\') - goto yy1935; - goto yy1919; + goto yy1923; + goto yy1907; } else { if (yych <= 0xC1) - goto yy1850; + goto yy1851; if (yych <= 0xDF) - goto yy1937; - goto yy1938; + goto yy1925; + goto yy1926; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1943; - goto yy1939; + goto yy1931; + goto yy1927; } else { if (yych <= 0xF0) - goto yy1940; + goto yy1928; if (yych <= 0xF3) - goto yy1941; + goto yy1929; if (yych <= 0xF4) - goto yy1942; - goto yy1850; + goto yy1930; + goto yy1851; } } } - yy1921: + yy1909: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1921; + goto yy1909; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= '<') - goto yy1850; + goto yy1851; if (yych >= '?') - goto yy1924; + goto yy1912; } else { if (yych <= 0xC1) - goto yy1850; + goto yy1851; if (yych <= 0xDF) - goto yy1926; - goto yy1927; + goto yy1914; + goto yy1915; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1932; - goto yy1928; + goto yy1920; + goto yy1916; } else { if (yych <= 0xF0) - goto yy1929; + goto yy1917; if (yych <= 0xF3) - goto yy1930; + goto yy1918; if (yych <= 0xF4) - goto yy1931; - goto yy1850; + goto yy1919; + goto yy1851; } } - yy1923: + yy1911: yych = *++p; - goto yy1910; - yy1924: + goto yy1899; + yy1912: ++p; yych = *p; if (yych <= 0x7F) { if (yych <= '\r') { if (yych <= '\t') { if (yych <= 0x00) - goto yy1850; - goto yy1921; + goto yy1851; + goto yy1909; } else { if (yych <= '\n') - goto yy1850; + goto yy1851; if (yych <= '\f') - goto yy1921; - goto yy1850; + goto yy1909; + goto yy1851; } } else { if (yych <= '>') { if (yych <= '=') - goto yy1921; - goto yy1933; + goto yy1909; + goto yy1921; } else { if (yych == '\\') - goto yy1924; - goto yy1921; + goto yy1912; + goto yy1909; } } } else { if (yych <= 0xED) { if (yych <= 0xDF) { if (yych <= 0xC1) - goto yy1850; + goto yy1851; } else { if (yych <= 0xE0) - goto yy1927; + goto yy1915; if (yych <= 0xEC) - goto yy1928; - goto yy1932; + goto yy1916; + goto yy1920; } } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1928; - goto yy1929; + goto yy1916; + goto yy1917; } else { if (yych <= 0xF3) - goto yy1930; + goto yy1918; if (yych <= 0xF4) - goto yy1931; - goto yy1850; + goto yy1919; + goto yy1851; } } } - yy1926: + yy1914: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1921; - goto yy1850; - yy1927: + goto yy1909; + goto yy1851; + yy1915: ++p; yych = *p; if (yych <= 0x9F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1926; - goto yy1850; - yy1928: + goto yy1914; + goto yy1851; + yy1916: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1926; - goto yy1850; - yy1929: + goto yy1914; + goto yy1851; + yy1917: ++p; yych = *p; if (yych <= 0x8F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1928; - goto yy1850; - yy1930: + goto yy1916; + goto yy1851; + yy1918: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1928; - goto yy1850; - yy1931: + goto yy1916; + goto yy1851; + yy1919: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x8F) - goto yy1928; - goto yy1850; - yy1932: + goto yy1916; + goto yy1851; + yy1920: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x9F) - goto yy1926; - goto yy1850; - yy1933: + goto yy1914; + goto yy1851; + yy1921: yyaccept = 2; marker = ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1921; + goto yy1909; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= '<') - goto yy1910; + goto yy1899; if (yych <= '>') - goto yy1923; - goto yy1924; + goto yy1911; + goto yy1912; } else { if (yych <= 0xC1) - goto yy1910; + goto yy1899; if (yych <= 0xDF) - goto yy1926; - goto yy1927; + goto yy1914; + goto yy1915; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1932; - goto yy1928; + goto yy1920; + goto yy1916; } else { if (yych <= 0xF0) - goto yy1929; + goto yy1917; if (yych <= 0xF3) - goto yy1930; + goto yy1918; if (yych <= 0xF4) - goto yy1931; - goto yy1910; + goto yy1919; + goto yy1899; } } - yy1934: + yy1922: yyaccept = 2; yych = *(marker = ++p); if (yych <= '(') { if (yych <= ' ') - goto yy1910; + goto yy1899; if (yych <= '\'') goto yy1864; - goto yy1910; + goto yy1899; } else { if (yych <= 0x7F) goto yy1864; if (yych <= 0xC1) - goto yy1910; + goto yy1899; if (yych <= 0xF4) goto yy1864; - goto yy1910; + goto yy1899; } - yy1935: + yy1923: ++p; yych = *p; if (yych <= '[') { if (yych <= '\r') { if (yych <= '\t') { if (yych <= 0x00) - goto yy1850; - goto yy1921; + goto yy1851; + goto yy1909; } else { if (yych <= '\n') - goto yy1850; + goto yy1851; if (yych <= '\f') - goto yy1921; - goto yy1850; + goto yy1909; + goto yy1851; } } else { if (yych <= ')') { if (yych <= ' ') - goto yy1921; + goto yy1909; if (yych <= '(') - goto yy1919; - goto yy1944; + goto yy1907; + goto yy1932; } else { if (yych == '>') - goto yy1946; - goto yy1919; + goto yy1934; + goto yy1907; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\\') - goto yy1935; + goto yy1923; if (yych <= 0x7F) - goto yy1919; - goto yy1850; + goto yy1907; + goto yy1851; } else { if (yych <= 0xDF) - goto yy1937; + goto yy1925; if (yych <= 0xE0) - goto yy1938; - goto yy1939; + goto yy1926; + goto yy1927; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1943; + goto yy1931; if (yych <= 0xEF) - goto yy1939; - goto yy1940; + goto yy1927; + goto yy1928; } else { if (yych <= 0xF3) - goto yy1941; + goto yy1929; if (yych <= 0xF4) - goto yy1942; - goto yy1850; + goto yy1930; + goto yy1851; } } } - yy1937: + yy1925: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1919; - goto yy1850; - yy1938: + goto yy1907; + goto yy1851; + yy1926: ++p; yych = *p; if (yych <= 0x9F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1937; - goto yy1850; - yy1939: + goto yy1925; + goto yy1851; + yy1927: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1937; - goto yy1850; - yy1940: + goto yy1925; + goto yy1851; + yy1928: ++p; yych = *p; if (yych <= 0x8F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1939; - goto yy1850; - yy1941: + goto yy1927; + goto yy1851; + yy1929: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1939; - goto yy1850; - yy1942: + goto yy1927; + goto yy1851; + yy1930: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x8F) - goto yy1939; - goto yy1850; - yy1943: + goto yy1927; + goto yy1851; + yy1931: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x9F) - goto yy1937; - goto yy1850; - yy1944: + goto yy1925; + goto yy1851; + yy1932: yyaccept = 0; marker = ++p; yych = *p; @@ -23680,58 +23209,58 @@ bufsize_t _scan_link_url(const unsigned char *p) { if (yych <= 0x00) goto yy1843; if (yych <= '\t') - goto yy1921; + goto yy1909; goto yy1843; } else { if (yych == '\r') goto yy1843; - goto yy1921; + goto yy1909; } } else { if (yych <= ')') { if (yych <= '\'') - goto yy1944; + goto yy1932; if (yych <= '(') - goto yy1919; - goto yy1907; + goto yy1907; + goto yy1896; } else { if (yych == '<') - goto yy1889; + goto yy1883; if (yych <= '=') - goto yy1944; - goto yy1947; + goto yy1932; + goto yy1935; } } } else { if (yych <= 0xE0) { if (yych <= 0x7F) { if (yych == '\\') - goto yy1948; - goto yy1944; + goto yy1936; + goto yy1932; } else { if (yych <= 0xC1) goto yy1843; if (yych <= 0xDF) - goto yy1949; - goto yy1950; + goto yy1938; + goto yy1939; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1955; - goto yy1951; + goto yy1944; + goto yy1940; } else { if (yych <= 0xF0) - goto yy1952; + goto yy1941; if (yych <= 0xF3) - goto yy1953; + goto yy1942; if (yych <= 0xF4) - goto yy1954; + goto yy1943; goto yy1843; } } } - yy1946: + yy1934: yyaccept = 2; marker = ++p; yych = *p; @@ -23739,542 +23268,309 @@ bufsize_t _scan_link_url(const unsigned char *p) { if (yych <= ' ') { if (yych <= '\n') { if (yych <= 0x00) - goto yy1910; + goto yy1899; if (yych <= '\t') - goto yy1921; - goto yy1910; + goto yy1909; + goto yy1899; } else { if (yych == '\r') - goto yy1910; - goto yy1921; + goto yy1899; + goto yy1909; } } else { if (yych <= ')') { if (yych <= '\'') - goto yy1919; + goto yy1907; if (yych <= '(') - goto yy1921; - goto yy1907; + goto yy1909; + goto yy1896; } else { if (yych == '<') goto yy1863; if (yych <= '=') - goto yy1919; - goto yy1934; + goto yy1907; + goto yy1922; } } } else { if (yych <= 0xE0) { if (yych <= 0x7F) { if (yych == '\\') - goto yy1935; - goto yy1919; + goto yy1923; + goto yy1907; } else { if (yych <= 0xC1) - goto yy1910; + goto yy1899; if (yych <= 0xDF) - goto yy1937; - goto yy1938; + goto yy1925; + goto yy1926; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1943; - goto yy1939; + goto yy1931; + goto yy1927; } else { if (yych <= 0xF0) - goto yy1940; + goto yy1928; if (yych <= 0xF3) - goto yy1941; + goto yy1929; if (yych <= 0xF4) - goto yy1942; - goto yy1910; + goto yy1930; + goto yy1899; } } } - yy1947: + yy1935: yyaccept = 2; yych = *(marker = ++p); if (yych <= ' ') - goto yy1910; + goto yy1899; if (yych <= 0x7F) - goto yy1890; + goto yy1884; if (yych <= 0xC1) - goto yy1910; + goto yy1899; if (yych <= 0xF4) - goto yy1890; - goto yy1910; - yy1948: - ++p; - yych = *p; - if (yych <= '\\') { - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x00) - goto yy1872; - goto yy1907; - } else { - if (yych <= '\n') - goto yy1872; - if (yych <= '\f') - goto yy1907; - goto yy1872; - } - } else { - if (yych <= '=') { - if (yych <= ' ') - goto yy1907; - goto yy1944; - } else { - if (yych <= '>') - goto yy1956; - if (yych <= '[') - goto yy1944; - goto yy1957; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) - goto yy1944; - goto yy1850; - } else { - if (yych <= 0xDF) - goto yy1958; - if (yych <= 0xE0) - goto yy1959; - goto yy1960; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1964; - if (yych <= 0xEF) - goto yy1960; - goto yy1961; - } else { - if (yych <= 0xF3) - goto yy1962; - if (yych <= 0xF4) - goto yy1963; - goto yy1850; - } - } - } - yy1949: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1944; - goto yy1850; - yy1950: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy1850; - if (yych <= 0xBF) - goto yy1949; - goto yy1850; - yy1951: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1949; - goto yy1850; - yy1952: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy1850; - if (yych <= 0xBF) - goto yy1951; - goto yy1850; - yy1953: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1951; - goto yy1850; - yy1954: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0x8F) - goto yy1951; - goto yy1850; - yy1955: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0x9F) - goto yy1949; - goto yy1850; - yy1956: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yych <= '>') { - if (yych <= ' ') { - if (yych <= '\n') { - if (yych <= 0x00) - goto yy1910; - if (yych <= '\t') - goto yy1921; - goto yy1910; - } else { - if (yych == '\r') - goto yy1910; - goto yy1921; - } - } else { - if (yych <= ')') { - if (yych <= '\'') - goto yy1944; - if (yych <= '(') - goto yy1919; - goto yy1907; - } else { - if (yych == '<') - goto yy1889; - if (yych <= '=') - goto yy1944; - goto yy1947; - } - } - } else { - if (yych <= 0xE0) { - if (yych <= 0x7F) { - if (yych == '\\') - goto yy1948; - goto yy1944; - } else { - if (yych <= 0xC1) - goto yy1910; - if (yych <= 0xDF) - goto yy1949; - goto yy1950; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy1955; - goto yy1951; - } else { - if (yych <= 0xF0) - goto yy1952; - if (yych <= 0xF3) - goto yy1953; - if (yych <= 0xF4) - goto yy1954; - goto yy1910; - } - } - } - yy1957: + goto yy1884; + goto yy1899; + yy1936: yyaccept = 0; marker = ++p; yych = *p; - if (yych <= '[') { + if (yych <= '\\') { if (yych <= '\r') { if (yych <= '\t') { if (yych <= 0x00) goto yy1843; - goto yy1921; + goto yy1909; } else { if (yych <= '\n') goto yy1843; if (yych <= '\f') - goto yy1921; + goto yy1909; goto yy1843; } } else { - if (yych <= '(') { + if (yych <= '=') { if (yych <= ' ') - goto yy1921; - if (yych <= '\'') - goto yy1944; - goto yy1919; + goto yy1909; + goto yy1932; } else { - if (yych == '>') - goto yy1956; - goto yy1944; + if (yych <= '>') + goto yy1945; + if (yych <= '[') + goto yy1932; + goto yy1936; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { - if (yych <= '\\') - goto yy1948; if (yych <= 0x7F) - goto yy1944; + goto yy1932; goto yy1843; } else { if (yych <= 0xDF) - goto yy1949; + goto yy1938; if (yych <= 0xE0) - goto yy1950; - goto yy1951; + goto yy1939; + goto yy1940; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1955; + goto yy1944; if (yych <= 0xEF) - goto yy1951; - goto yy1952; + goto yy1940; + goto yy1941; } else { if (yych <= 0xF3) - goto yy1953; + goto yy1942; if (yych <= 0xF4) - goto yy1954; + goto yy1943; goto yy1843; } } } - yy1958: + yy1938: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1944; - goto yy1850; - yy1959: + goto yy1932; + goto yy1851; + yy1939: ++p; yych = *p; if (yych <= 0x9F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1958; - goto yy1850; - yy1960: + goto yy1938; + goto yy1851; + yy1940: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1958; - goto yy1850; - yy1961: + goto yy1938; + goto yy1851; + yy1941: ++p; yych = *p; if (yych <= 0x8F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1960; - goto yy1850; - yy1962: + goto yy1940; + goto yy1851; + yy1942: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0xBF) - goto yy1960; - goto yy1850; - yy1963: + goto yy1940; + goto yy1851; + yy1943: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x8F) - goto yy1960; - goto yy1850; - yy1964: + goto yy1940; + goto yy1851; + yy1944: ++p; yych = *p; if (yych <= 0x7F) - goto yy1850; + goto yy1851; if (yych <= 0x9F) - goto yy1958; - goto yy1850; - yy1965: + goto yy1938; + goto yy1851; + yy1945: yyaccept = 2; marker = ++p; yych = *p; - if (yybm[0 + yych] & 64) { - goto yy1907; - } if (yych <= '>') { - if (yych <= '\r') { - if (yych <= '\t') { + if (yych <= ' ') { + if (yych <= '\n') { if (yych <= 0x00) - goto yy1910; - goto yy1921; + goto yy1899; + if (yych <= '\t') + goto yy1909; + goto yy1899; } else { - if (yych <= '\n') - goto yy1910; - if (yych <= '\f') - goto yy1921; - goto yy1910; + if (yych == '\r') + goto yy1899; + goto yy1909; } } else { - if (yych <= '(') { - if (yych <= ' ') - goto yy1921; - goto yy1919; + if (yych <= ')') { + if (yych <= '\'') + goto yy1932; + if (yych <= '(') + goto yy1907; + goto yy1896; } else { - if (yych <= ')') - goto yy1921; - if (yych <= '<') - goto yy1872; - goto yy1909; + if (yych == '<') + goto yy1883; + if (yych <= '=') + goto yy1932; + goto yy1935; } } } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') - goto yy1918; - goto yy1910; + if (yych <= 0xE0) { + if (yych <= 0x7F) { + if (yych == '\\') + goto yy1936; + goto yy1932; } else { + if (yych <= 0xC1) + goto yy1899; if (yych <= 0xDF) - goto yy1911; - if (yych <= 0xE0) - goto yy1912; - goto yy1913; + goto yy1938; + goto yy1939; } } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1917; - if (yych <= 0xEF) - goto yy1913; - goto yy1914; + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1944; + goto yy1940; } else { + if (yych <= 0xF0) + goto yy1941; if (yych <= 0xF3) - goto yy1915; + goto yy1942; if (yych <= 0xF4) - goto yy1916; - goto yy1910; + goto yy1943; + goto yy1899; } } } - yy1966: - yyaccept = 0; + yy1946: + yyaccept = 2; marker = ++p; yych = *p; - if (yych <= '[') { - if (yych <= ' ') { - if (yych <= '\n') { + if (yybm[0 + yych] & 64) { + goto yy1896; + } + if (yych <= '>') { + if (yych <= '\r') { + if (yych <= '\t') { if (yych <= 0x00) - goto yy1843; - if (yych <= '\t') - goto yy1921; - goto yy1843; + goto yy1899; + goto yy1909; } else { - if (yych == '\r') - goto yy1843; - goto yy1921; + if (yych <= '\n') + goto yy1899; + if (yych <= '\f') + goto yy1909; + goto yy1899; } } else { - if (yych <= ')') { - if (yych <= '\'') - goto yy1907; - if (yych <= '(') - goto yy1919; - goto yy1921; - } else { - if (yych == '>') - goto yy1965; + if (yych <= '(') { + if (yych <= ' ') + goto yy1909; goto yy1907; + } else { + if (yych <= ')') + goto yy1909; + if (yych <= '<') + goto yy1872; + goto yy1898; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\\') - goto yy1918; - if (yych <= 0x7F) - goto yy1907; - goto yy1843; + goto yy1894; + goto yy1899; } else { if (yych <= 0xDF) - goto yy1911; + goto yy1900; if (yych <= 0xE0) - goto yy1912; - goto yy1913; + goto yy1901; + goto yy1902; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1917; + goto yy1906; if (yych <= 0xEF) - goto yy1913; - goto yy1914; + goto yy1902; + goto yy1903; } else { if (yych <= 0xF3) - goto yy1915; + goto yy1904; if (yych <= 0xF4) - goto yy1916; - goto yy1843; + goto yy1905; + goto yy1899; } } } - yy1967: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1907; - goto yy1850; - yy1968: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy1850; - if (yych <= 0xBF) - goto yy1967; - goto yy1850; - yy1969: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1967; - goto yy1850; - yy1970: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy1850; - if (yych <= 0xBF) - goto yy1969; - goto yy1850; - yy1971: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0xBF) - goto yy1969; - goto yy1850; - yy1972: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0x8F) - goto yy1969; - goto yy1850; - yy1973: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy1850; - if (yych <= 0x9F) - goto yy1967; - goto yy1850; } } @@ -24313,640 +23609,640 @@ bufsize_t _scan_link_title(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '"') { if (yych == '\n') - goto yy1976; + goto yy1949; if (yych <= '!') - goto yy1980; - goto yy1977; + goto yy1953; + goto yy1950; } else { if (yych <= '\'') { if (yych <= '&') - goto yy1980; - goto yy1978; + goto yy1953; + goto yy1951; } else { if (yych <= '(') - goto yy1979; + goto yy1952; if (yych <= 0x7F) - goto yy1980; + goto yy1953; } } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1981; + goto yy1954; if (yych <= 0xE0) - goto yy1983; + goto yy1956; if (yych <= 0xEC) - goto yy1984; - goto yy1988; + goto yy1957; + goto yy1961; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1984; - goto yy1985; + goto yy1957; + goto yy1958; } else { if (yych <= 0xF3) - goto yy1986; + goto yy1959; if (yych <= 0xF4) - goto yy1987; + goto yy1960; } } } - yy1976 : { return 0; } - yy1977: + yy1949 : { return 0; } + yy1950: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x00) - goto yy1976; + goto yy1949; if (yych <= 0x7F) - goto yy2020; + goto yy1993; if (yych <= 0xC1) - goto yy1976; + goto yy1949; if (yych <= 0xF4) - goto yy2020; - goto yy1976; - yy1978: + goto yy1993; + goto yy1949; + yy1951: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x00) - goto yy1976; + goto yy1949; if (yych <= 0x7F) - goto yy2006; + goto yy1979; if (yych <= 0xC1) - goto yy1976; + goto yy1949; if (yych <= 0xF4) - goto yy2006; - goto yy1976; - yy1979: + goto yy1979; + goto yy1949; + yy1952: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x00) - goto yy1976; + goto yy1949; if (yych <= 0x7F) - goto yy1992; + goto yy1965; if (yych <= 0xC1) - goto yy1976; + goto yy1949; if (yych <= 0xF4) - goto yy1992; - goto yy1976; - yy1980: + goto yy1965; + goto yy1949; + yy1953: yych = *++p; - goto yy1976; - yy1981: + goto yy1949; + yy1954: yych = *++p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy1980; - yy1982: + goto yy1953; + yy1955: p = marker; if (yyaccept <= 1) { if (yyaccept == 0) { - goto yy1976; + goto yy1949; } else { - goto yy2001; + goto yy1974; } } else { if (yyaccept == 2) { - goto yy2015; + goto yy1988; } else { - goto yy2029; + goto yy2002; } } - yy1983: + yy1956: yych = *++p; if (yych <= 0x9F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy1981; - goto yy1982; - yy1984: + goto yy1954; + goto yy1955; + yy1957: yych = *++p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy1981; - goto yy1982; - yy1985: + goto yy1954; + goto yy1955; + yy1958: yych = *++p; if (yych <= 0x8F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy1984; - goto yy1982; - yy1986: + goto yy1957; + goto yy1955; + yy1959: yych = *++p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy1984; - goto yy1982; - yy1987: + goto yy1957; + goto yy1955; + yy1960: yych = *++p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0x8F) - goto yy1984; - goto yy1982; - yy1988: + goto yy1957; + goto yy1955; + yy1961: yych = *++p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0x9F) - goto yy1981; - goto yy1982; - yy1989: + goto yy1954; + goto yy1955; + yy1962: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1991; + goto yy1964; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1982; + goto yy1955; if (yych <= ')') - goto yy2002; - goto yy1989; + goto yy1975; + goto yy1962; } else { if (yych <= 0xC1) - goto yy1982; + goto yy1955; if (yych <= 0xDF) - goto yy1993; - goto yy1994; + goto yy1966; + goto yy1967; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1999; - goto yy1995; + goto yy1972; + goto yy1968; } else { if (yych <= 0xF0) - goto yy1996; + goto yy1969; if (yych <= 0xF3) - goto yy1997; + goto yy1970; if (yych <= 0xF4) - goto yy1998; - goto yy1982; + goto yy1971; + goto yy1955; } } - yy1991: + yy1964: ++p; yych = *p; - yy1992: + yy1965: if (yybm[0 + yych] & 32) { - goto yy1991; + goto yy1964; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1982; + goto yy1955; if (yych <= ')') - goto yy2000; - goto yy1989; + goto yy1973; + goto yy1962; } else { if (yych <= 0xC1) - goto yy1982; + goto yy1955; if (yych >= 0xE0) - goto yy1994; + goto yy1967; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1999; - goto yy1995; + goto yy1972; + goto yy1968; } else { if (yych <= 0xF0) - goto yy1996; + goto yy1969; if (yych <= 0xF3) - goto yy1997; + goto yy1970; if (yych <= 0xF4) - goto yy1998; - goto yy1982; + goto yy1971; + goto yy1955; } } - yy1993: + yy1966: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy1991; - goto yy1982; - yy1994: + goto yy1964; + goto yy1955; + yy1967: ++p; yych = *p; if (yych <= 0x9F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy1993; - goto yy1982; - yy1995: + goto yy1966; + goto yy1955; + yy1968: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy1993; - goto yy1982; - yy1996: + goto yy1966; + goto yy1955; + yy1969: ++p; yych = *p; if (yych <= 0x8F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy1995; - goto yy1982; - yy1997: + goto yy1968; + goto yy1955; + yy1970: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy1995; - goto yy1982; - yy1998: + goto yy1968; + goto yy1955; + yy1971: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0x8F) - goto yy1995; - goto yy1982; - yy1999: + goto yy1968; + goto yy1955; + yy1972: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0x9F) - goto yy1993; - goto yy1982; - yy2000: + goto yy1966; + goto yy1955; + yy1973: ++p; - yy2001 : { return (bufsize_t)(p - start); } - yy2002: + yy1974 : { return (bufsize_t)(p - start); } + yy1975: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1991; + goto yy1964; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy2001; + goto yy1974; if (yych <= ')') - goto yy2000; - goto yy1989; + goto yy1973; + goto yy1962; } else { if (yych <= 0xC1) - goto yy2001; + goto yy1974; if (yych <= 0xDF) - goto yy1993; - goto yy1994; + goto yy1966; + goto yy1967; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1999; - goto yy1995; + goto yy1972; + goto yy1968; } else { if (yych <= 0xF0) - goto yy1996; + goto yy1969; if (yych <= 0xF3) - goto yy1997; + goto yy1970; if (yych <= 0xF4) - goto yy1998; - goto yy2001; + goto yy1971; + goto yy1974; } } - yy2003: + yy1976: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy2005; + goto yy1978; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1982; + goto yy1955; if (yych <= '\'') - goto yy2016; - goto yy2003; + goto yy1989; + goto yy1976; } else { if (yych <= 0xC1) - goto yy1982; + goto yy1955; if (yych <= 0xDF) - goto yy2007; - goto yy2008; + goto yy1980; + goto yy1981; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2013; - goto yy2009; + goto yy1986; + goto yy1982; } else { if (yych <= 0xF0) - goto yy2010; + goto yy1983; if (yych <= 0xF3) - goto yy2011; + goto yy1984; if (yych <= 0xF4) - goto yy2012; - goto yy1982; + goto yy1985; + goto yy1955; } } - yy2005: + yy1978: ++p; yych = *p; - yy2006: + yy1979: if (yybm[0 + yych] & 64) { - goto yy2005; + goto yy1978; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1982; + goto yy1955; if (yych <= '\'') - goto yy2014; - goto yy2003; + goto yy1987; + goto yy1976; } else { if (yych <= 0xC1) - goto yy1982; + goto yy1955; if (yych >= 0xE0) - goto yy2008; + goto yy1981; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2013; - goto yy2009; + goto yy1986; + goto yy1982; } else { if (yych <= 0xF0) - goto yy2010; + goto yy1983; if (yych <= 0xF3) - goto yy2011; + goto yy1984; if (yych <= 0xF4) - goto yy2012; - goto yy1982; + goto yy1985; + goto yy1955; } } - yy2007: + yy1980: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy2005; - goto yy1982; - yy2008: + goto yy1978; + goto yy1955; + yy1981: ++p; yych = *p; if (yych <= 0x9F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy2007; - goto yy1982; - yy2009: + goto yy1980; + goto yy1955; + yy1982: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy2007; - goto yy1982; - yy2010: + goto yy1980; + goto yy1955; + yy1983: ++p; yych = *p; if (yych <= 0x8F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy2009; - goto yy1982; - yy2011: + goto yy1982; + goto yy1955; + yy1984: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy2009; - goto yy1982; - yy2012: + goto yy1982; + goto yy1955; + yy1985: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0x8F) - goto yy2009; - goto yy1982; - yy2013: + goto yy1982; + goto yy1955; + yy1986: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0x9F) - goto yy2007; - goto yy1982; - yy2014: + goto yy1980; + goto yy1955; + yy1987: ++p; - yy2015 : { return (bufsize_t)(p - start); } - yy2016: + yy1988 : { return (bufsize_t)(p - start); } + yy1989: yyaccept = 2; marker = ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy2005; + goto yy1978; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy2015; + goto yy1988; if (yych <= '\'') - goto yy2014; - goto yy2003; + goto yy1987; + goto yy1976; } else { if (yych <= 0xC1) - goto yy2015; + goto yy1988; if (yych <= 0xDF) - goto yy2007; - goto yy2008; + goto yy1980; + goto yy1981; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2013; - goto yy2009; + goto yy1986; + goto yy1982; } else { if (yych <= 0xF0) - goto yy2010; + goto yy1983; if (yych <= 0xF3) - goto yy2011; + goto yy1984; if (yych <= 0xF4) - goto yy2012; - goto yy2015; + goto yy1985; + goto yy1988; } } - yy2017: + yy1990: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy2019; + goto yy1992; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1982; + goto yy1955; if (yych <= '"') - goto yy2030; - goto yy2017; + goto yy2003; + goto yy1990; } else { if (yych <= 0xC1) - goto yy1982; + goto yy1955; if (yych <= 0xDF) - goto yy2021; - goto yy2022; + goto yy1994; + goto yy1995; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2027; - goto yy2023; + goto yy2000; + goto yy1996; } else { if (yych <= 0xF0) - goto yy2024; + goto yy1997; if (yych <= 0xF3) - goto yy2025; + goto yy1998; if (yych <= 0xF4) - goto yy2026; - goto yy1982; + goto yy1999; + goto yy1955; } } - yy2019: + yy1992: ++p; yych = *p; - yy2020: + yy1993: if (yybm[0 + yych] & 128) { - goto yy2019; + goto yy1992; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1982; + goto yy1955; if (yych <= '"') - goto yy2028; - goto yy2017; + goto yy2001; + goto yy1990; } else { if (yych <= 0xC1) - goto yy1982; + goto yy1955; if (yych >= 0xE0) - goto yy2022; + goto yy1995; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2027; - goto yy2023; + goto yy2000; + goto yy1996; } else { if (yych <= 0xF0) - goto yy2024; + goto yy1997; if (yych <= 0xF3) - goto yy2025; + goto yy1998; if (yych <= 0xF4) - goto yy2026; - goto yy1982; + goto yy1999; + goto yy1955; } } - yy2021: + yy1994: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy2019; - goto yy1982; - yy2022: + goto yy1992; + goto yy1955; + yy1995: ++p; yych = *p; if (yych <= 0x9F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy2021; - goto yy1982; - yy2023: + goto yy1994; + goto yy1955; + yy1996: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy2021; - goto yy1982; - yy2024: + goto yy1994; + goto yy1955; + yy1997: ++p; yych = *p; if (yych <= 0x8F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy2023; - goto yy1982; - yy2025: + goto yy1996; + goto yy1955; + yy1998: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0xBF) - goto yy2023; - goto yy1982; - yy2026: + goto yy1996; + goto yy1955; + yy1999: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0x8F) - goto yy2023; - goto yy1982; - yy2027: + goto yy1996; + goto yy1955; + yy2000: ++p; yych = *p; if (yych <= 0x7F) - goto yy1982; + goto yy1955; if (yych <= 0x9F) - goto yy2021; - goto yy1982; - yy2028: + goto yy1994; + goto yy1955; + yy2001: ++p; - yy2029 : { return (bufsize_t)(p - start); } - yy2030: + yy2002 : { return (bufsize_t)(p - start); } + yy2003: yyaccept = 3; marker = ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy2019; + goto yy1992; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy2029; + goto yy2002; if (yych <= '"') - goto yy2028; - goto yy2017; + goto yy2001; + goto yy1990; } else { if (yych <= 0xC1) - goto yy2029; + goto yy2002; if (yych <= 0xDF) - goto yy2021; - goto yy2022; + goto yy1994; + goto yy1995; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2027; - goto yy2023; + goto yy2000; + goto yy1996; } else { if (yych <= 0xF0) - goto yy2024; + goto yy1997; if (yych <= 0xF3) - goto yy2025; + goto yy1998; if (yych <= 0xF4) - goto yy2026; - goto yy2029; + goto yy1999; + goto yy2002; } } } @@ -24978,109 +24274,109 @@ bufsize_t _scan_spacechars(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '\r') { if (yych <= 0x08) - goto yy2037; + goto yy2010; if (yych == '\n') - goto yy2035; - goto yy2034; + goto yy2008; + goto yy2007; } else { if (yych == ' ') - goto yy2034; + goto yy2007; if (yych <= 0x7F) - goto yy2037; + goto yy2010; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy2039; + goto yy2012; if (yych <= 0xE0) - goto yy2041; + goto yy2014; if (yych <= 0xEC) - goto yy2042; - goto yy2046; + goto yy2015; + goto yy2019; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy2042; - goto yy2043; + goto yy2015; + goto yy2016; } else { if (yych <= 0xF3) - goto yy2044; + goto yy2017; if (yych <= 0xF4) - goto yy2045; + goto yy2018; } } } - yy2033 : { return (bufsize_t)(p - start); } - yy2034: + yy2006 : { return (bufsize_t)(p - start); } + yy2007: yych = *++p; - goto yy2036; - yy2035: + goto yy2009; + yy2008: ++p; yych = *p; - yy2036: + yy2009: if (yybm[0 + yych] & 128) { - goto yy2035; + goto yy2008; } - goto yy2033; - yy2037: + goto yy2006; + yy2010: ++p; { return 0; } - yy2039: + yy2012: yych = *++p; if (yych <= 0x7F) - goto yy2040; + goto yy2013; if (yych <= 0xBF) - goto yy2037; - yy2040: + goto yy2010; + yy2013: p = marker; - goto yy2033; - yy2041: + goto yy2006; + yy2014: yych = *++p; if (yych <= 0x9F) - goto yy2040; + goto yy2013; if (yych <= 0xBF) - goto yy2039; - goto yy2040; - yy2042: + goto yy2012; + goto yy2013; + yy2015: yych = *++p; if (yych <= 0x7F) - goto yy2040; + goto yy2013; if (yych <= 0xBF) - goto yy2039; - goto yy2040; - yy2043: + goto yy2012; + goto yy2013; + yy2016: yych = *++p; if (yych <= 0x8F) - goto yy2040; + goto yy2013; if (yych <= 0xBF) - goto yy2042; - goto yy2040; - yy2044: + goto yy2015; + goto yy2013; + yy2017: yych = *++p; if (yych <= 0x7F) - goto yy2040; + goto yy2013; if (yych <= 0xBF) - goto yy2042; - goto yy2040; - yy2045: + goto yy2015; + goto yy2013; + yy2018: yych = *++p; if (yych <= 0x7F) - goto yy2040; + goto yy2013; if (yych <= 0x8F) - goto yy2042; - goto yy2040; - yy2046: + goto yy2015; + goto yy2013; + yy2019: ++p; if ((yych = *p) <= 0x7F) - goto yy2040; + goto yy2013; if (yych <= 0x9F) - goto yy2039; - goto yy2040; + goto yy2012; + goto yy2013; } } -// Match ATX header start. -bufsize_t _scan_atx_header_start(const unsigned char *p) { +// Match ATX heading start. +bufsize_t _scan_atx_heading_start(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -25104,184 +24400,184 @@ bufsize_t _scan_atx_header_start(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= '"') { if (yych != '\n') - goto yy2051; + goto yy2024; } else { if (yych <= '#') - goto yy2050; + goto yy2023; if (yych <= 0x7F) - goto yy2051; + goto yy2024; if (yych >= 0xC2) - goto yy2052; + goto yy2025; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy2054; + goto yy2027; if (yych == 0xED) - goto yy2059; - goto yy2055; + goto yy2032; + goto yy2028; } else { if (yych <= 0xF0) - goto yy2056; + goto yy2029; if (yych <= 0xF3) - goto yy2057; + goto yy2030; if (yych <= 0xF4) - goto yy2058; + goto yy2031; } } - yy2049 : { return 0; } - yy2050: + yy2022 : { return 0; } + yy2023: yych = *(marker = ++p); if (yybm[0 + yych] & 128) { - goto yy2062; + goto yy2035; } if (yych <= '\f') { if (yych == '\n') - goto yy2060; - goto yy2049; + goto yy2033; + goto yy2022; } else { if (yych <= '\r') - goto yy2060; + goto yy2033; if (yych == '#') - goto yy2064; - goto yy2049; + goto yy2037; + goto yy2022; } - yy2051: + yy2024: yych = *++p; - goto yy2049; - yy2052: + goto yy2022; + yy2025: yych = *++p; if (yych <= 0x7F) - goto yy2053; + goto yy2026; if (yych <= 0xBF) - goto yy2051; - yy2053: + goto yy2024; + yy2026: p = marker; - goto yy2049; - yy2054: + goto yy2022; + yy2027: yych = *++p; if (yych <= 0x9F) - goto yy2053; + goto yy2026; if (yych <= 0xBF) - goto yy2052; - goto yy2053; - yy2055: + goto yy2025; + goto yy2026; + yy2028: yych = *++p; if (yych <= 0x7F) - goto yy2053; + goto yy2026; if (yych <= 0xBF) - goto yy2052; - goto yy2053; - yy2056: + goto yy2025; + goto yy2026; + yy2029: yych = *++p; if (yych <= 0x8F) - goto yy2053; + goto yy2026; if (yych <= 0xBF) - goto yy2055; - goto yy2053; - yy2057: + goto yy2028; + goto yy2026; + yy2030: yych = *++p; if (yych <= 0x7F) - goto yy2053; + goto yy2026; if (yych <= 0xBF) - goto yy2055; - goto yy2053; - yy2058: + goto yy2028; + goto yy2026; + yy2031: yych = *++p; if (yych <= 0x7F) - goto yy2053; + goto yy2026; if (yych <= 0x8F) - goto yy2055; - goto yy2053; - yy2059: + goto yy2028; + goto yy2026; + yy2032: yych = *++p; if (yych <= 0x7F) - goto yy2053; + goto yy2026; if (yych <= 0x9F) - goto yy2052; - goto yy2053; - yy2060: + goto yy2025; + goto yy2026; + yy2033: ++p; - yy2061 : { return (bufsize_t)(p - start); } - yy2062: + yy2034 : { return (bufsize_t)(p - start); } + yy2035: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy2062; + goto yy2035; } - goto yy2061; - yy2064: + goto yy2034; + yy2037: yych = *++p; if (yybm[0 + yych] & 128) { - goto yy2062; + goto yy2035; } if (yych <= '\f') { if (yych == '\n') - goto yy2060; - goto yy2053; + goto yy2033; + goto yy2026; } else { if (yych <= '\r') - goto yy2060; + goto yy2033; if (yych != '#') - goto yy2053; + goto yy2026; } yych = *++p; if (yybm[0 + yych] & 128) { - goto yy2062; + goto yy2035; } if (yych <= '\f') { if (yych == '\n') - goto yy2060; - goto yy2053; + goto yy2033; + goto yy2026; } else { if (yych <= '\r') - goto yy2060; + goto yy2033; if (yych != '#') - goto yy2053; + goto yy2026; } yych = *++p; if (yybm[0 + yych] & 128) { - goto yy2062; + goto yy2035; } if (yych <= '\f') { if (yych == '\n') - goto yy2060; - goto yy2053; + goto yy2033; + goto yy2026; } else { if (yych <= '\r') - goto yy2060; + goto yy2033; if (yych != '#') - goto yy2053; + goto yy2026; } yych = *++p; if (yybm[0 + yych] & 128) { - goto yy2062; + goto yy2035; } if (yych <= '\f') { if (yych == '\n') - goto yy2060; - goto yy2053; + goto yy2033; + goto yy2026; } else { if (yych <= '\r') - goto yy2060; + goto yy2033; if (yych != '#') - goto yy2053; + goto yy2026; } ++p; if (yybm[0 + (yych = *p)] & 128) { - goto yy2062; + goto yy2035; } if (yych == '\n') - goto yy2060; + goto yy2033; if (yych == '\r') - goto yy2060; - goto yy2053; + goto yy2033; + goto yy2026; } } -// Match setext header line. Return 1 for level-1 header, +// Match setext heading line. Return 1 for level-1 heading, // 2 for level-2, 0 for no match. -bufsize_t _scan_setext_header_line(const unsigned char *p) { +bufsize_t _scan_setext_heading_line(const unsigned char *p) { const unsigned char *marker = NULL; { @@ -25304,204 +24600,204 @@ bufsize_t _scan_setext_header_line(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '-') { if (yych == '\n') - goto yy2071; + goto yy2044; if (yych <= ',') - goto yy2074; - goto yy2073; + goto yy2047; + goto yy2046; } else { if (yych == '=') - goto yy2072; + goto yy2045; if (yych <= 0x7F) - goto yy2074; + goto yy2047; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy2075; + goto yy2048; if (yych <= 0xE0) - goto yy2077; + goto yy2050; if (yych <= 0xEC) - goto yy2078; - goto yy2082; + goto yy2051; + goto yy2055; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy2078; - goto yy2079; + goto yy2051; + goto yy2052; } else { if (yych <= 0xF3) - goto yy2080; + goto yy2053; if (yych <= 0xF4) - goto yy2081; + goto yy2054; } } } - yy2071 : { return 0; } - yy2072: + yy2044 : { return 0; } + yy2045: yych = *(marker = ++p); if (yybm[0 + yych] & 128) { - goto yy2093; + goto yy2066; } if (yych <= '\f') { if (yych == '\n') - goto yy2091; - goto yy2071; + goto yy2064; + goto yy2044; } else { if (yych <= '\r') - goto yy2091; + goto yy2064; if (yych == ' ') - goto yy2089; - goto yy2071; + goto yy2062; + goto yy2044; } - yy2073: + yy2046: yych = *(marker = ++p); if (yybm[0 + yych] & 32) { - goto yy2083; + goto yy2056; } if (yych <= '\f') { if (yych == '\n') - goto yy2085; - goto yy2071; + goto yy2058; + goto yy2044; } else { if (yych <= '\r') - goto yy2085; + goto yy2058; if (yych == '-') - goto yy2087; - goto yy2071; + goto yy2060; + goto yy2044; } - yy2074: + yy2047: yych = *++p; - goto yy2071; - yy2075: + goto yy2044; + yy2048: yych = *++p; if (yych <= 0x7F) - goto yy2076; + goto yy2049; if (yych <= 0xBF) - goto yy2074; - yy2076: + goto yy2047; + yy2049: p = marker; - goto yy2071; - yy2077: + goto yy2044; + yy2050: yych = *++p; if (yych <= 0x9F) - goto yy2076; + goto yy2049; if (yych <= 0xBF) - goto yy2075; - goto yy2076; - yy2078: + goto yy2048; + goto yy2049; + yy2051: yych = *++p; if (yych <= 0x7F) - goto yy2076; + goto yy2049; if (yych <= 0xBF) - goto yy2075; - goto yy2076; - yy2079: + goto yy2048; + goto yy2049; + yy2052: yych = *++p; if (yych <= 0x8F) - goto yy2076; + goto yy2049; if (yych <= 0xBF) - goto yy2078; - goto yy2076; - yy2080: + goto yy2051; + goto yy2049; + yy2053: yych = *++p; if (yych <= 0x7F) - goto yy2076; + goto yy2049; if (yych <= 0xBF) - goto yy2078; - goto yy2076; - yy2081: + goto yy2051; + goto yy2049; + yy2054: yych = *++p; if (yych <= 0x7F) - goto yy2076; + goto yy2049; if (yych <= 0x8F) - goto yy2078; - goto yy2076; - yy2082: + goto yy2051; + goto yy2049; + yy2055: yych = *++p; if (yych <= 0x7F) - goto yy2076; + goto yy2049; if (yych <= 0x9F) - goto yy2075; - goto yy2076; - yy2083: + goto yy2048; + goto yy2049; + yy2056: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy2083; + goto yy2056; } if (yych == '\n') - goto yy2085; + goto yy2058; if (yych != '\r') - goto yy2076; - yy2085: + goto yy2049; + yy2058: ++p; { return 2; } - yy2087: + yy2060: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy2083; + goto yy2056; } if (yych <= '\f') { if (yych == '\n') - goto yy2085; - goto yy2076; + goto yy2058; + goto yy2049; } else { if (yych <= '\r') - goto yy2085; + goto yy2058; if (yych == '-') - goto yy2087; - goto yy2076; + goto yy2060; + goto yy2049; } - yy2089: + yy2062: ++p; yych = *p; if (yych <= '\f') { if (yych != '\n') - goto yy2076; + goto yy2049; } else { if (yych <= '\r') - goto yy2091; + goto yy2064; if (yych == ' ') - goto yy2089; - goto yy2076; + goto yy2062; + goto yy2049; } - yy2091: + yy2064: ++p; { return 1; } - yy2093: + yy2066: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy2093; + goto yy2066; } if (yych <= '\f') { if (yych == '\n') - goto yy2091; - goto yy2076; + goto yy2064; + goto yy2049; } else { if (yych <= '\r') - goto yy2091; + goto yy2064; if (yych == ' ') - goto yy2089; - goto yy2076; + goto yy2062; + goto yy2049; } } } -// Scan a horizontal rule line: "...three or more hyphens, asterisks, +// Scan a thematic break 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." -bufsize_t _scan_hrule(const unsigned char *p) { +bufsize_t _scan_thematic_break(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, 16, 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, 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, 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, @@ -25516,269 +24812,347 @@ bufsize_t _scan_hrule(const unsigned char *p) { if (yych <= 0x7F) { if (yych <= '*') { if (yych == '\n') - goto yy2097; + goto yy2070; if (yych <= ')') - goto yy2101; - goto yy2098; + goto yy2074; + goto yy2071; } else { if (yych <= '-') { if (yych <= ',') - goto yy2101; - goto yy2100; + goto yy2074; + goto yy2073; } else { if (yych == '_') - goto yy2099; - goto yy2101; + goto yy2072; + goto yy2074; } } } else { if (yych <= 0xED) { if (yych <= 0xDF) { if (yych >= 0xC2) - goto yy2102; + goto yy2075; } else { if (yych <= 0xE0) - goto yy2104; + goto yy2077; if (yych <= 0xEC) - goto yy2105; - goto yy2109; + goto yy2078; + goto yy2082; } } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy2105; - goto yy2106; + goto yy2078; + goto yy2079; } else { if (yych <= 0xF3) - goto yy2107; + goto yy2080; if (yych <= 0xF4) - goto yy2108; + goto yy2081; } } } - yy2097 : { return 0; } - yy2098: + yy2070 : { return 0; } + yy2071: yych = *(marker = ++p); if (yych == ' ') - goto yy2130; + goto yy2107; if (yych == '*') - goto yy2132; - goto yy2097; - yy2099: + goto yy2109; + goto yy2070; + yy2072: yych = *(marker = ++p); if (yych == ' ') - goto yy2120; + goto yy2095; if (yych == '_') - goto yy2122; - goto yy2097; - yy2100: + goto yy2097; + goto yy2070; + yy2073: yych = *(marker = ++p); if (yybm[0 + yych] & 8) { - goto yy2110; + goto yy2083; } if (yych == '-') - goto yy2112; - goto yy2097; - yy2101: + goto yy2085; + goto yy2070; + yy2074: yych = *++p; - goto yy2097; - yy2102: + goto yy2070; + yy2075: yych = *++p; if (yych <= 0x7F) - goto yy2103; + goto yy2076; if (yych <= 0xBF) - goto yy2101; - yy2103: + goto yy2074; + yy2076: p = marker; - goto yy2097; - yy2104: + goto yy2070; + yy2077: yych = *++p; if (yych <= 0x9F) - goto yy2103; + goto yy2076; if (yych <= 0xBF) - goto yy2102; - goto yy2103; - yy2105: + goto yy2075; + goto yy2076; + yy2078: yych = *++p; if (yych <= 0x7F) - goto yy2103; + goto yy2076; if (yych <= 0xBF) - goto yy2102; - goto yy2103; - yy2106: + goto yy2075; + goto yy2076; + yy2079: yych = *++p; if (yych <= 0x8F) - goto yy2103; + goto yy2076; if (yych <= 0xBF) - goto yy2105; - goto yy2103; - yy2107: + goto yy2078; + goto yy2076; + yy2080: yych = *++p; if (yych <= 0x7F) - goto yy2103; + goto yy2076; if (yych <= 0xBF) - goto yy2105; - goto yy2103; - yy2108: + goto yy2078; + goto yy2076; + yy2081: yych = *++p; if (yych <= 0x7F) - goto yy2103; + goto yy2076; if (yych <= 0x8F) - goto yy2105; - goto yy2103; - yy2109: + goto yy2078; + goto yy2076; + yy2082: yych = *++p; if (yych <= 0x7F) - goto yy2103; + goto yy2076; if (yych <= 0x9F) - goto yy2102; - goto yy2103; - yy2110: + goto yy2075; + goto yy2076; + yy2083: ++p; yych = *p; if (yybm[0 + yych] & 8) { - goto yy2110; + goto yy2083; } if (yych != '-') - goto yy2103; - yy2112: + goto yy2076; + yy2085: ++p; yych = *p; if (yych == ' ') - goto yy2112; + goto yy2085; if (yych != '-') - goto yy2103; - yy2114: + goto yy2076; + yy2087: ++p; yych = *p; - if (yybm[0 + yych] & 16) { - goto yy2114; - } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy2103; - if (yych >= '\n') - goto yy2118; + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x08) + goto yy2076; + } else { + if (yych <= '\n') + goto yy2091; + if (yych <= '\f') + goto yy2076; + goto yy2091; + } } else { - if (yych == '\r') - goto yy2118; - goto yy2103; + if (yych <= ' ') { + if (yych <= 0x1F) + goto yy2076; + goto yy2087; + } else { + if (yych == '-') + goto yy2093; + goto yy2076; + } } - yy2116: + yy2089: ++p; yych = *p; - if (yybm[0 + yych] & 32) { - goto yy2116; + if (yybm[0 + yych] & 16) { + goto yy2089; } if (yych <= 0x08) - goto yy2103; + goto yy2076; if (yych <= '\n') - goto yy2118; + goto yy2091; if (yych != '\r') - goto yy2103; - yy2118: + goto yy2076; + yy2091: ++p; { return (bufsize_t)(p - start); } - yy2120: + yy2093: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy2093; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy2076; + if (yych <= '\t') + goto yy2089; + goto yy2091; + } else { + if (yych == '\r') + goto yy2091; + goto yy2076; + } + yy2095: ++p; yych = *p; if (yych == ' ') - goto yy2120; + goto yy2095; if (yych != '_') - goto yy2103; - yy2122: + goto yy2076; + yy2097: ++p; yych = *p; if (yych == ' ') - goto yy2122; + goto yy2097; if (yych != '_') - goto yy2103; - yy2124: + goto yy2076; + yy2099: ++p; yych = *p; - if (yybm[0 + yych] & 64) { - goto yy2124; - } - if (yych <= '\n') { - if (yych <= 0x08) + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x08) + goto yy2076; + } else { + if (yych <= '\n') + goto yy2103; + if (yych <= '\f') + goto yy2076; goto yy2103; - if (yych >= '\n') - goto yy2128; + } } else { - if (yych == '\r') - goto yy2128; - goto yy2103; + if (yych <= ' ') { + if (yych <= 0x1F) + goto yy2076; + goto yy2099; + } else { + if (yych == '_') + goto yy2105; + goto yy2076; + } } - yy2126: + yy2101: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) - goto yy2103; + goto yy2076; if (yych <= '\t') - goto yy2126; + goto yy2101; if (yych >= '\v') - goto yy2103; + goto yy2076; } else { if (yych <= '\r') - goto yy2128; + goto yy2103; if (yych == ' ') - goto yy2126; - goto yy2103; + goto yy2101; + goto yy2076; } - yy2128: + yy2103: ++p; { return (bufsize_t)(p - start); } - yy2130: + yy2105: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy2105; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy2076; + if (yych <= '\t') + goto yy2101; + goto yy2103; + } else { + if (yych == '\r') + goto yy2103; + goto yy2076; + } + yy2107: ++p; yych = *p; if (yych == ' ') - goto yy2130; + goto yy2107; if (yych != '*') - goto yy2103; - yy2132: + goto yy2076; + yy2109: ++p; yych = *p; if (yych == ' ') - goto yy2132; + goto yy2109; if (yych != '*') - goto yy2103; - yy2134: + goto yy2076; + yy2111: ++p; yych = *p; - if (yybm[0 + yych] & 128) { - goto yy2134; - } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy2103; - if (yych >= '\n') - goto yy2138; + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x08) + goto yy2076; + } else { + if (yych <= '\n') + goto yy2115; + if (yych <= '\f') + goto yy2076; + goto yy2115; + } } else { - if (yych == '\r') - goto yy2138; - goto yy2103; + if (yych <= ' ') { + if (yych <= 0x1F) + goto yy2076; + goto yy2111; + } else { + if (yych == '*') + goto yy2117; + goto yy2076; + } } - yy2136: + yy2113: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) - goto yy2103; + goto yy2076; if (yych <= '\t') - goto yy2136; + goto yy2113; if (yych >= '\v') - goto yy2103; + goto yy2076; } else { if (yych <= '\r') - goto yy2138; + goto yy2115; if (yych == ' ') - goto yy2136; - goto yy2103; + goto yy2113; + goto yy2076; } - yy2138: + yy2115: ++p; { return (bufsize_t)(p - start); } + yy2117: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy2117; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy2076; + if (yych <= '\t') + goto yy2113; + goto yy2115; + } else { + if (yych == '\r') + goto yy2115; + goto yy2076; + } } } @@ -25814,374 +25188,374 @@ bufsize_t _scan_open_code_fence(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '`') { if (yych == '\n') - goto yy2142; + goto yy2121; if (yych <= '_') - goto yy2145; - goto yy2143; + goto yy2124; + goto yy2122; } else { if (yych == '~') - goto yy2144; + goto yy2123; if (yych <= 0x7F) - goto yy2145; + goto yy2124; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy2146; + goto yy2125; if (yych <= 0xE0) - goto yy2148; + goto yy2127; if (yych <= 0xEC) - goto yy2149; - goto yy2153; + goto yy2128; + goto yy2132; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy2149; - goto yy2150; + goto yy2128; + goto yy2129; } else { if (yych <= 0xF3) - goto yy2151; + goto yy2130; if (yych <= 0xF4) - goto yy2152; + goto yy2131; } } } - yy2142 : { return 0; } - yy2143: + yy2121 : { return 0; } + yy2122: yych = *(marker = ++p); if (yych == '`') - goto yy2168; - goto yy2142; - yy2144: + goto yy2147; + goto yy2121; + yy2123: yych = *(marker = ++p); if (yych == '~') - goto yy2154; - goto yy2142; - yy2145: + goto yy2133; + goto yy2121; + yy2124: yych = *++p; - goto yy2142; - yy2146: + goto yy2121; + yy2125: yych = *++p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2145; - yy2147: + goto yy2124; + yy2126: p = marker; - goto yy2142; - yy2148: + goto yy2121; + yy2127: yych = *++p; if (yych <= 0x9F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2146; - goto yy2147; - yy2149: + goto yy2125; + goto yy2126; + yy2128: yych = *++p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2146; - goto yy2147; - yy2150: + goto yy2125; + goto yy2126; + yy2129: yych = *++p; if (yych <= 0x8F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2149; - goto yy2147; - yy2151: + goto yy2128; + goto yy2126; + yy2130: yych = *++p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2149; - goto yy2147; - yy2152: + goto yy2128; + goto yy2126; + yy2131: yych = *++p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0x8F) - goto yy2149; - goto yy2147; - yy2153: + goto yy2128; + goto yy2126; + yy2132: yych = *++p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0x9F) - goto yy2146; - goto yy2147; - yy2154: + goto yy2125; + goto yy2126; + yy2133: yych = *++p; if (yybm[0 + yych] & 16) { - goto yy2155; + goto yy2134; } - goto yy2147; - yy2155: - marker = p + 1; + goto yy2126; + yy2134: ++p; yych = *p; + marker = p; if (yybm[0 + yych] & 32) { - goto yy2157; + goto yy2136; } if (yych <= 0xE0) { if (yych <= '~') { if (yych <= 0x00) - goto yy2147; + goto yy2126; if (yych <= '\r') - goto yy2166; - goto yy2155; + goto yy2145; + goto yy2134; } else { if (yych <= 0xC1) - goto yy2147; + goto yy2126; if (yych <= 0xDF) - goto yy2159; - goto yy2160; + goto yy2138; + goto yy2139; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2165; - goto yy2161; + goto yy2144; + goto yy2140; } else { if (yych <= 0xF0) - goto yy2162; + goto yy2141; if (yych <= 0xF3) - goto yy2163; + goto yy2142; if (yych <= 0xF4) - goto yy2164; - goto yy2147; + goto yy2143; + goto yy2126; } } - yy2157: + yy2136: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy2157; + goto yy2136; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy2147; + goto yy2126; if (yych <= '\r') - goto yy2166; - goto yy2147; + goto yy2145; + goto yy2126; } else { if (yych <= 0xDF) - goto yy2159; + goto yy2138; if (yych <= 0xE0) - goto yy2160; - goto yy2161; + goto yy2139; + goto yy2140; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy2165; + goto yy2144; if (yych <= 0xEF) - goto yy2161; - goto yy2162; + goto yy2140; + goto yy2141; } else { if (yych <= 0xF3) - goto yy2163; + goto yy2142; if (yych <= 0xF4) - goto yy2164; - goto yy2147; + goto yy2143; + goto yy2126; } } - yy2159: + yy2138: ++p; yych = *p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2157; - goto yy2147; - yy2160: + goto yy2136; + goto yy2126; + yy2139: ++p; yych = *p; if (yych <= 0x9F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2159; - goto yy2147; - yy2161: + goto yy2138; + goto yy2126; + yy2140: ++p; yych = *p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2159; - goto yy2147; - yy2162: + goto yy2138; + goto yy2126; + yy2141: ++p; yych = *p; if (yych <= 0x8F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2161; - goto yy2147; - yy2163: + goto yy2140; + goto yy2126; + yy2142: ++p; yych = *p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2161; - goto yy2147; - yy2164: + goto yy2140; + goto yy2126; + yy2143: ++p; yych = *p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0x8F) - goto yy2161; - goto yy2147; - yy2165: + goto yy2140; + goto yy2126; + yy2144: ++p; yych = *p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0x9F) - goto yy2159; - goto yy2147; - yy2166: + goto yy2138; + goto yy2126; + yy2145: ++p; p = marker; { return (bufsize_t)(p - start); } - yy2168: + yy2147: yych = *++p; if (yybm[0 + yych] & 64) { - goto yy2169; + goto yy2148; } - goto yy2147; - yy2169: - marker = p + 1; + goto yy2126; + yy2148: ++p; yych = *p; + marker = p; if (yybm[0 + yych] & 128) { - goto yy2171; + goto yy2150; } if (yych <= 0xE0) { if (yych <= '`') { if (yych <= 0x00) - goto yy2147; + goto yy2126; if (yych <= '\r') - goto yy2180; - goto yy2169; + goto yy2159; + goto yy2148; } else { if (yych <= 0xC1) - goto yy2147; + goto yy2126; if (yych <= 0xDF) - goto yy2173; - goto yy2174; + goto yy2152; + goto yy2153; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2179; - goto yy2175; + goto yy2158; + goto yy2154; } else { if (yych <= 0xF0) - goto yy2176; + goto yy2155; if (yych <= 0xF3) - goto yy2177; + goto yy2156; if (yych <= 0xF4) - goto yy2178; - goto yy2147; + goto yy2157; + goto yy2126; } } - yy2171: + yy2150: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy2171; + goto yy2150; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy2147; + goto yy2126; if (yych <= '\r') - goto yy2180; - goto yy2147; + goto yy2159; + goto yy2126; } else { if (yych <= 0xDF) - goto yy2173; + goto yy2152; if (yych <= 0xE0) - goto yy2174; - goto yy2175; + goto yy2153; + goto yy2154; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy2179; + goto yy2158; if (yych <= 0xEF) - goto yy2175; - goto yy2176; + goto yy2154; + goto yy2155; } else { if (yych <= 0xF3) - goto yy2177; + goto yy2156; if (yych <= 0xF4) - goto yy2178; - goto yy2147; + goto yy2157; + goto yy2126; } } - yy2173: + yy2152: ++p; yych = *p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2171; - goto yy2147; - yy2174: + goto yy2150; + goto yy2126; + yy2153: ++p; yych = *p; if (yych <= 0x9F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2173; - goto yy2147; - yy2175: + goto yy2152; + goto yy2126; + yy2154: ++p; yych = *p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2173; - goto yy2147; - yy2176: + goto yy2152; + goto yy2126; + yy2155: ++p; yych = *p; if (yych <= 0x8F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2175; - goto yy2147; - yy2177: + goto yy2154; + goto yy2126; + yy2156: ++p; yych = *p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0xBF) - goto yy2175; - goto yy2147; - yy2178: + goto yy2154; + goto yy2126; + yy2157: ++p; yych = *p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0x8F) - goto yy2175; - goto yy2147; - yy2179: + goto yy2154; + goto yy2126; + yy2158: ++p; yych = *p; if (yych <= 0x7F) - goto yy2147; + goto yy2126; if (yych <= 0x9F) - goto yy2173; - goto yy2147; - yy2180: + goto yy2152; + goto yy2126; + yy2159: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -26213,190 +25587,190 @@ bufsize_t _scan_close_code_fence(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '`') { if (yych == '\n') - goto yy2184; + goto yy2163; if (yych <= '_') - goto yy2187; - goto yy2185; + goto yy2166; + goto yy2164; } else { if (yych == '~') - goto yy2186; + goto yy2165; if (yych <= 0x7F) - goto yy2187; + goto yy2166; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy2188; + goto yy2167; if (yych <= 0xE0) - goto yy2190; + goto yy2169; if (yych <= 0xEC) - goto yy2191; - goto yy2195; + goto yy2170; + goto yy2174; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy2191; - goto yy2192; + goto yy2170; + goto yy2171; } else { if (yych <= 0xF3) - goto yy2193; + goto yy2172; if (yych <= 0xF4) - goto yy2194; + goto yy2173; } } } - yy2184 : { return 0; } - yy2185: + yy2163 : { return 0; } + yy2164: yych = *(marker = ++p); if (yych == '`') - goto yy2203; - goto yy2184; - yy2186: + goto yy2182; + goto yy2163; + yy2165: yych = *(marker = ++p); if (yych == '~') - goto yy2196; - goto yy2184; - yy2187: + goto yy2175; + goto yy2163; + yy2166: yych = *++p; - goto yy2184; - yy2188: + goto yy2163; + yy2167: yych = *++p; if (yych <= 0x7F) - goto yy2189; + goto yy2168; if (yych <= 0xBF) - goto yy2187; - yy2189: + goto yy2166; + yy2168: p = marker; - goto yy2184; - yy2190: + goto yy2163; + yy2169: yych = *++p; if (yych <= 0x9F) - goto yy2189; + goto yy2168; if (yych <= 0xBF) - goto yy2188; - goto yy2189; - yy2191: + goto yy2167; + goto yy2168; + yy2170: yych = *++p; if (yych <= 0x7F) - goto yy2189; + goto yy2168; if (yych <= 0xBF) - goto yy2188; - goto yy2189; - yy2192: + goto yy2167; + goto yy2168; + yy2171: yych = *++p; if (yych <= 0x8F) - goto yy2189; + goto yy2168; if (yych <= 0xBF) - goto yy2191; - goto yy2189; - yy2193: + goto yy2170; + goto yy2168; + yy2172: yych = *++p; if (yych <= 0x7F) - goto yy2189; + goto yy2168; if (yych <= 0xBF) - goto yy2191; - goto yy2189; - yy2194: + goto yy2170; + goto yy2168; + yy2173: yych = *++p; if (yych <= 0x7F) - goto yy2189; + goto yy2168; if (yych <= 0x8F) - goto yy2191; - goto yy2189; - yy2195: + goto yy2170; + goto yy2168; + yy2174: yych = *++p; if (yych <= 0x7F) - goto yy2189; + goto yy2168; if (yych <= 0x9F) - goto yy2188; - goto yy2189; - yy2196: + goto yy2167; + goto yy2168; + yy2175: yych = *++p; if (yybm[0 + yych] & 32) { - goto yy2197; + goto yy2176; } - goto yy2189; - yy2197: - marker = p + 1; + goto yy2168; + yy2176: ++p; yych = *p; + marker = p; if (yybm[0 + yych] & 64) { - goto yy2199; + goto yy2178; } if (yych <= '\f') { if (yych <= 0x08) - goto yy2189; + goto yy2168; if (yych <= '\n') - goto yy2201; - goto yy2189; + goto yy2180; + goto yy2168; } else { if (yych <= '\r') - goto yy2201; + goto yy2180; if (yych == '~') - goto yy2197; - goto yy2189; + goto yy2176; + goto yy2168; } - yy2199: + yy2178: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy2199; + goto yy2178; } if (yych <= 0x08) - goto yy2189; + goto yy2168; if (yych <= '\n') - goto yy2201; + goto yy2180; if (yych != '\r') - goto yy2189; - yy2201: + goto yy2168; + yy2180: ++p; p = marker; { return (bufsize_t)(p - start); } - yy2203: + yy2182: yych = *++p; if (yybm[0 + yych] & 128) { - goto yy2204; + goto yy2183; } - goto yy2189; - yy2204: - marker = p + 1; + goto yy2168; + yy2183: ++p; yych = *p; + marker = p; if (yybm[0 + yych] & 128) { - goto yy2204; + goto yy2183; } if (yych <= '\f') { if (yych <= 0x08) - goto yy2189; + goto yy2168; if (yych <= '\t') - goto yy2206; + goto yy2185; if (yych <= '\n') - goto yy2208; - goto yy2189; + goto yy2187; + goto yy2168; } else { if (yych <= '\r') - goto yy2208; + goto yy2187; if (yych != ' ') - goto yy2189; + goto yy2168; } - yy2206: + yy2185: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) - goto yy2189; + goto yy2168; if (yych <= '\t') - goto yy2206; + goto yy2185; if (yych >= '\v') - goto yy2189; + goto yy2168; } else { if (yych <= '\r') - goto yy2208; + goto yy2187; if (yych == ' ') - goto yy2206; - goto yy2189; + goto yy2185; + goto yy2168; } - yy2208: + yy2187: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -26415,997 +25789,997 @@ bufsize_t _scan_entity(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= '%') { if (yych != '\n') - goto yy2214; + goto yy2193; } else { if (yych <= '&') - goto yy2213; + goto yy2192; if (yych <= 0x7F) - goto yy2214; + goto yy2193; if (yych >= 0xC2) - goto yy2215; + goto yy2194; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy2217; + goto yy2196; if (yych == 0xED) - goto yy2222; - goto yy2218; + goto yy2201; + goto yy2197; } else { if (yych <= 0xF0) - goto yy2219; + goto yy2198; if (yych <= 0xF3) - goto yy2220; + goto yy2199; if (yych <= 0xF4) - goto yy2221; + goto yy2200; } } - yy2212 : { return 0; } - yy2213: + yy2191 : { return 0; } + yy2192: yych = *(marker = ++p); if (yych <= '@') { if (yych == '#') - goto yy2223; - goto yy2212; + goto yy2202; + goto yy2191; } else { if (yych <= 'Z') - goto yy2224; + goto yy2203; if (yych <= '`') - goto yy2212; + goto yy2191; if (yych <= 'z') - goto yy2224; - goto yy2212; + goto yy2203; + goto yy2191; } - yy2214: + yy2193: yych = *++p; - goto yy2212; - yy2215: + goto yy2191; + yy2194: yych = *++p; if (yych <= 0x7F) - goto yy2216; + goto yy2195; if (yych <= 0xBF) - goto yy2214; - yy2216: + goto yy2193; + yy2195: p = marker; - goto yy2212; - yy2217: + goto yy2191; + yy2196: yych = *++p; if (yych <= 0x9F) - goto yy2216; + goto yy2195; if (yych <= 0xBF) - goto yy2215; - goto yy2216; - yy2218: + goto yy2194; + goto yy2195; + yy2197: yych = *++p; if (yych <= 0x7F) - goto yy2216; + goto yy2195; if (yych <= 0xBF) - goto yy2215; - goto yy2216; - yy2219: + goto yy2194; + goto yy2195; + yy2198: yych = *++p; if (yych <= 0x8F) - goto yy2216; + goto yy2195; if (yych <= 0xBF) - goto yy2218; - goto yy2216; - yy2220: + goto yy2197; + goto yy2195; + yy2199: yych = *++p; if (yych <= 0x7F) - goto yy2216; + goto yy2195; if (yych <= 0xBF) - goto yy2218; - goto yy2216; - yy2221: + goto yy2197; + goto yy2195; + yy2200: yych = *++p; if (yych <= 0x7F) - goto yy2216; + goto yy2195; if (yych <= 0x8F) - goto yy2218; - goto yy2216; - yy2222: + goto yy2197; + goto yy2195; + yy2201: yych = *++p; if (yych <= 0x7F) - goto yy2216; + goto yy2195; if (yych <= 0x9F) - goto yy2215; - goto yy2216; - yy2223: + goto yy2194; + goto yy2195; + yy2202: yych = *++p; if (yych <= 'W') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2259; - goto yy2216; + goto yy2238; + goto yy2195; } else { if (yych <= 'X') - goto yy2258; + goto yy2237; if (yych == 'x') - goto yy2258; - goto yy2216; + goto yy2237; + goto yy2195; } - yy2224: + yy2203: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych >= ':') - goto yy2216; + goto yy2195; } else { if (yych <= 'Z') - goto yy2225; + goto yy2204; if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } - yy2225: + yy2204: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2228; + goto yy2207; if (yych <= ':') - goto yy2216; + goto yy2195; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; - goto yy2228; + goto yy2195; + goto yy2207; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych <= 'z') - goto yy2228; - goto yy2216; + goto yy2207; + goto yy2195; } } - yy2226: + yy2205: ++p; { return (bufsize_t)(p - start); } - yy2228: + yy2207: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2229; + goto yy2208; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2229: + yy2208: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2230; + goto yy2209; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2230: + yy2209: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2231; + goto yy2210; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2231: + yy2210: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2232; + goto yy2211; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2232: + yy2211: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2233; + goto yy2212; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2233: + yy2212: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2234; + goto yy2213; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2234: + yy2213: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2235; + goto yy2214; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2235: + yy2214: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2236; + goto yy2215; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2236: + yy2215: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2237; - if (yych <= ':') goto yy2216; - goto yy2226; + if (yych <= ':') + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2237: + yy2216: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2238; + goto yy2217; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2238: + yy2217: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2239; + goto yy2218; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2239: + yy2218: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2240; + goto yy2219; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2240: + yy2219: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2241; + goto yy2220; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2241: + yy2220: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2242; + goto yy2221; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2242: + yy2221: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2243; + goto yy2222; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2243: + yy2222: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2244; + goto yy2223; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2244: + yy2223: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2245; + goto yy2224; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2245: + yy2224: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2246; + goto yy2225; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2246: + yy2225: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2247; + goto yy2226; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2247: + yy2226: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2248; + goto yy2227; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2248: + yy2227: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2249; + goto yy2228; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2249: + yy2228: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2250; + goto yy2229; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2250: + yy2229: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2251; + goto yy2230; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2251: + yy2230: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2252; + goto yy2231; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2252: + yy2231: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2253; + goto yy2232; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2253: + yy2232: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2254; + goto yy2233; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2254: + yy2233: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2255; + goto yy2234; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2255: + yy2234: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2256; + goto yy2235; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2256: + yy2235: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2257; + goto yy2236; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= '{') - goto yy2216; + goto yy2195; } } - yy2257: + yy2236: yych = *++p; if (yych == ';') - goto yy2226; - goto yy2216; - yy2258: + goto yy2205; + goto yy2195; + yy2237: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2266; - goto yy2216; + goto yy2245; + goto yy2195; } else { if (yych <= 'F') - goto yy2266; + goto yy2245; if (yych <= '`') - goto yy2216; + goto yy2195; if (yych <= 'f') - goto yy2266; - goto yy2216; + goto yy2245; + goto yy2195; } - yy2259: + yy2238: yych = *++p; if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2260; + goto yy2239; if (yych == ';') - goto yy2226; - goto yy2216; - yy2260: + goto yy2205; + goto yy2195; + yy2239: yych = *++p; if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2261; + goto yy2240; if (yych == ';') - goto yy2226; - goto yy2216; - yy2261: + goto yy2205; + goto yy2195; + yy2240: yych = *++p; if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2262; + goto yy2241; if (yych == ';') - goto yy2226; - goto yy2216; - yy2262: + goto yy2205; + goto yy2195; + yy2241: yych = *++p; if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2263; + goto yy2242; if (yych == ';') - goto yy2226; - goto yy2216; - yy2263: + goto yy2205; + goto yy2195; + yy2242: yych = *++p; if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2264; + goto yy2243; if (yych == ';') - goto yy2226; - goto yy2216; - yy2264: + goto yy2205; + goto yy2195; + yy2243: yych = *++p; if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2265; + goto yy2244; if (yych == ';') - goto yy2226; - goto yy2216; - yy2265: + goto yy2205; + goto yy2195; + yy2244: yych = *++p; if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2257; + goto yy2236; if (yych == ';') - goto yy2226; - goto yy2216; - yy2266: + goto yy2205; + goto yy2195; + yy2245: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2267; + goto yy2246; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= 'g') - goto yy2216; + goto yy2195; } } - yy2267: + yy2246: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2268; + goto yy2247; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= 'g') - goto yy2216; + goto yy2195; } } - yy2268: + yy2247: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2269; + goto yy2248; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= 'g') - goto yy2216; + goto yy2195; } } - yy2269: + yy2248: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2270; + goto yy2249; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= 'g') - goto yy2216; + goto yy2195; } } - yy2270: + yy2249: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2271; + goto yy2250; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= 'g') - goto yy2216; + goto yy2195; } } - yy2271: + yy2250: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2272; + goto yy2251; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2216; + goto yy2195; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych >= 'g') - goto yy2216; + goto yy2195; } } - yy2272: + yy2251: ++p; if ((yych = *p) <= ';') { if (yych <= '/') - goto yy2216; + goto yy2195; if (yych <= '9') - goto yy2257; + goto yy2236; if (yych <= ':') - goto yy2216; - goto yy2226; + goto yy2195; + goto yy2205; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2216; - goto yy2257; + goto yy2195; + goto yy2236; } else { if (yych <= '`') - goto yy2216; + goto yy2195; if (yych <= 'f') - goto yy2257; - goto yy2216; + goto yy2236; + goto yy2195; } } } @@ -27425,415 +26799,415 @@ bufsize_t _scan_dangerous_url(const unsigned char *p) { if (yych <= 'I') { if (yych <= 'C') { if (yych != '\n') - goto yy2280; + goto yy2259; } else { if (yych <= 'D') - goto yy2276; + goto yy2255; if (yych == 'F') - goto yy2279; - goto yy2280; + goto yy2258; + goto yy2259; } } else { if (yych <= 'V') { if (yych <= 'J') - goto yy2277; + goto yy2256; if (yych <= 'U') - goto yy2280; - goto yy2278; + goto yy2259; + goto yy2257; } else { if (yych == 'd') - goto yy2276; + goto yy2255; if (yych <= 'e') - goto yy2280; - goto yy2279; + goto yy2259; + goto yy2258; } } } else { if (yych <= 0xDF) { if (yych <= 'u') { if (yych == 'j') - goto yy2277; - goto yy2280; + goto yy2256; + goto yy2259; } else { if (yych <= 'v') - goto yy2278; + goto yy2257; if (yych <= 0x7F) - goto yy2280; + goto yy2259; if (yych >= 0xC2) - goto yy2281; + goto yy2260; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy2283; + goto yy2262; if (yych == 0xED) - goto yy2288; - goto yy2284; + goto yy2267; + goto yy2263; } else { if (yych <= 0xF0) - goto yy2285; + goto yy2264; if (yych <= 0xF3) - goto yy2286; + goto yy2265; if (yych <= 0xF4) - goto yy2287; + goto yy2266; } } } - yy2275 : { return 0; } - yy2276: + yy2254 : { return 0; } + yy2255: yyaccept = 0; yych = *(marker = ++p); if (yych == 'A') - goto yy2310; + goto yy2289; if (yych == 'a') - goto yy2310; - goto yy2275; - yy2277: + goto yy2289; + goto yy2254; + yy2256: yyaccept = 0; yych = *(marker = ++p); if (yych == 'A') - goto yy2301; + goto yy2280; if (yych == 'a') - goto yy2301; - goto yy2275; - yy2278: + goto yy2280; + goto yy2254; + yy2257: yyaccept = 0; yych = *(marker = ++p); if (yych == 'B') - goto yy2294; + goto yy2273; if (yych == 'b') - goto yy2294; - goto yy2275; - yy2279: + goto yy2273; + goto yy2254; + yy2258: yyaccept = 0; yych = *(marker = ++p); if (yych == 'I') - goto yy2289; + goto yy2268; if (yych == 'i') - goto yy2289; - goto yy2275; - yy2280: + goto yy2268; + goto yy2254; + yy2259: yych = *++p; - goto yy2275; - yy2281: + goto yy2254; + yy2260: yych = *++p; if (yych <= 0x7F) - goto yy2282; + goto yy2261; if (yych <= 0xBF) - goto yy2280; - yy2282: + goto yy2259; + yy2261: p = marker; if (yyaccept == 0) { - goto yy2275; + goto yy2254; } else { - goto yy2293; + goto yy2272; } - yy2283: + yy2262: yych = *++p; if (yych <= 0x9F) - goto yy2282; + goto yy2261; if (yych <= 0xBF) - goto yy2281; - goto yy2282; - yy2284: + goto yy2260; + goto yy2261; + yy2263: yych = *++p; if (yych <= 0x7F) - goto yy2282; + goto yy2261; if (yych <= 0xBF) - goto yy2281; - goto yy2282; - yy2285: + goto yy2260; + goto yy2261; + yy2264: yych = *++p; if (yych <= 0x8F) - goto yy2282; + goto yy2261; if (yych <= 0xBF) - goto yy2284; - goto yy2282; - yy2286: + goto yy2263; + goto yy2261; + yy2265: yych = *++p; if (yych <= 0x7F) - goto yy2282; + goto yy2261; if (yych <= 0xBF) - goto yy2284; - goto yy2282; - yy2287: + goto yy2263; + goto yy2261; + yy2266: yych = *++p; if (yych <= 0x7F) - goto yy2282; + goto yy2261; if (yych <= 0x8F) - goto yy2284; - goto yy2282; - yy2288: + goto yy2263; + goto yy2261; + yy2267: yych = *++p; if (yych <= 0x7F) - goto yy2282; + goto yy2261; if (yych <= 0x9F) - goto yy2281; - goto yy2282; - yy2289: + goto yy2260; + goto yy2261; + yy2268: yych = *++p; if (yych == 'L') - goto yy2290; + goto yy2269; if (yych != 'l') - goto yy2282; - yy2290: + goto yy2261; + yy2269: yych = *++p; if (yych == 'E') - goto yy2291; + goto yy2270; if (yych != 'e') - goto yy2282; - yy2291: + goto yy2261; + yy2270: yych = *++p; if (yych != ':') - goto yy2282; - yy2292: + goto yy2261; + yy2271: ++p; - yy2293 : { return (bufsize_t)(p - start); } - yy2294: + yy2272 : { return (bufsize_t)(p - start); } + yy2273: yych = *++p; if (yych == 'S') - goto yy2295; + goto yy2274; if (yych != 's') - goto yy2282; - yy2295: + goto yy2261; + yy2274: yych = *++p; if (yych == 'C') - goto yy2296; + goto yy2275; if (yych != 'c') - goto yy2282; - yy2296: + goto yy2261; + yy2275: yych = *++p; if (yych == 'R') - goto yy2297; + goto yy2276; if (yych != 'r') - goto yy2282; - yy2297: + goto yy2261; + yy2276: yych = *++p; if (yych == 'I') - goto yy2298; + goto yy2277; if (yych != 'i') - goto yy2282; - yy2298: + goto yy2261; + yy2277: yych = *++p; if (yych == 'P') - goto yy2299; + goto yy2278; if (yych != 'p') - goto yy2282; - yy2299: + goto yy2261; + yy2278: yych = *++p; if (yych == 'T') - goto yy2300; + goto yy2279; if (yych != 't') - goto yy2282; - yy2300: + goto yy2261; + yy2279: yych = *++p; if (yych == ':') - goto yy2292; - goto yy2282; - yy2301: + goto yy2271; + goto yy2261; + yy2280: yych = *++p; if (yych == 'V') - goto yy2302; + goto yy2281; if (yych != 'v') - goto yy2282; - yy2302: + goto yy2261; + yy2281: yych = *++p; if (yych == 'A') - goto yy2303; - if (yych != 'a') goto yy2282; - yy2303: + if (yych != 'a') + goto yy2261; + yy2282: yych = *++p; if (yych == 'S') - goto yy2304; + goto yy2283; if (yych != 's') - goto yy2282; - yy2304: + goto yy2261; + yy2283: yych = *++p; if (yych == 'C') - goto yy2305; + goto yy2284; if (yych != 'c') - goto yy2282; - yy2305: + goto yy2261; + yy2284: yych = *++p; if (yych == 'R') - goto yy2306; + goto yy2285; if (yych != 'r') - goto yy2282; - yy2306: + goto yy2261; + yy2285: yych = *++p; if (yych == 'I') - goto yy2307; + goto yy2286; if (yych != 'i') - goto yy2282; - yy2307: + goto yy2261; + yy2286: yych = *++p; if (yych == 'P') - goto yy2308; + goto yy2287; if (yych != 'p') - goto yy2282; - yy2308: + goto yy2261; + yy2287: yych = *++p; if (yych == 'T') - goto yy2309; + goto yy2288; if (yych != 't') - goto yy2282; - yy2309: + goto yy2261; + yy2288: yych = *++p; if (yych == ':') - goto yy2292; - goto yy2282; - yy2310: + goto yy2271; + goto yy2261; + yy2289: yych = *++p; if (yych == 'T') - goto yy2311; + goto yy2290; if (yych != 't') - goto yy2282; - yy2311: + goto yy2261; + yy2290: yych = *++p; if (yych == 'A') - goto yy2312; + goto yy2291; if (yych != 'a') - goto yy2282; - yy2312: + goto yy2261; + yy2291: yych = *++p; if (yych != ':') - goto yy2282; + goto yy2261; yyaccept = 1; yych = *(marker = ++p); if (yych == 'I') - goto yy2314; - if (yych != 'i') goto yy2293; - yy2314: + if (yych != 'i') + goto yy2272; + yy2293: yych = *++p; if (yych == 'M') - goto yy2315; + goto yy2294; if (yych != 'm') - goto yy2282; - yy2315: + goto yy2261; + yy2294: yych = *++p; if (yych == 'A') - goto yy2316; + goto yy2295; if (yych != 'a') - goto yy2282; - yy2316: + goto yy2261; + yy2295: yych = *++p; if (yych == 'G') - goto yy2317; + goto yy2296; if (yych != 'g') - goto yy2282; - yy2317: + goto yy2261; + yy2296: yych = *++p; if (yych == 'E') - goto yy2318; + goto yy2297; if (yych != 'e') - goto yy2282; - yy2318: + goto yy2261; + yy2297: yych = *++p; if (yych != '/') - goto yy2282; + goto yy2261; yych = *++p; if (yych <= 'W') { if (yych <= 'J') { if (yych == 'G') - goto yy2321; + goto yy2300; if (yych <= 'I') - goto yy2282; - goto yy2322; + goto yy2261; + goto yy2301; } else { if (yych == 'P') - goto yy2320; + goto yy2299; if (yych <= 'V') - goto yy2282; - goto yy2323; + goto yy2261; + goto yy2302; } } else { if (yych <= 'j') { if (yych == 'g') - goto yy2321; + goto yy2300; if (yych <= 'i') - goto yy2282; - goto yy2322; + goto yy2261; + goto yy2301; } else { if (yych <= 'p') { if (yych <= 'o') - goto yy2282; + goto yy2261; } else { if (yych == 'w') - goto yy2323; - goto yy2282; + goto yy2302; + goto yy2261; } } } - yy2320: + yy2299: yych = *++p; if (yych == 'N') - goto yy2331; + goto yy2310; if (yych == 'n') - goto yy2331; - goto yy2282; - yy2321: + goto yy2310; + goto yy2261; + yy2300: yych = *++p; if (yych == 'I') - goto yy2330; + goto yy2309; if (yych == 'i') - goto yy2330; - goto yy2282; - yy2322: + goto yy2309; + goto yy2261; + yy2301: yych = *++p; if (yych == 'P') - goto yy2328; + goto yy2307; if (yych == 'p') - goto yy2328; - goto yy2282; - yy2323: + goto yy2307; + goto yy2261; + yy2302: yych = *++p; if (yych == 'E') - goto yy2324; + goto yy2303; if (yych != 'e') - goto yy2282; - yy2324: + goto yy2261; + yy2303: yych = *++p; if (yych == 'B') - goto yy2325; + goto yy2304; if (yych != 'b') - goto yy2282; - yy2325: + goto yy2261; + yy2304: yych = *++p; if (yych == 'P') - goto yy2326; + goto yy2305; if (yych != 'p') - goto yy2282; - yy2326: + goto yy2261; + yy2305: ++p; { return 0; } - yy2328: + yy2307: yych = *++p; if (yych == 'E') - goto yy2329; + goto yy2308; if (yych != 'e') - goto yy2282; - yy2329: + goto yy2261; + yy2308: yych = *++p; if (yych == 'G') - goto yy2326; + goto yy2305; if (yych == 'g') - goto yy2326; - goto yy2282; - yy2330: + goto yy2305; + goto yy2261; + yy2309: yych = *++p; if (yych == 'F') - goto yy2326; + goto yy2305; if (yych == 'f') - goto yy2326; - goto yy2282; - yy2331: + goto yy2305; + goto yy2261; + yy2310: ++p; if ((yych = *p) == 'G') - goto yy2326; + goto yy2305; if (yych == 'g') - goto yy2326; - goto yy2282; + goto yy2305; + goto yy2261; } } diff --git a/scanners.h b/scanners.h index 4616f9f..5e3cbe7 100644 --- a/scanners.h +++ b/scanners.h @@ -21,9 +21,9 @@ bufsize_t _scan_html_block_end_5(const unsigned char *p); bufsize_t _scan_link_url(const unsigned char *p); bufsize_t _scan_link_title(const unsigned char *p); bufsize_t _scan_spacechars(const unsigned char *p); -bufsize_t _scan_atx_header_start(const unsigned char *p); -bufsize_t _scan_setext_header_line(const unsigned char *p); -bufsize_t _scan_hrule(const unsigned char *p); +bufsize_t _scan_atx_heading_start(const unsigned char *p); +bufsize_t _scan_setext_heading_line(const unsigned char *p); +bufsize_t _scan_thematic_break(const unsigned char *p); bufsize_t _scan_open_code_fence(const unsigned char *p); bufsize_t _scan_close_code_fence(const unsigned char *p); bufsize_t _scan_entity(const unsigned char *p); @@ -43,9 +43,10 @@ bufsize_t _scan_dangerous_url(const unsigned char *p); #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_atx_heading_start(c, n) _scan_at(&_scan_atx_heading_start, c, n) +#define scan_setext_heading_line(c, n) \ + _scan_at(&_scan_setext_heading_line, c, n) +#define scan_thematic_break(c, n) _scan_at(&_scan_thematic_break, 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) diff --git a/scanners.re b/scanners.re index 0037bc4..8176590 100644 --- a/scanners.re +++ b/scanners.re @@ -6,11 +6,16 @@ bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, { bufsize_t 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; + if (ptr == NULL || offset > c->len) { + return 0; + } else { + unsigned char lim = ptr[c->len]; + + ptr[c->len] = '\0'; + res = scanner(ptr + offset); + ptr[c->len] = lim; + } return res; } @@ -210,7 +215,7 @@ bufsize_t _scan_link_url(const unsigned char *p) const unsigned char *start = p; /*!re2c [ \r\n]* [<] ([^<>\r\n\\\x00] | escaped_char | [\\])* [>] { return (bufsize_t)(p - start); } - [ \r\n]* (reg_char+ | escaped_char | in_parens_nosp | [\\][^()])* { return (bufsize_t)(p - start); } + [ \r\n]* (reg_char+ | escaped_char | [\\] | in_parens_nosp)* { return (bufsize_t)(p - start); } .? { return 0; } */ } @@ -241,8 +246,8 @@ bufsize_t _scan_spacechars(const unsigned char *p) */ } -// Match ATX header start. -bufsize_t _scan_atx_header_start(const unsigned char *p) +// Match ATX heading start. +bufsize_t _scan_atx_heading_start(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -252,9 +257,9 @@ bufsize_t _scan_atx_header_start(const unsigned char *p) */ } -// Match setext header line. Return 1 for level-1 header, +// Match setext heading line. Return 1 for level-1 heading, // 2 for level-2, 0 for no match. -bufsize_t _scan_setext_header_line(const unsigned char *p) +bufsize_t _scan_setext_heading_line(const unsigned char *p) { const unsigned char *marker = NULL; /*!re2c @@ -264,10 +269,10 @@ bufsize_t _scan_setext_header_line(const unsigned char *p) */ } -// Scan a horizontal rule line: "...three or more hyphens, asterisks, +// Scan a thematic break 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." -bufsize_t _scan_hrule(const unsigned char *p) +bufsize_t _scan_thematic_break(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; diff --git a/utf8.c b/utf8.c index 319539d..c29bbf7 100644 --- a/utf8.c +++ b/utf8.c @@ -107,7 +107,8 @@ static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) { return length; } -void cmark_utf8proc_check(cmark_strbuf *ob, const uint8_t *line, bufsize_t size) { +void cmark_utf8proc_check(cmark_strbuf *ob, const uint8_t *line, + bufsize_t size) { bufsize_t i = 0; while (i < size) { @@ -146,7 +147,8 @@ void cmark_utf8proc_check(cmark_strbuf *ob, const uint8_t *line, bufsize_t size) } } -int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst) { +int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, + int32_t *dst) { int length; int32_t uc = -1; @@ -222,7 +224,8 @@ void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) { cmark_strbuf_put(buf, dst, len); } -void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, bufsize_t len) { +void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, + bufsize_t len) { int32_t c; #define bufpush(x) cmark_utf8proc_encode_char(x, dest) diff --git a/utf8.h b/utf8.h index 43b3757..8e45714 100644 --- a/utf8.h +++ b/utf8.h @@ -8,10 +8,12 @@ extern "C" { #endif -void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, bufsize_t len); +void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, + bufsize_t len); void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf); int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst); -void cmark_utf8proc_check(cmark_strbuf *dest, const uint8_t *line, bufsize_t size); +void cmark_utf8proc_check(cmark_strbuf *dest, const uint8_t *line, + bufsize_t size); int cmark_utf8proc_is_space(int32_t uc); int cmark_utf8proc_is_punctuation(int32_t uc); diff --git a/xml.c b/xml.c index 0b225fa..a06cdd3 100644 --- a/xml.c +++ b/xml.c @@ -50,10 +50,13 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, literal = false; switch (node->type) { + case CMARK_NODE_DOCUMENT: + cmark_strbuf_puts(xml, " xmlns=\"http://commonmark.org/xml/1.0\""); + break; case CMARK_NODE_TEXT: case CMARK_NODE_CODE: - case CMARK_NODE_HTML: - case CMARK_NODE_INLINE_HTML: + case CMARK_NODE_HTML_BLOCK: + case CMARK_NODE_HTML_INLINE: cmark_strbuf_puts(xml, ">"); escape_xml(xml, node->as.literal.data, node->as.literal.len); cmark_strbuf_puts(xml, "as.header.level); + case CMARK_NODE_HEADING: + sprintf(buffer, " level=\"%d\"", node->as.heading.level); cmark_strbuf_puts(xml, buffer); break; case CMARK_NODE_CODE_BLOCK: @@ -99,6 +102,17 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, cmark_strbuf_puts(xml, cmark_node_get_type_string(node)); literal = true; break; + case CMARK_NODE_CUSTOM_BLOCK: + case CMARK_NODE_CUSTOM_INLINE: + cmark_strbuf_puts(xml, " on_enter=\""); + escape_xml(xml, node->as.custom.on_enter.data, + node->as.custom.on_enter.len); + cmark_strbuf_putc(xml, '"'); + cmark_strbuf_puts(xml, " on_exit=\""); + escape_xml(xml, node->as.custom.on_exit.data, + node->as.custom.on_exit.len); + cmark_strbuf_putc(xml, '"'); + break; case CMARK_NODE_LINK: case CMARK_NODE_IMAGE: cmark_strbuf_puts(xml, " destination=\""); @@ -140,7 +154,7 @@ char *cmark_render_xml(cmark_node *root, int options) { cmark_strbuf_puts(state.xml, "\n"); cmark_strbuf_puts(state.xml, - "\n"); + "\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); From 7d62b5633045bf07e6b5b985dedda1e2197aefcc Mon Sep 17 00:00:00 2001 From: jcadam Date: Mon, 4 Jan 2016 19:38:55 -0500 Subject: [PATCH 19/26] cleanup --- config.h.in | 25 ------------------------- 1 file changed, 25 deletions(-) delete mode 100644 config.h.in diff --git a/config.h.in b/config.h.in deleted file mode 100644 index 2792313..0000000 --- a/config.h.in +++ /dev/null @@ -1,25 +0,0 @@ -#cmakedefine HAVE_STDBOOL_H - -#ifdef HAVE_STDBOOL_H - #include -#elif !defined(__cplusplus) - typedef char bool; -#endif - -#cmakedefine HAVE___BUILTIN_EXPECT - -#cmakedefine HAVE___ATTRIBUTE__ - -#ifdef HAVE___ATTRIBUTE__ - #define CMARK_ATTRIBUTE(list) __attribute__ (list) -#else - #define CMARK_ATTRIBUTE(list) -#endif - -#ifndef CMARK_INLINE - #if defined(_MSC_VER) && !defined(__cplusplus) - #define CMARK_INLINE __inline - #else - #define CMARK_INLINE inline - #endif -#endif From bbc056cd7e3ed9d9a973e392a7511d6234cb370d Mon Sep 17 00:00:00 2001 From: jcadam Date: Wed, 13 Jan 2016 20:35:44 -0500 Subject: [PATCH 20/26] updated to cmark 0.24.0 --- blocks.c | 6 +- cmark.h | 20 +- cmark_version.h | 4 +- commonmark.c | 22 +- commonmark_test.go | 20 +- html.c | 2 +- node.c | 16 +- node.go | 7 + scanners.c | 26864 +++++++++++++++++-------------------------- scanners.re | 6 +- 10 files changed, 10529 insertions(+), 16438 deletions(-) diff --git a/blocks.c b/blocks.c index 773179e..9f41e1f 100644 --- a/blocks.c +++ b/blocks.c @@ -800,11 +800,7 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, } else if (!indented && container->type == CMARK_NODE_PARAGRAPH && (lev = - scan_setext_heading_line(&input, parser->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)) { + scan_setext_heading_line(&input, parser->first_nonspace))) { container->type = CMARK_NODE_HEADING; container->as.heading.level = lev; diff --git a/cmark.h b/cmark.h index f9172b0..d0f1953 100644 --- a/cmark.h +++ b/cmark.h @@ -86,13 +86,6 @@ 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 */ @@ -178,6 +171,13 @@ CMARK_EXPORT cmark_node *cmark_node_last_child(cmark_node *node); * leaf nodes. */ +typedef enum { + CMARK_EVENT_NONE, + CMARK_EVENT_DONE, + CMARK_EVENT_ENTER, + CMARK_EVENT_EXIT +} cmark_event_type; + /** 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. */ @@ -387,6 +387,12 @@ CMARK_EXPORT int cmark_node_insert_before(cmark_node *node, */ CMARK_EXPORT int cmark_node_insert_after(cmark_node *node, cmark_node *sibling); +/** Replaces 'oldnode' with 'newnode' and unlinks 'oldnode' (but does + * not free its memory). + * Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode); + /** Adds 'child' to the beginning of the children of 'node'. * Returns 1 on success, 0 on failure. */ diff --git a/cmark_version.h b/cmark_version.h index 434eb00..b7af51d 100644 --- a/cmark_version.h +++ b/cmark_version.h @@ -1,7 +1,7 @@ #ifndef CMARK_VERSION_H #define CMARK_VERSION_H -#define CMARK_VERSION ((0 << 16) | (23 << 8) | 0) -#define CMARK_VERSION_STRING "0.23.0" +#define CMARK_VERSION ((0 << 16) | (24 << 8) | 0) +#define CMARK_VERSION_STRING "0.24.0" #endif diff --git a/commonmark.c b/commonmark.c index 69bd2b1..1a61334 100644 --- a/commonmark.c +++ b/commonmark.c @@ -135,12 +135,17 @@ static bool is_autolink(cmark_node *node) { // if node is a block node, returns node. // otherwise returns first block-level node that is an ancestor of node. +// if there is no block-level ancestor, returns NULL. static cmark_node *get_containing_block(cmark_node *node) { - while (node && (node->type < CMARK_NODE_FIRST_BLOCK || - node->type > CMARK_NODE_LAST_BLOCK)) { - node = node->parent; + while (node) { + if (node->type >= CMARK_NODE_FIRST_BLOCK && + node->type <= CMARK_NODE_LAST_BLOCK) { + return node; + } else { + node = node->parent; + } } - return node; + return NULL; } static int S_render_node(cmark_renderer *renderer, cmark_node *node, @@ -163,10 +168,11 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && entering)) { tmp = get_containing_block(node); renderer->in_tight_list_item = - (tmp->type == CMARK_NODE_ITEM && - cmark_node_get_list_tight(tmp->parent)) || - (tmp && tmp->parent && tmp->parent->type == CMARK_NODE_ITEM && - cmark_node_get_list_tight(tmp->parent->parent)); + tmp && // tmp might be NULL if there is no containing block + ((tmp->type == CMARK_NODE_ITEM && + cmark_node_get_list_tight(tmp->parent)) || + (tmp && tmp->parent && tmp->parent->type == CMARK_NODE_ITEM && + cmark_node_get_list_tight(tmp->parent->parent))); } switch (node->type) { diff --git a/commonmark_test.go b/commonmark_test.go index 332e21d..0d649e1 100644 --- a/commonmark_test.go +++ b/commonmark_test.go @@ -113,6 +113,18 @@ func TestCMarkNodeOps(t *testing.T) { t.Error("Couldn't prepend header to root") } root.AppendChild(header2) + //Replace a Node + header3 := commonmark.NewCMarkNode(commonmark.CMARK_NODE_HEADING) + header3str := commonmark.NewCMarkNode(commonmark.CMARK_NODE_TEXT) + header3.AppendChild(header3str) + header3.SetHeaderLevel(2) + if header3str.SetLiteral("Replacement header!") == false { + t.Error("SetLiteral returned false for valid input") + } + if header3.Replace(header2) == false { + t.Error("Couldn't Replace Node!") + } + //Custom nodes custom := commonmark.NewCMarkNode(commonmark.CMARK_NODE_CUSTOM_BLOCK) custom.SetOnEnter("ENTER") custom.SetOnExit("EXIT") @@ -125,10 +137,14 @@ func TestCMarkNodeOps(t *testing.T) { t.Logf("\nXML: %v", root.RenderXML(commonmark.CMARK_OPT_DEFAULT)) htmlStr := root.RenderHtml(commonmark.CMARK_OPT_DEFAULT) - if htmlStr != "

I'm the main header!

\n

Another header!

\n" { + if htmlStr != "

I'm the main header!

\n

Replacement header!

\n" { t.Error("htmlStr is wrong!") } t.Logf("Html Text: %v", htmlStr) + //Replace again + if header2.Replace(header3) == false { + t.Error("replaced node was freed prematurely.") + } //Rearrange... header1.InsertBefore(header2) t.Logf("\nXML: %v", root.RenderXML(commonmark.CMARK_OPT_DEFAULT)) @@ -204,7 +220,7 @@ func TestCMarkCodeBlocks(t *testing.T) { t.Logf("\nXML: %v", root.RenderXML(commonmark.CMARK_OPT_DEFAULT)) htmlString := root.RenderHtml(commonmark.CMARK_OPT_DEFAULT) t.Logf("\nHtml String: %v\n", htmlString) - if htmlString != "
int main(){\n return 0;\n }
\n" { + if htmlString != "
int main(){\n return 0;\n }
\n" { t.Error("htmlString isn't right!") } root.Free() diff --git a/html.c b/html.c index 7493596..54f27ba 100644 --- a/html.c +++ b/html.c @@ -144,7 +144,7 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_CODE_BLOCK: cr(html); - if (!node->as.code.fenced || node->as.code.info.len == 0) { + if (node->as.code.info.len == 0) { cmark_strbuf_puts(html, ""); diff --git a/node.c b/node.c index d4c39cc..26a8e25 100644 --- a/node.c +++ b/node.c @@ -46,12 +46,14 @@ static bool S_can_contain(cmark_node *node, cmark_node *child) { case CMARK_NODE_DOCUMENT: case CMARK_NODE_BLOCK_QUOTE: case CMARK_NODE_ITEM: - case CMARK_NODE_CUSTOM_BLOCK: return S_is_block(child) && child->type != CMARK_NODE_ITEM; case CMARK_NODE_LIST: return child->type == CMARK_NODE_ITEM; + case CMARK_NODE_CUSTOM_BLOCK: + return true; + case CMARK_NODE_PARAGRAPH: case CMARK_NODE_HEADING: case CMARK_NODE_EMPH: @@ -169,7 +171,7 @@ const char *cmark_node_get_type_string(cmark_node *node) { case CMARK_NODE_HTML_BLOCK: return "html_block"; case CMARK_NODE_CUSTOM_BLOCK: - return "raw_block"; + return "custom_block"; case CMARK_NODE_PARAGRAPH: return "paragraph"; case CMARK_NODE_HEADING: @@ -187,7 +189,7 @@ const char *cmark_node_get_type_string(cmark_node *node) { case CMARK_NODE_HTML_INLINE: return "html_inline"; case CMARK_NODE_CUSTOM_INLINE: - return "raw_inline"; + return "custom_inline"; case CMARK_NODE_EMPH: return "emph"; case CMARK_NODE_STRONG: @@ -728,6 +730,14 @@ int cmark_node_insert_after(cmark_node *node, cmark_node *sibling) { return 1; } +int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode) { + if (!cmark_node_insert_before(oldnode, newnode)) { + return 0; + } + cmark_node_unlink(oldnode); + return 1; +} + int cmark_node_prepend_child(cmark_node *node, cmark_node *child) { if (!S_can_contain(node, child)) { return 0; diff --git a/node.go b/node.go index 95247b6..2df07cc 100644 --- a/node.go +++ b/node.go @@ -389,6 +389,13 @@ func (node *CMarkNode) InsertAfter(sibling *CMarkNode) bool { return success(C.cmark_node_insert_after(node.node, sibling.node)) } +// Replaces 'oldNode' with 'newNode' and unlinks 'oldnode' (but does +// not free its memory). +// Returns true on success, false on failure. +func (newNode *CMarkNode) Replace(oldNode *CMarkNode) bool { + return success(C.cmark_node_replace(oldNode.node, newNode.node)) +} + //Prepend a child node func (node *CMarkNode) PrependChild(child *CMarkNode) bool { return success(C.cmark_node_prepend_child(node.node, child.node)) diff --git a/scanners.c b/scanners.c index ae4125f..28821ba 100644 --- a/scanners.c +++ b/scanners.c @@ -1,4 +1,4 @@ -/* Generated by re2c 0.15.3 */ +/* Generated by re2c 0.14.3 */ #include #include "chunk.h" #include "scanners.h" @@ -28,8414 +28,1839 @@ bufsize_t _scan_scheme(const unsigned char *p) { { unsigned char yych; + yych = *(marker = p); - if (yych <= 'c') { - if (yych <= 'M') { - if (yych <= 'E') { - if (yych <= 'A') { - if (yych == '\n') - goto yy2; - if (yych <= '@') - goto yy29; - goto yy6; - } else { - if (yych <= 'B') - goto yy24; - if (yych <= 'C') - goto yy3; - if (yych <= 'D') - goto yy4; - goto yy25; - } - } else { - if (yych <= 'I') { - if (yych <= 'F') - goto yy7; - if (yych <= 'G') - goto yy8; - if (yych <= 'H') - goto yy9; - goto yy10; - } else { - if (yych <= 'J') - goto yy5; - if (yych <= 'K') - goto yy26; - if (yych <= 'L') - goto yy11; - goto yy12; - } - } + if (yych <= 0x7F) { + if (yych <= ' ') { + if (yych == '\n') + goto yy2; + if (yych <= 0x1F) + goto yy4; + goto yy3; } else { - if (yych <= 'U') { - if (yych <= 'Q') { - if (yych <= 'N') - goto yy13; - if (yych <= 'O') - goto yy14; - if (yych <= 'P') - goto yy15; - goto yy27; - } else { - if (yych <= 'R') - goto yy16; - if (yych <= 'S') - goto yy17; - if (yych <= 'T') - goto yy18; - goto yy19; - } + if (yych <= 'Z') { + if (yych <= '@') + goto yy4; + goto yy3; } else { - if (yych <= 'Y') { - if (yych <= 'V') - goto yy20; - if (yych <= 'W') - goto yy21; - if (yych <= 'X') - goto yy22; - goto yy28; - } else { - if (yych <= '`') { - if (yych <= 'Z') - goto yy23; - goto yy29; - } else { - if (yych <= 'a') - goto yy6; - if (yych <= 'b') - goto yy24; - goto yy3; - } - } + if (yych <= '`') + goto yy4; + if (yych <= 'z') + goto yy3; + goto yy4; } } } else { - if (yych <= 't') { - if (yych <= 'k') { - if (yych <= 'g') { - if (yych <= 'd') - goto yy4; - if (yych <= 'e') - goto yy25; - if (yych <= 'f') - goto yy7; - goto yy8; - } else { - if (yych <= 'h') - goto yy9; - if (yych <= 'i') - goto yy10; - if (yych <= 'j') - goto yy5; - goto yy26; - } + if (yych <= 0xED) { + if (yych <= 0xDF) { + if (yych >= 0xC2) + goto yy5; } else { - if (yych <= 'o') { - if (yych <= 'l') - goto yy11; - if (yych <= 'm') - goto yy12; - if (yych <= 'n') - goto yy13; - goto yy14; - } else { - if (yych <= 'q') { - if (yych <= 'p') - goto yy15; - goto yy27; - } else { - if (yych <= 'r') - goto yy16; - if (yych <= 's') - goto yy17; - goto yy18; - } - } + if (yych <= 0xE0) + goto yy7; + if (yych <= 0xEC) + goto yy8; + goto yy12; } } else { - if (yych <= 0xC1) { - if (yych <= 'x') { - if (yych <= 'u') - goto yy19; - if (yych <= 'v') - goto yy20; - if (yych <= 'w') - goto yy21; - goto yy22; - } else { - if (yych <= 'y') - goto yy28; - if (yych <= 'z') - goto yy23; - if (yych <= 0x7F) - goto yy29; - } + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy8; + goto yy9; } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy30; - if (yych <= 0xE0) - goto yy32; - if (yych <= 0xEC) - goto yy33; - goto yy37; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy33; - goto yy34; - } else { - if (yych <= 0xF3) - goto yy35; - if (yych <= 0xF4) - goto yy36; - } - } + if (yych <= 0xF3) + goto yy10; + if (yych <= 0xF4) + goto yy11; } } } yy2 : { return 0; } yy3: yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy447; - case 'H': - case 'h': - goto yy446; - case 'I': - case 'i': - goto yy449; - case 'O': - case 'o': - goto yy445; - case 'R': - case 'r': - goto yy448; - case 'V': - case 'v': - goto yy444; - default: - goto yy2; - } - yy4: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy420; - case 'I': - case 'i': - goto yy419; - case 'L': - case 'l': - goto yy417; - case 'N': - case 'n': - goto yy418; - case 'O': - case 'o': - goto yy421; - case 'T': - case 't': - goto yy416; - case 'V': - case 'v': - goto yy415; - default: - goto yy2; - } - yy5: - yych = *(marker = ++p); - if (yych <= 'M') { - if (yych == 'A') - goto yy407; - if (yych <= 'L') + if (yych <= '.') { + if (yych == '+') + goto yy13; + if (yych <= ',') goto yy2; - goto yy406; + goto yy13; } else { - if (yych <= 'a') { - if (yych <= '`') + if (yych <= 'Z') { + if (yych <= '@') goto yy2; - goto yy407; + goto yy13; } else { - if (yych == 'm') - goto yy406; + if (yych <= '`') + goto yy2; + if (yych <= 'z') + goto yy13; goto yy2; } } + yy4: + yych = *++p; + goto yy2; + yy5: + yych = *++p; + if (yych <= 0x7F) + goto yy6; + if (yych <= 0xBF) + goto yy4; yy6: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy388; - case 'B': - case 'b': - goto yy387; - case 'C': - case 'c': - goto yy386; - case 'D': - case 'd': - goto yy385; - case 'F': - case 'f': - goto yy384; - case 'I': - case 'i': - goto yy383; - case 'P': - case 'p': - goto yy382; - case 'T': - case 't': - goto yy381; - case 'W': - case 'w': - goto yy41; - default: - goto yy2; - } + p = marker; + goto yy2; yy7: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'E') { - if (yych == 'A') - goto yy368; - if (yych <= 'D') - goto yy2; - goto yy367; + yych = *++p; + if (yych <= 0x9F) + goto yy6; + if (yych <= 0xBF) + goto yy5; + goto yy6; + yy8: + yych = *++p; + if (yych <= 0x7F) + goto yy6; + if (yych <= 0xBF) + goto yy5; + goto yy6; + yy9: + yych = *++p; + if (yych <= 0x8F) + goto yy6; + if (yych <= 0xBF) + goto yy8; + goto yy6; + yy10: + yych = *++p; + if (yych <= 0x7F) + goto yy6; + if (yych <= 0xBF) + goto yy8; + goto yy6; + yy11: + yych = *++p; + if (yych <= 0x7F) + goto yy6; + if (yych <= 0x8F) + goto yy8; + goto yy6; + yy12: + yych = *++p; + if (yych <= 0x7F) + goto yy6; + if (yych <= 0x9F) + goto yy5; + goto yy6; + yy13: + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + goto yy16; } else { - if (yych == 'I') - goto yy366; - if (yych <= 'S') - goto yy2; - goto yy369; + if (yych <= ',') + goto yy6; + if (yych <= '.') + goto yy16; + goto yy6; } } else { - if (yych <= 'e') { - if (yych == 'a') - goto yy368; - if (yych <= 'd') - goto yy2; - goto yy367; + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + goto yy16; } else { - if (yych <= 'i') { - if (yych <= 'h') - goto yy2; - goto yy366; - } else { - if (yych == 't') - goto yy369; - goto yy2; - } + if (yych <= '`') + goto yy6; + if (yych <= 'z') + goto yy16; + goto yy6; } } - yy8: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': - goto yy351; - case 'G': - case 'g': - goto yy41; - case 'I': - case 'i': - goto yy349; - case 'O': - case 'o': - goto yy350; - case 'T': - case 't': - goto yy348; - default: - goto yy2; - } - yy9: - yych = *(marker = ++p); - if (yych <= 'S') { - if (yych <= '3') { - if (yych <= '2') - goto yy2; - goto yy344; + yy14: + ++p; + { return (bufsize_t)(p - start); } + yy16: + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; } else { - if (yych == 'C') - goto yy342; - goto yy2; + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; } } else { - if (yych <= 'c') { - if (yych <= 'T') - goto yy343; - if (yych <= 'b') - goto yy2; - goto yy342; + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; } else { - if (yych == 't') - goto yy343; - goto yy2; + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; } } - yy10: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy324; - case 'C': - case 'c': - goto yy321; - case 'M': - case 'm': - goto yy323; - case 'N': - case 'n': - goto yy322; - case 'P': - case 'p': - goto yy320; - case 'R': - case 'r': - goto yy319; - case 'T': - case 't': - goto yy318; - default: - goto yy2; - } - yy11: - yych = *(marker = ++p); - if (yych <= 'D') { - if (yych == 'A') - goto yy312; - if (yych <= 'C') - goto yy2; - goto yy311; + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } } else { - if (yych <= 'a') { - if (yych <= '`') - goto yy2; - goto yy312; + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; } else { - if (yych == 'd') - goto yy311; - goto yy2; + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; } } - yy12: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy278; - case 'E': - case 'e': - goto yy277; - case 'I': - case 'i': - goto yy280; - case 'M': - case 'm': - goto yy276; - case 'S': - case 's': - goto yy275; - case 'T': - case 't': - goto yy279; - case 'U': - case 'u': - goto yy274; - case 'V': - case 'v': - goto yy273; - default: - goto yy2; - } - yy13: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': - goto yy268; - case 'F': - case 'f': - goto yy267; - case 'I': - case 'i': - goto yy266; - case 'N': - case 'n': - goto yy265; - case 'O': - case 'o': - goto yy264; - default: - goto yy2; - } - yy14: - yych = *(marker = ++p); - if (yych <= 'P') { - if (yych == 'I') - goto yy250; - if (yych <= 'O') - goto yy2; - goto yy251; + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } } else { - if (yych <= 'i') { - if (yych <= 'h') - goto yy2; - goto yy250; + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; } else { - if (yych == 'p') - goto yy251; - goto yy2; + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; } } - yy15: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy232; - case 'L': - case 'l': - goto yy231; - case 'O': - case 'o': - goto yy233; - case 'R': - case 'r': - goto yy230; - case 'S': - case 's': - goto yy229; - default: - goto yy2; - } - yy16: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'L') { - if (yych == 'E') - goto yy219; - goto yy2; + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; } else { - if (yych <= 'M') - goto yy218; - if (yych <= 'R') - goto yy2; - if (yych <= 'S') - goto yy217; - goto yy216; + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; } } else { - if (yych <= 'm') { - if (yych == 'e') - goto yy219; - if (yych <= 'l') - goto yy2; - goto yy218; + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; } else { - if (yych <= 'r') - goto yy2; - if (yych <= 's') - goto yy217; - if (yych <= 't') - goto yy216; - goto yy2; + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; } } - yy17: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': - goto yy172; - case 'F': - case 'f': - goto yy171; - case 'G': - case 'g': - goto yy170; - case 'H': - case 'h': - goto yy175; - case 'I': - case 'i': - goto yy174; - case 'K': - case 'k': - goto yy169; - case 'M': - case 'm': - goto yy168; - case 'N': - case 'n': - goto yy173; - case 'O': - case 'o': - goto yy167; - case 'P': - case 'p': - goto yy166; - case 'S': - case 's': - goto yy165; - case 'T': - case 't': - goto yy164; - case 'V': - case 'v': - goto yy163; - default: - goto yy2; - } - yy18: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy139; - case 'E': - case 'e': - goto yy135; - case 'F': - case 'f': - goto yy138; - case 'H': - case 'h': - goto yy134; - case 'I': - case 'i': - goto yy136; - case 'N': - case 'n': - goto yy137; - case 'V': - case 'v': - goto yy41; - default: - goto yy2; - } - yy19: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'N') { - if (yych == 'D') - goto yy126; - if (yych <= 'M') - goto yy2; - goto yy125; + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; } else { - if (yych == 'R') - goto yy127; - if (yych <= 'S') - goto yy2; - goto yy124; + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; } } else { - if (yych <= 'n') { - if (yych == 'd') - goto yy126; - if (yych <= 'm') - goto yy2; - goto yy125; + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; } else { - if (yych <= 'r') { - if (yych <= 'q') - goto yy2; - goto yy127; - } else { - if (yych == 't') - goto yy124; - goto yy2; - } + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; } } - yy20: - yych = *(marker = ++p); - if (yych <= 'I') { - if (yych == 'E') - goto yy108; - if (yych <= 'H') - goto yy2; - goto yy107; + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } } else { - if (yych <= 'e') { - if (yych <= 'd') - goto yy2; - goto yy108; + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; } else { - if (yych == 'i') - goto yy107; - goto yy2; + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; } } - yy21: - yych = *(marker = ++p); - if (yych <= 'Y') { - if (yych <= 'R') { - if (yych == 'E') - goto yy97; - goto yy2; + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; } else { - if (yych <= 'S') - goto yy98; - if (yych <= 'T') - goto yy96; - if (yych <= 'X') - goto yy2; - goto yy95; + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; } } else { - if (yych <= 's') { - if (yych == 'e') - goto yy97; - if (yych <= 'r') - goto yy2; - goto yy98; + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; } else { - if (yych <= 't') - goto yy96; - if (yych == 'y') - goto yy95; - goto yy2; + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; } } - yy22: - yych = *(marker = ++p); - if (yych <= 'R') { - if (yych <= 'F') { - if (yych == 'C') - goto yy74; - if (yych <= 'E') - goto yy2; - goto yy72; + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; } else { - if (yych == 'M') - goto yy73; - if (yych <= 'Q') - goto yy2; - goto yy71; + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; } } else { - if (yych <= 'f') { - if (yych == 'c') - goto yy74; - if (yych <= 'e') - goto yy2; - goto yy72; + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; } else { - if (yych <= 'm') { - if (yych <= 'l') - goto yy2; - goto yy73; - } else { - if (yych == 'r') - goto yy71; - goto yy2; - } + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; } } - yy23: - yych = *(marker = ++p); - if (yych == '3') - goto yy66; - goto yy2; - yy24: - yych = *(marker = ++p); - if (yych <= 'O') { - if (yych <= 'H') { - if (yych == 'E') - goto yy56; - goto yy2; - } else { - if (yych <= 'I') - goto yy55; - if (yych <= 'N') - goto yy2; - goto yy54; + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; } } else { - if (yych <= 'h') { - if (yych == 'e') - goto yy56; - goto yy2; + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; } else { - if (yych <= 'i') - goto yy55; - if (yych == 'o') - goto yy54; - goto yy2; + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; } } - yy25: - yych = *(marker = ++p); - if (yych == 'D') - goto yy52; - if (yych == 'd') - goto yy52; - goto yy2; - yy26: - yych = *(marker = ++p); - if (yych == 'E') - goto yy47; - if (yych == 'e') - goto yy47; - goto yy2; - yy27: - yych = *(marker = ++p); - if (yych == 'U') - goto yy44; - if (yych == 'u') - goto yy44; - goto yy2; - yy28: - yych = *(marker = ++p); - if (yych == 'M') - goto yy38; - if (yych == 'm') - goto yy38; - goto yy2; - yy29: - yych = *++p; - goto yy2; - yy30: - yych = *++p; - if (yych <= 0x7F) - goto yy31; - if (yych <= 0xBF) - goto yy29; - yy31: - p = marker; - goto yy2; - yy32: yych = *++p; - if (yych <= 0x9F) - goto yy31; - if (yych <= 0xBF) - goto yy30; - goto yy31; - yy33: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych <= 0x7F) - goto yy31; - if (yych <= 0xBF) - goto yy30; - goto yy31; - yy34: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych <= 0x8F) - goto yy31; - if (yych <= 0xBF) - goto yy33; - goto yy31; - yy35: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych <= 0x7F) - goto yy31; - if (yych <= 0xBF) - goto yy33; - goto yy31; - yy36: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych <= 0x7F) - goto yy31; - if (yych <= 0x8F) - goto yy33; - goto yy31; - yy37: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych <= 0x7F) - goto yy31; - if (yych <= 0x9F) - goto yy30; - goto yy31; - yy38: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych == 'S') - goto yy39; - if (yych != 's') - goto yy31; - yy39: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych == 'G') - goto yy40; - if (yych != 'g') - goto yy31; - yy40: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych == 'R') - goto yy41; - if (yych != 'r') - goto yy31; - yy41: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych != ':') - goto yy31; - yy42: - ++p; - { return (bufsize_t)(p - start); } - yy44: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych == 'E') - goto yy45; - if (yych != 'e') - goto yy31; - yy45: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych == 'R') - goto yy46; - if (yych != 'r') - goto yy31; - yy46: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych == 'Y') - goto yy41; - if (yych == 'y') - goto yy41; - goto yy31; - yy47: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych == 'Y') - goto yy48; - if (yych != 'y') - goto yy31; - yy48: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych == 'P') - goto yy49; - if (yych != 'p') - goto yy31; - yy49: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } yych = *++p; - if (yych == 'A') - goto yy50; - if (yych != 'a') - goto yy31; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy6; + } else { + if (yych <= ',') + goto yy6; + if (yych >= '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy14; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + ++p; + if ((yych = *p) == ':') + goto yy14; + goto yy6; + } +} + +// Try to match URI autolink after first <, returning number of chars matched. +bufsize_t _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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); + if (yych <= 0x7F) { + if (yych <= ' ') { + if (yych == '\n') + goto yy48; + if (yych <= 0x1F) + goto yy50; + goto yy49; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy50; + goto yy49; + } else { + if (yych <= '`') + goto yy50; + if (yych <= 'z') + goto yy49; + goto yy50; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) { + if (yych >= 0xC2) + goto yy51; + } else { + if (yych <= 0xE0) + goto yy53; + if (yych <= 0xEC) + goto yy54; + goto yy58; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy54; + goto yy55; + } else { + if (yych <= 0xF3) + goto yy56; + if (yych <= 0xF4) + goto yy57; + } + } + } + yy48 : { return 0; } + yy49: + yych = *(marker = ++p); + if (yych <= '.') { + if (yych == '+') + goto yy59; + if (yych <= ',') + goto yy48; + goto yy59; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy48; + goto yy59; + } else { + if (yych <= '`') + goto yy48; + if (yych <= 'z') + goto yy59; + goto yy48; + } + } yy50: yych = *++p; - if (yych == 'R') - goto yy51; - if (yych != 'r') - goto yy31; + goto yy48; yy51: yych = *++p; - if (yych == 'C') - goto yy41; - if (yych == 'c') - goto yy41; - goto yy31; + if (yych <= 0x7F) + goto yy52; + if (yych <= 0xBF) + goto yy50; yy52: + p = marker; + goto yy48; + yy53: yych = *++p; - if (yych != '2') - goto yy31; - yych = *++p; - if (yych == 'K') - goto yy41; - if (yych == 'k') - goto yy41; - goto yy31; + if (yych <= 0x9F) + goto yy52; + if (yych <= 0xBF) + goto yy51; + goto yy52; yy54: yych = *++p; - if (yych == 'L') - goto yy65; - if (yych == 'l') - goto yy65; - goto yy31; + if (yych <= 0x7F) + goto yy52; + if (yych <= 0xBF) + goto yy51; + goto yy52; yy55: yych = *++p; - if (yych == 'T') - goto yy61; - if (yych == 't') - goto yy61; - goto yy31; + if (yych <= 0x8F) + goto yy52; + if (yych <= 0xBF) + goto yy54; + goto yy52; yy56: yych = *++p; - if (yych == 'S') - goto yy57; - if (yych != 's') - goto yy31; + if (yych <= 0x7F) + goto yy52; + if (yych <= 0xBF) + goto yy54; + goto yy52; yy57: yych = *++p; - if (yych == 'H') - goto yy58; - if (yych != 'h') - goto yy31; + if (yych <= 0x7F) + goto yy52; + if (yych <= 0x8F) + goto yy54; + goto yy52; yy58: yych = *++p; - if (yych == 'A') - goto yy59; - if (yych != 'a') - goto yy31; + if (yych <= 0x7F) + goto yy52; + if (yych <= 0x9F) + goto yy51; + goto yy52; yy59: yych = *++p; - if (yych == 'R') - goto yy60; - if (yych != 'r') - goto yy31; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + goto yy62; + } else { + if (yych <= ',') + goto yy52; + if (yych <= '.') + goto yy62; + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + goto yy62; + } else { + if (yych <= '`') + goto yy52; + if (yych <= 'z') + goto yy62; + goto yy52; + } + } yy60: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy61: - yych = *++p; - if (yych == 'C') - goto yy62; - if (yych != 'c') - goto yy31; - yy62: - yych = *++p; - if (yych == 'O') - goto yy63; - if (yych != 'o') - goto yy31; - yy63: - yych = *++p; - if (yych == 'I') - goto yy64; - if (yych != 'i') - goto yy31; - yy64: - yych = *++p; - if (yych == 'N') - goto yy41; - if (yych == 'n') - goto yy41; - goto yy31; - yy65: - yych = *++p; - if (yych == 'O') - goto yy41; - if (yych == 'o') - goto yy41; - goto yy31; - yy66: - 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 yy41; - if (yych <= 'q') - goto yy31; - if (yych <= 's') - goto yy41; - goto yy31; - yy71: - yych = *++p; - if (yych == 'I') - goto yy41; - if (yych == 'i') - goto yy41; - goto yy31; - yy72: - yych = *++p; - if (yych == 'I') - goto yy93; - if (yych == 'i') - goto yy93; - goto yy31; - yy73: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') - goto yy83; - if (yych <= 'O') - goto yy31; - goto yy84; + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy60; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '<') + goto yy52; + if (yych <= '>') + goto yy99; + goto yy52; + } else { + if (yych <= 0xDF) + goto yy92; + if (yych <= 0xE0) + goto yy93; + goto yy94; + } } else { - if (yych <= 'l') { - if (yych <= 'k') - goto yy31; - goto yy83; + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy98; + if (yych <= 0xEF) + goto yy94; + goto yy95; } else { - if (yych == 'p') - goto yy84; - goto yy31; + if (yych <= 0xF3) + goto yy96; + if (yych <= 0xF4) + goto yy97; + goto yy52; } } - yy74: - yych = *++p; - if (yych == 'O') - goto yy75; - if (yych != 'o') - goto yy31; - yy75: - yych = *++p; - if (yych == 'N') - goto yy76; - if (yych != 'n') - goto yy31; - yy76: - yych = *++p; - if (yych == '-') - goto yy77; - if (yych == ':') - goto yy42; - goto yy31; - yy77: - yych = *++p; - if (yych == 'U') - goto yy78; - if (yych != 'u') - goto yy31; - yy78: - yych = *++p; - if (yych == 'S') - goto yy79; - if (yych != 's') - goto yy31; - yy79: - yych = *++p; - if (yych == 'E') - goto yy80; - if (yych != 'e') - goto yy31; - yy80: - yych = *++p; - if (yych == 'R') - goto yy81; - if (yych != 'r') - goto yy31; - yy81: - yych = *++p; - if (yych == 'I') - goto yy82; - if (yych != 'i') - goto yy31; - yy82: - yych = *++p; - if (yych == 'D') - goto yy41; - if (yych == 'd') - goto yy41; - goto yy31; - yy83: + yy62: yych = *++p; - if (yych == 'R') - goto yy85; - if (yych == 'r') - goto yy85; - goto yy31; - yy84: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy85: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'P') - goto yy86; - if (yych != 'p') - goto yy31; - yy86: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'C') - goto yy87; - if (yych != 'c') - goto yy31; - yy87: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych != '.') - goto yy31; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'B') - goto yy89; - if (yych != 'b') - goto yy31; - yy89: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'E') - goto yy90; - if (yych != 'e') - goto yy31; - yy90: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'E') - goto yy91; - if (yych != 'e') - goto yy31; - yy91: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'P') - goto yy92; - if (yych != 'p') - goto yy31; - yy92: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy42; - goto yy31; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } } else { - if (yych <= 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } } - yy93: yych = *++p; - if (yych == 'R') - goto yy94; - if (yych != 'r') - goto yy31; - yy94: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy95: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'C') - goto yy103; - if (yych == 'c') - goto yy103; - goto yy31; - yy96: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'A') - goto yy102; - if (yych == 'a') - goto yy102; - goto yy31; - yy97: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'B') - goto yy99; - if (yych == 'b') - goto yy99; - goto yy31; - yy98: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy42; - goto yy31; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } } else { - if (yych <= 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } } - yy99: yych = *++p; - if (yych == 'C') - goto yy100; - if (yych != 'c') - goto yy31; - yy100: - yych = *++p; - if (yych == 'A') - goto yy101; - if (yych != 'a') - goto yy31; - yy101: - yych = *++p; - if (yych == 'L') - goto yy41; - if (yych == 'l') - goto yy41; - goto yy31; - yy102: - yych = *++p; - if (yych == 'I') - goto yy41; - if (yych == 'i') - goto yy41; - goto yy31; - yy103: - yych = *++p; - if (yych == 'I') - goto yy104; - if (yych != 'i') - goto yy31; - yy104: - yych = *++p; - if (yych == 'W') - goto yy105; - if (yych != 'w') - goto yy31; - yy105: - yych = *++p; - if (yych == 'Y') - goto yy106; - if (yych != 'y') - goto yy31; - yy106: - yych = *++p; - if (yych == 'G') - goto yy41; - if (yych == 'g') - goto yy41; - goto yy31; - yy107: - yych = *++p; - if (yych == 'E') - goto yy116; - if (yych == 'e') - goto yy116; - goto yy31; - yy108: - yych = *++p; - if (yych <= 'N') { - if (yych <= 'L') - goto yy31; - if (yych >= 'N') - goto yy110; - } else { - if (yych <= 'l') - goto yy31; - if (yych <= 'm') - goto yy109; - if (yych <= 'n') - goto yy110; - goto yy31; - } - yy109: - yych = *++p; - if (yych == 'M') - goto yy115; - if (yych == 'm') - goto yy115; - goto yy31; - yy110: - yych = *++p; - if (yych == 'T') - goto yy111; - if (yych != 't') - goto yy31; - yy111: - yych = *++p; - if (yych == 'R') - goto yy112; - if (yych != 'r') - goto yy31; - yy112: - yych = *++p; - if (yych == 'I') - goto yy113; - if (yych != 'i') - goto yy31; - yy113: - yych = *++p; - if (yych == 'L') - goto yy114; - if (yych != 'l') - goto yy31; - yy114: - yych = *++p; - if (yych == 'O') - goto yy41; - if (yych == 'o') - goto yy41; - goto yy31; - yy115: - yych = *++p; - if (yych == 'I') - goto yy41; - if (yych == 'i') - goto yy41; - goto yy31; - yy116: - yych = *++p; - if (yych == 'W') - goto yy117; - if (yych != 'w') - goto yy31; - yy117: - yych = *++p; - if (yych != '-') - goto yy31; - yych = *++p; - if (yych == 'S') - goto yy119; - if (yych != 's') - goto yy31; - yy119: - yych = *++p; - if (yych == 'O') - goto yy120; - if (yych != 'o') - goto yy31; - yy120: - yych = *++p; - if (yych == 'U') - goto yy121; - if (yych != 'u') - goto yy31; - yy121: - yych = *++p; - if (yych == 'R') - goto yy122; - if (yych != 'r') - goto yy31; - yy122: - yych = *++p; - if (yych == 'C') - goto yy123; - if (yych != 'c') - goto yy31; - yy123: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy124: - yych = *++p; - if (yych == '2') - goto yy131; - goto yy31; - yy125: - yych = *++p; - if (yych == 'R') - goto yy128; - if (yych == 'r') - goto yy128; - goto yy31; - yy126: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy127: - yych = *++p; - if (yych == 'N') - goto yy41; - if (yych == 'n') - goto yy41; - goto yy31; - yy128: - yych = *++p; - if (yych == 'E') - goto yy129; - if (yych != 'e') - goto yy31; - yy129: - yych = *++p; - if (yych == 'A') - goto yy130; - if (yych != 'a') - goto yy31; - yy130: - yych = *++p; - if (yych == 'L') - goto yy41; - if (yych == 'l') - goto yy41; - goto yy31; - yy131: - yych = *++p; - if (yych != '0') - goto yy31; - yych = *++p; - if (yych != '0') - goto yy31; - yych = *++p; - if (yych == '4') - goto yy41; - goto yy31; - yy134: - yych = *++p; - if (yych == 'I') - goto yy153; - if (yych == 'i') - goto yy153; - goto yy31; - yy135: - yych = *++p; - if (yych <= 'L') { - if (yych == 'A') - goto yy145; - if (yych <= 'K') - goto yy31; - goto yy144; - } else { - if (yych <= 'a') { - if (yych <= '`') - goto yy31; - goto yy145; - } else { - if (yych == 'l') - goto yy144; - goto yy31; - } - } - yy136: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy137: - yych = *++p; - if (yych == '3') - goto yy141; - goto yy31; - yy138: - yych = *++p; - if (yych == 'T') - goto yy140; - if (yych == 't') - goto yy140; - goto yy31; - yy139: - yych = *++p; - if (yych == 'G') - goto yy41; - if (yych == 'g') - goto yy41; - goto yy31; - yy140: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy141: - yych = *++p; - if (yych != '2') - goto yy31; - yych = *++p; - if (yych != '7') - goto yy31; - yych = *++p; - if (yych == '0') - goto yy41; - goto yy31; - yy144: - yych = *++p; - if (yych <= 'M') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'N') - goto yy151; - if (yych == 'n') - goto yy151; - goto yy31; - } - yy145: - yych = *++p; - if (yych == 'M') - goto yy146; - if (yych != 'm') - goto yy31; - yy146: - yych = *++p; - if (yych == 'S') - goto yy147; - if (yych != 's') - goto yy31; - yy147: - yych = *++p; - if (yych == 'P') - goto yy148; - if (yych != 'p') - goto yy31; - yy148: - yych = *++p; - if (yych == 'E') - goto yy149; - if (yych != 'e') - goto yy31; - yy149: - yych = *++p; - if (yych == 'A') - goto yy150; - if (yych != 'a') - goto yy31; - yy150: - yych = *++p; - if (yych == 'K') - goto yy41; - if (yych == 'k') - goto yy41; - goto yy31; - yy151: - yych = *++p; - if (yych == 'E') - goto yy152; - if (yych != 'e') - goto yy31; - yy152: - yych = *++p; - if (yych == 'T') - goto yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy153: - yych = *++p; - if (yych <= 'S') { - if (yych == 'N') - goto yy154; - if (yych <= 'R') - goto yy31; - goto yy155; - } else { - if (yych <= 'n') { - if (yych <= 'm') - goto yy31; - } else { - if (yych == 's') - goto yy155; - goto yy31; - } - } - yy154: - yych = *++p; - if (yych == 'G') - goto yy162; - if (yych == 'g') - goto yy162; - goto yy31; - yy155: - yych = *++p; - if (yych == 'M') - goto yy156; - if (yych != 'm') - goto yy31; - yy156: - yych = *++p; - if (yych == 'E') - goto yy157; - if (yych != 'e') - goto yy31; - yy157: - yych = *++p; - if (yych == 'S') - goto yy158; - if (yych != 's') - goto yy31; - yy158: - yych = *++p; - if (yych == 'S') - goto yy159; - if (yych != 's') - goto yy31; - yy159: - yych = *++p; - if (yych == 'A') - goto yy160; - if (yych != 'a') - goto yy31; - yy160: - yych = *++p; - if (yych == 'G') - goto yy161; - if (yych != 'g') - goto yy31; - yy161: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy162: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy163: - yych = *++p; - if (yych == 'N') - goto yy41; - if (yych == 'n') - goto yy41; - goto yy31; - yy164: - yych = *++p; - if (yych == 'E') - goto yy214; - if (yych == 'e') - goto yy214; - goto yy31; - yy165: - yych = *++p; - if (yych == 'H') - goto yy41; - if (yych == 'h') - goto yy41; - goto yy31; - yy166: - yych = *++p; - if (yych == 'O') - goto yy210; - if (yych == 'o') - goto yy210; - goto yy31; - yy167: - yych = *++p; - if (yych <= 'L') { - if (yych == 'A') - goto yy200; - if (yych <= 'K') - goto yy31; - goto yy201; - } else { - if (yych <= 'a') { - if (yych <= '`') - goto yy31; - goto yy200; - } else { - if (yych == 'l') - goto yy201; - goto yy31; - } - } - yy168: - yych = *++p; - if (yych <= 'S') { - if (yych == 'B') - goto yy41; - if (yych <= 'R') - goto yy31; - goto yy41; - } else { - if (yych <= 'b') { - if (yych <= 'a') - goto yy31; - goto yy41; - } else { - if (yych == 's') - goto yy41; - goto yy31; - } - } - yy169: - yych = *++p; - if (yych == 'Y') - goto yy198; - if (yych == 'y') - goto yy198; - goto yy31; - yy170: - yych = *++p; - if (yych == 'N') - goto yy41; - if (yych == 'n') - goto yy41; - goto yy31; - yy171: - yych = *++p; - if (yych == 'T') - goto yy197; - if (yych == 't') - goto yy197; - goto yy31; - yy172: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'C') { - if (yych <= 'B') - goto yy31; - goto yy184; - } else { - if (yych <= 'Q') - goto yy31; - if (yych <= 'R') - goto yy182; - goto yy183; - } - } else { - if (yych <= 'q') { - if (yych == 'c') - goto yy184; - goto yy31; - } else { - if (yych <= 'r') - goto yy182; - if (yych <= 's') - goto yy183; - goto yy31; - } - } - yy173: - yych = *++p; - if (yych == 'M') - goto yy181; - if (yych == 'm') - goto yy181; - goto yy31; - yy174: - yych = *++p; - if (yych <= 'P') { - if (yych == 'E') - goto yy178; - if (yych <= 'O') - goto yy31; - goto yy179; - } else { - if (yych <= 'e') { - if (yych <= 'd') - goto yy31; - goto yy178; - } else { - if (yych == 'p') - goto yy179; - goto yy31; - } - } - yy175: - yych = *++p; - if (yych == 'T') - goto yy176; - if (yych != 't') - goto yy31; - yy176: - yych = *++p; - if (yych == 'T') - goto yy177; - if (yych != 't') - goto yy31; - yy177: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy178: - yych = *++p; - if (yych == 'V') - goto yy180; - if (yych == 'v') - goto yy180; - goto yy31; - yy179: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - } - yy180: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy181: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy182: - yych = *++p; - if (yych == 'V') - goto yy194; - if (yych == 'v') - goto yy194; - goto yy31; - yy183: - yych = *++p; - if (yych == 'S') - goto yy191; - if (yych == 's') - goto yy191; - goto yy31; - yy184: - yych = *++p; - if (yych == 'O') - goto yy185; - if (yych != 'o') - goto yy31; - yy185: - yych = *++p; - if (yych == 'N') - goto yy186; - if (yych != 'n') - goto yy31; - yy186: - yych = *++p; - if (yych == 'D') - goto yy187; - if (yych != 'd') - goto yy31; - yy187: - yych = *++p; - if (yych == 'L') - goto yy188; - if (yych != 'l') - goto yy31; - yy188: - yych = *++p; - if (yych == 'I') - goto yy189; - if (yych != 'i') - goto yy31; - yy189: - yych = *++p; - if (yych == 'F') - goto yy190; - if (yych != 'f') - goto yy31; - yy190: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy191: - yych = *++p; - if (yych == 'I') - goto yy192; - if (yych != 'i') - goto yy31; - yy192: - yych = *++p; - if (yych == 'O') - goto yy193; - if (yych != 'o') - goto yy31; - yy193: - yych = *++p; - if (yych == 'N') - goto yy41; - if (yych == 'n') - goto yy41; - goto yy31; - yy194: - yych = *++p; - if (yych == 'I') - goto yy195; - if (yych != 'i') - goto yy31; - yy195: - yych = *++p; - if (yych == 'C') - goto yy196; - if (yych != 'c') - goto yy31; - yy196: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy197: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy198: - yych = *++p; - if (yych == 'P') - goto yy199; - if (yych != 'p') - goto yy31; - yy199: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy200: - yych = *++p; - if (yych == 'P') - goto yy204; - if (yych == 'p') - goto yy204; - goto yy31; - yy201: - yych = *++p; - if (yych == 'D') - goto yy202; - if (yych != 'd') - goto yy31; - yy202: - yych = *++p; - if (yych == 'A') - goto yy203; - if (yych != 'a') - goto yy31; - yy203: - yych = *++p; - if (yych == 'T') - goto yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy204: - yych = *++p; - if (yych != '.') - goto yy31; - yych = *++p; - if (yych == 'B') - goto yy206; - if (yych != 'b') - goto yy31; - yy206: - yych = *++p; - if (yych == 'E') - goto yy207; - if (yych != 'e') - goto yy31; - yy207: - yych = *++p; - if (yych == 'E') - goto yy208; - if (yych != 'e') - goto yy31; - yy208: - yych = *++p; - if (yych == 'P') - goto yy209; - if (yych != 'p') - goto yy31; - yy209: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - } - yy210: - yych = *++p; - if (yych == 'T') - goto yy211; - if (yych != 't') - goto yy31; - yy211: - yych = *++p; - if (yych == 'I') - goto yy212; - if (yych != 'i') - goto yy31; - yy212: - yych = *++p; - if (yych == 'F') - goto yy213; - if (yych != 'f') - goto yy31; - yy213: - yych = *++p; - if (yych == 'Y') - goto yy41; - if (yych == 'y') - goto yy41; - goto yy31; - yy214: - yych = *++p; - if (yych == 'A') - goto yy215; - if (yych != 'a') - goto yy31; - yy215: - yych = *++p; - if (yych == 'M') - goto yy41; - if (yych == 'm') - goto yy41; - goto yy31; - yy216: - yych = *++p; - if (yych <= 'S') { - if (yych == 'M') - goto yy228; - if (yych <= 'R') - goto yy31; - goto yy227; - } else { - if (yych <= 'm') { - if (yych <= 'l') - goto yy31; - goto yy228; - } else { - if (yych == 's') - goto yy227; - goto yy31; - } - } - yy217: - yych = *++p; - if (yych == 'Y') - goto yy225; - if (yych == 'y') - goto yy225; - goto yy31; - yy218: - yych = *++p; - if (yych == 'I') - goto yy41; - if (yych == 'i') - goto yy41; - goto yy31; - yy219: - yych = *++p; - if (yych == 'S') - goto yy220; - if (yych != 's') - goto yy31; - yy220: - yych = *++p; - if (yych <= 'N') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'O') - goto yy221; - if (yych != 'o') - goto yy31; - } - yy221: - yych = *++p; - if (yych == 'U') - goto yy222; - if (yych != 'u') - goto yy31; - yy222: - yych = *++p; - if (yych == 'R') - goto yy223; - if (yych != 'r') - goto yy31; - yy223: - yych = *++p; - if (yych == 'C') - goto yy224; - if (yych != 'c') - goto yy31; - yy224: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy225: - yych = *++p; - if (yych == 'N') - goto yy226; - if (yych != 'n') - goto yy31; - yy226: - yych = *++p; - if (yych == 'C') - goto yy41; - if (yych == 'c') - goto yy41; - goto yy31; - yy227: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy228: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy229: - yych = *++p; - if (yych == 'Y') - goto yy249; - if (yych == 'y') - goto yy249; - goto yy31; - yy230: - yych = *++p; - if (yych <= 'O') { - if (yych == 'E') - goto yy246; - if (yych <= 'N') - goto yy31; - goto yy247; - } else { - if (yych <= 'e') { - if (yych <= 'd') - goto yy31; - goto yy246; - } else { - if (yych == 'o') - goto yy247; - goto yy31; - } - } - yy231: - yych = *++p; - if (yych == 'A') - goto yy241; - if (yych == 'a') - goto yy241; - goto yy31; - yy232: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') - goto yy234; - if (yych <= 'O') - goto yy31; - goto yy235; - } else { - if (yych <= 'l') { - if (yych <= 'k') - goto yy31; - goto yy234; - } else { - if (yych == 'p') - goto yy235; - goto yy31; - } - } - yy233: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy234: - yych = *++p; - if (yych == 'M') - goto yy41; - if (yych == 'm') - goto yy41; - goto yy31; - yy235: - yych = *++p; - if (yych == 'A') - goto yy236; - if (yych != 'a') - goto yy31; - yy236: - yych = *++p; - if (yych == 'R') - goto yy237; - if (yych != 'r') - goto yy31; - yy237: - yych = *++p; - if (yych == 'A') - goto yy238; - if (yych != 'a') - goto yy31; - yy238: - yych = *++p; - if (yych == 'Z') - goto yy239; - if (yych != 'z') - goto yy31; - yy239: - yych = *++p; - if (yych == 'Z') - goto yy240; - if (yych != 'z') - goto yy31; - yy240: - yych = *++p; - if (yych == 'I') - goto yy41; - if (yych == 'i') - goto yy41; - goto yy31; - yy241: - yych = *++p; - if (yych == 'T') - goto yy242; - if (yych != 't') - goto yy31; - yy242: - yych = *++p; - if (yych == 'F') - goto yy243; - if (yych != 'f') - goto yy31; - yy243: - yych = *++p; - if (yych == 'O') - goto yy244; - if (yych != 'o') - goto yy31; - yy244: - yych = *++p; - if (yych == 'R') - goto yy245; - if (yych != 'r') - goto yy31; - yy245: - yych = *++p; - if (yych == 'M') - goto yy41; - if (yych == 'm') - goto yy41; - goto yy31; - yy246: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy247: - yych = *++p; - if (yych == 'X') - goto yy248; - if (yych != 'x') - goto yy31; - yy248: - yych = *++p; - if (yych == 'Y') - goto yy41; - if (yych == 'y') - goto yy41; - goto yy31; - yy249: - yych = *++p; - if (yych == 'C') - goto yy41; - if (yych == 'c') - goto yy41; - goto yy31; - yy250: - yych = *++p; - if (yych == 'D') - goto yy41; - if (yych == 'd') - goto yy41; - goto yy31; - yy251: - yych = *++p; - if (yych == 'A') - goto yy252; - if (yych != 'a') - goto yy31; - yy252: - yych = *++p; - if (yych == 'Q') - goto yy253; - if (yych != 'q') - goto yy31; - yy253: - yych = *++p; - if (yych == 'U') - goto yy254; - if (yych != 'u') - goto yy31; - yy254: - yych = *++p; - if (yych == 'E') - goto yy255; - if (yych != 'e') - goto yy31; - yy255: - yych = *++p; - if (yych == 'L') - goto yy256; - if (yych != 'l') - goto yy31; - yy256: - yych = *++p; - if (yych == 'O') - goto yy257; - if (yych != 'o') - goto yy31; - yy257: - yych = *++p; - if (yych == 'C') - goto yy258; - if (yych != 'c') - goto yy31; - yy258: - yych = *++p; - if (yych == 'K') - goto yy259; - if (yych != 'k') - goto yy31; - yy259: - yych = *++p; - if (yych == 'T') - goto yy260; - if (yych != 't') - goto yy31; - yy260: - yych = *++p; - if (yych == 'O') - goto yy261; - if (yych != 'o') - goto yy31; - yy261: - yych = *++p; - if (yych == 'K') - goto yy262; - if (yych != 'k') - goto yy31; - yy262: - yych = *++p; - if (yych == 'E') - goto yy263; - if (yych != 'e') - goto yy31; - yy263: - yych = *++p; - if (yych == 'N') - goto yy41; - if (yych == 'n') - goto yy41; - goto yy31; - yy264: - yych = *++p; - if (yych == 'T') - goto yy271; - if (yych == 't') - goto yy271; - goto yy31; - yy265: - yych = *++p; - if (yych == 'T') - goto yy270; - if (yych == 't') - goto yy270; - goto yy31; - yy266: - yych = *++p; - if (yych <= 'G') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'H') - goto yy41; - if (yych == 'h') - goto yy41; - goto yy31; - } - yy267: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy268: - yych = *++p; - if (yych == 'W') - goto yy269; - if (yych != 'w') - goto yy31; - yy269: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy270: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy271: - yych = *++p; - if (yych == 'E') - goto yy272; - if (yych != 'e') - goto yy31; - yy272: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy273: - yych = *++p; - if (yych == 'N') - goto yy41; - if (yych == 'n') - goto yy41; - goto yy31; - yy274: - yych = *++p; - if (yych <= 'P') { - if (yych == 'M') - goto yy305; - if (yych <= 'O') - goto yy31; - goto yy304; - } else { - if (yych <= 'm') { - if (yych <= 'l') - goto yy31; - goto yy305; - } else { - if (yych == 'p') - goto yy304; - goto yy31; - } - } - yy275: - yych = *++p; - if (yych <= 'Q') { - if (yych <= '-') { - if (yych <= ',') - goto yy31; - goto yy297; - } else { - if (yych == 'N') - goto yy298; - goto yy31; - } - } else { - if (yych <= 'n') { - if (yych <= 'R') - goto yy296; - if (yych <= 'm') - goto yy31; - goto yy298; - } else { - if (yych == 'r') - goto yy296; - goto yy31; - } - } - yy276: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy277: - yych = *++p; - if (yych == 'S') - goto yy292; - if (yych == 's') - goto yy292; - goto yy31; - yy278: - yych = *++p; - switch (yych) { - case 'G': - case 'g': - goto yy283; - case 'I': - case 'i': - goto yy282; - case 'P': - case 'p': - goto yy284; - case 'R': - case 'r': - goto yy285; - default: - goto yy31; - } - yy279: - yych = *++p; - if (yych == 'Q') - goto yy281; - if (yych == 'q') - goto yy281; - goto yy31; - yy280: - yych = *++p; - if (yych == 'D') - goto yy41; - if (yych == 'd') - goto yy41; - goto yy31; - yy281: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy282: - yych = *++p; - if (yych == 'L') - goto yy290; - if (yych == 'l') - goto yy290; - goto yy31; - yy283: - yych = *++p; - if (yych == 'N') - goto yy288; - if (yych == 'n') - goto yy288; - goto yy31; - yy284: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy285: - yych = *++p; - if (yych == 'K') - goto yy286; - if (yych != 'k') - goto yy31; - yy286: - yych = *++p; - if (yych == 'E') - goto yy287; - if (yych != 'e') - goto yy31; - yy287: - yych = *++p; - if (yych == 'T') - goto yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy288: - yych = *++p; - if (yych == 'E') - goto yy289; - if (yych != 'e') - goto yy31; - yy289: - yych = *++p; - if (yych == 'T') - goto yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy290: - yych = *++p; - if (yych == 'T') - goto yy291; - if (yych != 't') - goto yy31; - yy291: - yych = *++p; - if (yych == 'O') - goto yy41; - if (yych == 'o') - goto yy41; - goto yy31; - yy292: - yych = *++p; - if (yych == 'S') - goto yy293; - if (yych != 's') - goto yy31; - yy293: - yych = *++p; - if (yych == 'A') - goto yy294; - if (yych != 'a') - goto yy31; - yy294: - yych = *++p; - if (yych == 'G') - goto yy295; - if (yych != 'g') - goto yy31; - yy295: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy296: - yych = *++p; - if (yych == 'P') - goto yy303; - if (yych == 'p') - goto yy303; - goto yy31; - yy297: - yych = *++p; - if (yych == 'H') - goto yy300; - if (yych == 'h') - goto yy300; - goto yy31; - yy298: - yych = *++p; - if (yych == 'I') - goto yy299; - if (yych != 'i') - goto yy31; - yy299: - yych = *++p; - if (yych == 'M') - goto yy41; - if (yych == 'm') - goto yy41; - goto yy31; - yy300: - yych = *++p; - if (yych == 'E') - goto yy301; - if (yych != 'e') - goto yy31; - yy301: - yych = *++p; - if (yych == 'L') - goto yy302; - if (yych != 'l') - goto yy31; - yy302: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy303: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - } - yy304: - yych = *++p; - if (yych == 'D') - goto yy308; - if (yych == 'd') - goto yy308; - goto yy31; - yy305: - yych = *++p; - if (yych == 'B') - goto yy306; - if (yych != 'b') - goto yy31; - yy306: - yych = *++p; - if (yych == 'L') - goto yy307; - if (yych != 'l') - goto yy31; - yy307: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy308: - yych = *++p; - if (yych == 'A') - goto yy309; - if (yych != 'a') - goto yy31; - yy309: - yych = *++p; - if (yych == 'T') - goto yy310; - if (yych != 't') - goto yy31; - yy310: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy311: - yych = *++p; - if (yych == 'A') - goto yy316; - if (yych == 'a') - goto yy316; - goto yy31; - yy312: - yych = *++p; - if (yych == 'S') - goto yy313; - if (yych != 's') - goto yy31; - yy313: - yych = *++p; - if (yych == 'T') - goto yy314; - if (yych != 't') - goto yy31; - yy314: - yych = *++p; - if (yych == 'F') - goto yy315; - if (yych != 'f') - goto yy31; - yy315: - yych = *++p; - if (yych == 'M') - goto yy41; - if (yych == 'm') - goto yy41; - goto yy31; - yy316: - yych = *++p; - if (yych == 'P') - goto yy317; - if (yych != 'p') - goto yy31; - yy317: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - } - yy318: - yych = *++p; - if (yych == 'M') - goto yy341; - if (yych == 'm') - goto yy341; - goto yy31; - yy319: - yych = *++p; - if (yych <= 'I') { - if (yych == 'C') - goto yy330; - if (yych <= 'H') - goto yy31; - goto yy329; - } else { - if (yych <= 'c') { - if (yych <= 'b') - goto yy31; - goto yy330; - } else { - if (yych == 'i') - goto yy329; - goto yy31; - } - } - yy320: - yych = *++p; - if (yych <= 'P') { - if (yych == 'N') - goto yy41; - if (yych <= 'O') - goto yy31; - goto yy41; - } else { - if (yych <= 'n') { - if (yych <= 'm') - goto yy31; - goto yy41; - } else { - if (yych == 'p') - goto yy41; - goto yy31; - } - } - yy321: - yych = *++p; - if (yych <= 'O') { - if (yych == 'A') - goto yy327; - if (yych <= 'N') - goto yy31; - goto yy328; - } else { - if (yych <= 'a') { - if (yych <= '`') - goto yy31; - goto yy327; - } else { - if (yych == 'o') - goto yy328; - goto yy31; - } - } - yy322: - yych = *++p; - if (yych == 'F') - goto yy326; - if (yych == 'f') - goto yy326; - goto yy31; - yy323: - yych = *++p; - if (yych <= '@') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'A') - goto yy325; - if (yych == 'a') - goto yy325; - goto yy31; - } - yy324: - yych = *++p; - if (yych == 'X') - goto yy41; - if (yych == 'x') - goto yy41; - goto yy31; - yy325: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy326: - yych = *++p; - if (yych == 'O') - goto yy41; - if (yych == 'o') - goto yy41; - goto yy31; - yy327: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy328: - yych = *++p; - if (yych == 'N') - goto yy41; - if (yych == 'n') - goto yy41; - goto yy31; - yy329: - yych = *++p; - if (yych == 'S') - goto yy331; - if (yych == 's') - goto yy331; - goto yy31; - yy330: - yych = *++p; - if (yych <= ':') { - if (yych == '6') - goto yy41; - if (yych <= '9') - goto yy31; - goto yy42; - } else { - if (yych <= 'S') { - if (yych <= 'R') - goto yy31; - goto yy41; - } else { - if (yych == 's') - goto yy41; - goto yy31; - } - } - yy331: - yych = *++p; - if (yych == '.') - goto yy332; - if (yych == ':') - goto yy42; - goto yy31; - yy332: - yych = *++p; - if (yych <= 'X') { - if (yych <= 'K') { - if (yych == 'B') - goto yy335; - goto yy31; - } else { - if (yych <= 'L') - goto yy333; - if (yych <= 'W') - goto yy31; - goto yy334; - } - } else { - if (yych <= 'k') { - if (yych == 'b') - goto yy335; - goto yy31; - } else { - if (yych <= 'l') - goto yy333; - if (yych == 'x') - goto yy334; - goto yy31; - } - } - yy333: - yych = *++p; - if (yych == 'W') - goto yy340; - if (yych == 'w') - goto yy340; - goto yy31; - yy334: - yych = *++p; - if (yych == 'P') - goto yy338; - if (yych == 'p') - goto yy338; - goto yy31; - yy335: - yych = *++p; - if (yych == 'E') - goto yy336; - if (yych != 'e') - goto yy31; - yy336: - yych = *++p; - if (yych == 'E') - goto yy337; - if (yych != 'e') - goto yy31; - yy337: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy338: - yych = *++p; - if (yych == 'C') - goto yy339; - if (yych != 'c') - goto yy31; - yy339: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - } - yy340: - yych = *++p; - if (yych == 'Z') - goto yy41; - if (yych == 'z') - goto yy41; - goto yy31; - yy341: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy342: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy343: - yych = *++p; - if (yych == 'T') - goto yy346; - if (yych == 't') - goto yy346; - goto yy31; - yy344: - yych = *++p; - if (yych != '2') - goto yy31; - yych = *++p; - if (yych == '3') - goto yy41; - goto yy31; - yy346: - yych = *++p; - if (yych == 'P') - goto yy347; - if (yych != 'p') - goto yy31; - yy347: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - } - yy348: - yych = *++p; - if (yych == 'A') - goto yy364; - if (yych == 'a') - goto yy364; - goto yy31; - yy349: - yych = *++p; - if (yych <= 'Z') { - if (yych == 'T') - goto yy41; - if (yych <= 'Y') - goto yy31; - goto yy355; - } else { - if (yych <= 't') { - if (yych <= 's') - goto yy31; - goto yy41; - } else { - if (yych == 'z') - goto yy355; - goto yy31; - } - } - yy350: - yych = *++p; - if (yych <= 'O') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'P') - goto yy352; - if (yych == 'p') - goto yy352; - goto yy31; - } - yy351: - yych = *++p; - if (yych == 'O') - goto yy41; - if (yych == 'o') - goto yy41; - goto yy31; - yy352: - yych = *++p; - if (yych == 'H') - goto yy353; - if (yych != 'h') - goto yy31; - yy353: - yych = *++p; - if (yych == 'E') - goto yy354; - if (yych != 'e') - goto yy31; - yy354: - yych = *++p; - if (yych == 'R') - goto yy41; - if (yych == 'r') - goto yy41; - goto yy31; - yy355: - yych = *++p; - if (yych == 'M') - goto yy356; - if (yych != 'm') - goto yy31; - yy356: - yych = *++p; - if (yych == 'O') - goto yy357; - if (yych != 'o') - goto yy31; - yy357: - yych = *++p; - if (yych == 'P') - goto yy358; - if (yych != 'p') - goto yy31; - yy358: - yych = *++p; - if (yych == 'R') - goto yy359; - if (yych != 'r') - goto yy31; - yy359: - yych = *++p; - if (yych == 'O') - goto yy360; - if (yych != 'o') - goto yy31; - yy360: - yych = *++p; - if (yych == 'J') - goto yy361; - if (yych != 'j') - goto yy31; - yy361: - yych = *++p; - if (yych == 'E') - goto yy362; - if (yych != 'e') - goto yy31; - yy362: - yych = *++p; - if (yych == 'C') - goto yy363; - if (yych != 'c') - goto yy31; - yy363: - yych = *++p; - if (yych == 'T') - goto yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy364: - yych = *++p; - if (yych == 'L') - goto yy365; - if (yych != 'l') - goto yy31; - yy365: - yych = *++p; - if (yych == 'K') - goto yy41; - if (yych == 'k') - goto yy41; - goto yy31; - yy366: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'M') { - if (yych == 'L') - goto yy376; - goto yy31; - } else { - if (yych <= 'N') - goto yy377; - if (yych <= 'R') - goto yy31; - goto yy378; - } - } else { - if (yych <= 'm') { - if (yych == 'l') - goto yy376; - goto yy31; - } else { - if (yych <= 'n') - goto yy377; - if (yych == 's') - goto yy378; - goto yy31; - } - } - yy367: - yych = *++p; - if (yych == 'E') - goto yy375; - if (yych == 'e') - goto yy375; - goto yy31; - yy368: - yych = *++p; - if (yych == 'C') - goto yy370; - if (yych == 'c') - goto yy370; - goto yy31; - yy369: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy370: - yych = *++p; - if (yych == 'E') - goto yy371; - if (yych != 'e') - goto yy31; - yy371: - yych = *++p; - if (yych == 'T') - goto yy372; - if (yych != 't') - goto yy31; - yy372: - yych = *++p; - if (yych == 'I') - goto yy373; - if (yych != 'i') - goto yy31; - yy373: - yych = *++p; - if (yych == 'M') - goto yy374; - if (yych != 'm') - goto yy31; - yy374: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy375: - yych = *++p; - if (yych == 'D') - goto yy41; - if (yych == 'd') - goto yy41; - goto yy31; - yy376: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy377: - yych = *++p; - if (yych == 'G') - goto yy379; - if (yych == 'g') - goto yy379; - goto yy31; - yy378: - yych = *++p; - if (yych == 'H') - goto yy41; - if (yych == 'h') - goto yy41; - goto yy31; - yy379: - yych = *++p; - if (yych == 'E') - goto yy380; - if (yych != 'e') - goto yy31; - yy380: - yych = *++p; - if (yych == 'R') - goto yy41; - if (yych == 'r') - goto yy41; - goto yy31; - yy381: - yych = *++p; - if (yych == 'T') - goto yy399; - if (yych == 't') - goto yy399; - goto yy31; - yy382: - yych = *++p; - if (yych == 'T') - goto yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy383: - yych = *++p; - if (yych == 'M') - goto yy41; - if (yych == 'm') - goto yy41; - goto yy31; - yy384: - yych = *++p; - if (yych <= 'S') { - if (yych == 'P') - goto yy41; - if (yych <= 'R') - goto yy31; - goto yy41; - } else { - if (yych <= 'p') { - if (yych <= 'o') - goto yy31; - goto yy41; - } else { - if (yych == 's') - goto yy41; - goto yy31; - } - } - yy385: - yych = *++p; - if (yych == 'I') - goto yy393; - if (yych == 'i') - goto yy393; - goto yy31; - yy386: - yych = *++p; - if (yych == 'A') - goto yy392; - if (yych == 'a') - goto yy392; - goto yy31; - yy387: - yych = *++p; - if (yych == 'O') - goto yy390; - if (yych == 'o') - goto yy390; - goto yy31; - yy388: - yych = *++p; - if (yych == 'A') - goto yy389; - if (yych != 'a') - goto yy31; - yy389: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy42; - goto yy31; - } else { - if (yych <= 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - } - yy390: - yych = *++p; - if (yych == 'U') - goto yy391; - if (yych != 'u') - goto yy31; - yy391: - yych = *++p; - if (yych == 'T') - goto yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy392: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy393: - yych = *++p; - if (yych == 'U') - goto yy394; - if (yych != 'u') - goto yy31; - yy394: - yych = *++p; - if (yych == 'M') - goto yy395; - if (yych != 'm') - goto yy31; - yy395: - yych = *++p; - if (yych == 'X') - goto yy396; - if (yych != 'x') - goto yy31; - yy396: - yych = *++p; - if (yych == 'T') - goto yy397; - if (yych != 't') - goto yy31; - yy397: - yych = *++p; - if (yych == 'R') - goto yy398; - if (yych != 'r') - goto yy31; - yy398: - yych = *++p; - if (yych == 'A') - goto yy41; - if (yych == 'a') - goto yy41; - goto yy31; - yy399: - yych = *++p; - if (yych == 'A') - goto yy400; - if (yych != 'a') - goto yy31; - yy400: - yych = *++p; - if (yych == 'C') - goto yy401; - if (yych != 'c') - goto yy31; - yy401: - yych = *++p; - if (yych == 'H') - goto yy402; - if (yych != 'h') - goto yy31; - yy402: - yych = *++p; - if (yych == 'M') - goto yy403; - if (yych != 'm') - goto yy31; - yy403: - yych = *++p; - if (yych == 'E') - goto yy404; - if (yych != 'e') - goto yy31; - yy404: - yych = *++p; - if (yych == 'N') - goto yy405; - if (yych != 'n') - goto yy31; - yy405: - yych = *++p; - if (yych == 'T') - goto yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy406: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy407: - yych = *++p; - if (yych <= 'V') { - if (yych == 'R') - goto yy41; - if (yych <= 'U') - goto yy31; - } else { - if (yych <= 'r') { - if (yych <= 'q') - goto yy31; - goto yy41; - } else { - if (yych != 'v') - goto yy31; - } - } - yych = *++p; - if (yych == 'A') - goto yy409; - if (yych != 'a') - goto yy31; - yy409: - yych = *++p; - if (yych == 'S') - goto yy410; - if (yych != 's') - goto yy31; - yy410: - yych = *++p; - if (yych == 'C') - goto yy411; - if (yych != 'c') - goto yy31; - yy411: - yych = *++p; - if (yych == 'R') - goto yy412; - if (yych != 'r') - goto yy31; - yy412: - yych = *++p; - if (yych == 'I') - goto yy413; - if (yych != 'i') - goto yy31; - yy413: - yych = *++p; - if (yych == 'P') - goto yy414; - if (yych != 'p') - goto yy31; - yy414: - yych = *++p; - if (yych == 'T') - goto yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy415: - yych = *++p; - if (yych == 'B') - goto yy41; - if (yych == 'b') - goto yy41; - goto yy31; - yy416: - yych = *++p; - if (yych == 'N') - goto yy41; - if (yych == 'n') - goto yy41; - goto yy31; - yy417: - yych = *++p; - if (yych == 'N') - goto yy424; - if (yych == 'n') - goto yy424; - goto yy31; - yy418: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy419: - yych = *++p; - if (yych == 'C') - goto yy423; - if (yych == 'c') - goto yy423; - goto yy31; - yy420: - yych = *++p; - if (yych <= 'V') { - if (yych == 'T') - goto yy422; - if (yych <= 'U') - goto yy31; - goto yy41; - } else { - if (yych <= 't') { - if (yych <= 's') - goto yy31; - goto yy422; - } else { - if (yych == 'v') - goto yy41; - goto yy31; - } - } - yy421: - yych = *++p; - if (yych == 'I') - goto yy41; - if (yych == 'i') - goto yy41; - goto yy31; - yy422: - yych = *++p; - if (yych == 'A') - goto yy41; - if (yych == 'a') - goto yy41; - goto yy31; - yy423: - yych = *++p; - if (yych == 'T') - goto yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy424: - yych = *++p; - if (yych == 'A') - goto yy425; - if (yych != 'a') - goto yy31; - yy425: - yych = *++p; - if (yych != '-') - goto yy31; - yych = *++p; - if (yych == 'P') - goto yy427; - if (yych != 'p') - goto yy31; - yy427: - yych = *++p; - if (yych == 'L') - goto yy428; - if (yych != 'l') - goto yy31; - yy428: - yych = *++p; - if (yych == 'A') - goto yy429; - if (yych != 'a') - goto yy31; - yy429: - yych = *++p; - if (yych == 'Y') - goto yy430; - if (yych != 'y') - goto yy31; - yy430: - yych = *++p; - if (yych <= 'S') { - if (yych == 'C') - goto yy431; - if (yych <= 'R') - goto yy31; - goto yy432; - } else { - if (yych <= 'c') { - if (yych <= 'b') - goto yy31; - } else { - if (yych == 's') - goto yy432; - goto yy31; - } - } - yy431: - yych = *++p; - if (yych == 'O') - goto yy437; - if (yych == 'o') - goto yy437; - goto yy31; - yy432: - yych = *++p; - if (yych == 'I') - goto yy433; - if (yych != 'i') - goto yy31; - yy433: - yych = *++p; - if (yych == 'N') - goto yy434; - if (yych != 'n') - goto yy31; - yy434: - yych = *++p; - if (yych == 'G') - goto yy435; - if (yych != 'g') - goto yy31; - yy435: - yych = *++p; - if (yych == 'L') - goto yy436; - if (yych != 'l') - goto yy31; - yy436: - yych = *++p; - if (yych == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - yy437: - yych = *++p; - if (yych == 'N') - goto yy438; - if (yych != 'n') - goto yy31; - yy438: - yych = *++p; - if (yych == 'T') - goto yy439; - if (yych != 't') - goto yy31; - yy439: - yych = *++p; - if (yych == 'A') - goto yy440; - if (yych != 'a') - goto yy31; - yy440: - yych = *++p; - if (yych == 'I') - goto yy441; - if (yych != 'i') - goto yy31; - yy441: - yych = *++p; - if (yych == 'N') - goto yy442; - if (yych != 'n') - goto yy31; - yy442: - yych = *++p; - if (yych == 'E') - goto yy443; - if (yych != 'e') - goto yy31; - yy443: - yych = *++p; - if (yych == 'R') - goto yy41; - if (yych == 'r') - goto yy41; - goto yy31; - yy444: - yych = *++p; - if (yych == 'S') - goto yy41; - if (yych == 's') - goto yy41; - goto yy31; - yy445: - yych = *++p; - if (yych <= 'N') { - if (yych <= 'A') { - if (yych <= '@') - goto yy31; - goto yy467; - } else { - if (yych <= 'L') - goto yy31; - if (yych <= 'M') - goto yy468; - goto yy469; - } - } else { - if (yych <= 'l') { - if (yych == 'a') - goto yy467; - goto yy31; - } else { - if (yych <= 'm') - goto yy468; - if (yych <= 'n') - goto yy469; - goto yy31; - } - } - yy446: - yych = *++p; - if (yych == 'R') - goto yy454; - if (yych == 'r') - goto yy454; - goto yy31; - yy447: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') - goto yy451; - if (yych <= 'O') - goto yy31; - goto yy41; - } else { - if (yych <= 'l') { - if (yych <= 'k') - goto yy31; - goto yy451; - } else { - if (yych == 'p') - goto yy41; - goto yy31; - } - } - yy448: - yych = *++p; - if (yych == 'I') - goto yy450; - if (yych == 'i') - goto yy450; - goto yy31; - yy449: - yych = *++p; - if (yych == 'D') - goto yy41; - if (yych == 'd') - goto yy41; - goto yy31; - yy450: - yych = *++p; - if (yych == 'D') - goto yy41; - if (yych == 'd') - goto yy41; - goto yy31; - yy451: - yych = *++p; - if (yych == 'L') - goto yy452; - if (yych != 'l') - goto yy31; - yy452: - yych = *++p; - if (yych == 'T') - goto yy453; - if (yych != 't') - goto yy31; - yy453: - yych = *++p; - if (yych == 'O') - goto yy41; - if (yych == 'o') - goto yy41; - goto yy31; - yy454: - yych = *++p; - if (yych == 'O') - goto yy455; - if (yych != 'o') - goto yy31; - yy455: - yych = *++p; - if (yych == 'M') - goto yy456; - if (yych != 'm') - goto yy31; - yy456: - yych = *++p; - if (yych == 'E') - goto yy457; - if (yych != 'e') - goto yy31; - yy457: - yych = *++p; - if (yych == '-') - goto yy458; - if (yych == ':') - goto yy42; - goto yy31; - yy458: - yych = *++p; - if (yych == 'E') - goto yy459; - if (yych != 'e') - goto yy31; - yy459: - yych = *++p; - if (yych == 'X') - goto yy460; - if (yych != 'x') - goto yy31; - yy460: - yych = *++p; - if (yych == 'T') - goto yy461; - if (yych != 't') - goto yy31; - yy461: - yych = *++p; - if (yych == 'E') - goto yy462; - if (yych != 'e') - goto yy31; - yy462: - yych = *++p; - if (yych == 'N') - goto yy463; - if (yych != 'n') - goto yy31; - yy463: - yych = *++p; - if (yych == 'S') - goto yy464; - if (yych != 's') - goto yy31; - yy464: - yych = *++p; - if (yych == 'I') - goto yy465; - if (yych != 'i') - goto yy31; - yy465: - yych = *++p; - if (yych == 'O') - goto yy466; - if (yych != 'o') - goto yy31; - yy466: - yych = *++p; - if (yych == 'N') - goto yy41; - if (yych == 'n') - goto yy41; - goto yy31; - yy467: - yych = *++p; - if (yych == 'P') - goto yy41; - if (yych == 'p') - goto yy41; - goto yy31; - yy468: - yych = *++p; - if (yych == '-') - goto yy473; - goto yy31; - yy469: - yych = *++p; - if (yych == 'T') - goto yy470; - if (yych != 't') - 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 yy41; - if (yych == 't') - goto yy41; - goto yy31; - yy473: - yych = *++p; - if (yych == 'E') - goto yy474; - if (yych != 'e') - goto yy31; - yy474: - yych = *++p; - if (yych == 'V') - goto yy475; - if (yych != 'v') - goto yy31; - yy475: - yych = *++p; - if (yych == 'E') - goto yy476; - if (yych != 'e') - goto yy31; - yy476: - yych = *++p; - if (yych == 'N') - goto yy477; - if (yych != 'n') - goto yy31; - yy477: - yych = *++p; - if (yych == 'T') - goto yy478; - if (yych != 't') - goto yy31; - yy478: - yych = *++p; - if (yych == 'B') - goto yy479; - if (yych != 'b') - goto yy31; - yy479: - yych = *++p; - if (yych == 'R') - goto yy480; - if (yych != 'r') - goto yy31; - yy480: - yych = *++p; - if (yych == 'I') - goto yy481; - if (yych != 'i') - 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 != '-') - goto yy31; - yych = *++p; - if (yych == 'A') - goto yy485; - if (yych != 'a') - goto yy31; - yy485: - yych = *++p; - if (yych == 'T') - goto yy486; - if (yych != 't') - goto yy31; - yy486: - yych = *++p; - if (yych == 'T') - goto yy487; - if (yych != 't') - goto yy31; - yy487: - yych = *++p; - if (yych == 'E') - goto yy488; - if (yych != 'e') - goto yy31; - yy488: - yych = *++p; - if (yych == 'N') - goto yy489; - if (yych != 'n') - goto yy31; - yy489: - yych = *++p; - if (yych == 'D') - goto yy490; - if (yych != 'd') - goto yy31; - yy490: - yych = *++p; - if (yych == 'E') - goto yy491; - if (yych != 'e') - goto yy31; - yy491: - ++p; - if ((yych = *p) == 'E') - goto yy41; - if (yych == 'e') - goto yy41; - goto yy31; - } -} - -// Try to match URI autolink after first <, returning number of chars matched. -bufsize_t _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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); - if (yych <= 'c') { - if (yych <= 'M') { - if (yych <= 'E') { - if (yych <= 'A') { - if (yych == '\n') - goto yy494; - if (yych <= '@') - goto yy521; - goto yy498; - } else { - if (yych <= 'B') - goto yy516; - if (yych <= 'C') - goto yy495; - if (yych <= 'D') - goto yy496; - goto yy517; - } - } else { - if (yych <= 'I') { - if (yych <= 'F') - goto yy499; - if (yych <= 'G') - goto yy500; - if (yych <= 'H') - goto yy501; - goto yy502; - } else { - if (yych <= 'J') - goto yy497; - if (yych <= 'K') - goto yy518; - if (yych <= 'L') - goto yy503; - goto yy504; - } - } - } else { - if (yych <= 'U') { - if (yych <= 'Q') { - if (yych <= 'N') - goto yy505; - if (yych <= 'O') - goto yy506; - if (yych <= 'P') - goto yy507; - goto yy519; - } else { - if (yych <= 'R') - goto yy508; - if (yych <= 'S') - goto yy509; - if (yych <= 'T') - goto yy510; - goto yy511; - } - } else { - if (yych <= 'Y') { - if (yych <= 'V') - goto yy512; - if (yych <= 'W') - goto yy513; - if (yych <= 'X') - goto yy514; - goto yy520; - } else { - if (yych <= '`') { - if (yych <= 'Z') - goto yy515; - goto yy521; - } else { - if (yych <= 'a') - goto yy498; - if (yych <= 'b') - goto yy516; - goto yy495; - } - } - } - } - } else { - if (yych <= 't') { - if (yych <= 'k') { - if (yych <= 'g') { - if (yych <= 'd') - goto yy496; - if (yych <= 'e') - goto yy517; - if (yych <= 'f') - goto yy499; - goto yy500; - } else { - if (yych <= 'h') - goto yy501; - if (yych <= 'i') - goto yy502; - if (yych <= 'j') - goto yy497; - goto yy518; - } - } else { - if (yych <= 'o') { - if (yych <= 'l') - goto yy503; - if (yych <= 'm') - goto yy504; - if (yych <= 'n') - goto yy505; - goto yy506; - } else { - if (yych <= 'q') { - if (yych <= 'p') - goto yy507; - goto yy519; - } else { - if (yych <= 'r') - goto yy508; - if (yych <= 's') - goto yy509; - goto yy510; - } - } - } - } else { - if (yych <= 0xC1) { - if (yych <= 'x') { - if (yych <= 'u') - goto yy511; - if (yych <= 'v') - goto yy512; - if (yych <= 'w') - goto yy513; - goto yy514; - } else { - if (yych <= 'y') - goto yy520; - if (yych <= 'z') - goto yy515; - if (yych <= 0x7F) - goto yy521; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy522; - if (yych <= 0xE0) - goto yy524; - if (yych <= 0xEC) - goto yy525; - goto yy529; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy525; - goto yy526; - } else { - if (yych <= 0xF3) - goto yy527; - if (yych <= 0xF4) - goto yy528; - } - } - } - } - } - yy494 : { return 0; } - yy495: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy948; - case 'H': - case 'h': - goto yy947; - case 'I': - case 'i': - goto yy950; - case 'O': - case 'o': - goto yy946; - case 'R': - case 'r': - goto yy949; - case 'V': - case 'v': - goto yy945; - default: - goto yy494; - } - yy496: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy921; - case 'I': - case 'i': - goto yy920; - case 'L': - case 'l': - goto yy918; - case 'N': - case 'n': - goto yy919; - case 'O': - case 'o': - goto yy922; - case 'T': - case 't': - goto yy917; - case 'V': - case 'v': - goto yy916; - default: - goto yy494; - } - yy497: - yych = *(marker = ++p); - if (yych <= 'M') { - if (yych == 'A') - goto yy908; - if (yych <= 'L') - goto yy494; - goto yy907; - } else { - if (yych <= 'a') { - if (yych <= '`') - goto yy494; - goto yy908; - } else { - if (yych == 'm') - goto yy907; - goto yy494; - } - } - yy498: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy889; - case 'B': - case 'b': - goto yy888; - case 'C': - case 'c': - goto yy887; - case 'D': - case 'd': - goto yy886; - case 'F': - case 'f': - goto yy885; - case 'I': - case 'i': - goto yy884; - case 'P': - case 'p': - goto yy883; - case 'T': - case 't': - goto yy882; - case 'W': - case 'w': - goto yy533; - default: - goto yy494; - } - yy499: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'E') { - if (yych == 'A') - goto yy869; - if (yych <= 'D') - goto yy494; - goto yy868; - } else { - if (yych == 'I') - goto yy867; - if (yych <= 'S') - goto yy494; - goto yy870; - } - } else { - if (yych <= 'e') { - if (yych == 'a') - goto yy869; - if (yych <= 'd') - goto yy494; - goto yy868; - } else { - if (yych <= 'i') { - if (yych <= 'h') - goto yy494; - goto yy867; - } else { - if (yych == 't') - goto yy870; - goto yy494; - } - } - } - yy500: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': - goto yy852; - case 'G': - case 'g': - goto yy533; - case 'I': - case 'i': - goto yy850; - case 'O': - case 'o': - goto yy851; - case 'T': - case 't': - goto yy849; - default: - goto yy494; - } - yy501: - yych = *(marker = ++p); - if (yych <= 'S') { - if (yych <= '3') { - if (yych <= '2') - goto yy494; - goto yy845; - } else { - if (yych == 'C') - goto yy843; - goto yy494; - } - } else { - if (yych <= 'c') { - if (yych <= 'T') - goto yy844; - if (yych <= 'b') - goto yy494; - goto yy843; - } else { - if (yych == 't') - goto yy844; - goto yy494; - } - } - yy502: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy825; - case 'C': - case 'c': - goto yy822; - case 'M': - case 'm': - goto yy824; - case 'N': - case 'n': - goto yy823; - case 'P': - case 'p': - goto yy821; - case 'R': - case 'r': - goto yy820; - case 'T': - case 't': - goto yy819; - default: - goto yy494; - } - yy503: - yych = *(marker = ++p); - if (yych <= 'D') { - if (yych == 'A') - goto yy813; - if (yych <= 'C') - goto yy494; - goto yy812; - } else { - if (yych <= 'a') { - if (yych <= '`') - goto yy494; - goto yy813; - } else { - if (yych == 'd') - goto yy812; - goto yy494; - } - } - yy504: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy779; - case 'E': - case 'e': - goto yy778; - case 'I': - case 'i': - goto yy781; - case 'M': - case 'm': - goto yy777; - case 'S': - case 's': - goto yy776; - case 'T': - case 't': - goto yy780; - case 'U': - case 'u': - goto yy775; - case 'V': - case 'v': - goto yy774; - default: - goto yy494; - } - yy505: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': - goto yy769; - case 'F': - case 'f': - goto yy768; - case 'I': - case 'i': - goto yy767; - case 'N': - case 'n': - goto yy766; - case 'O': - case 'o': - goto yy765; - default: - goto yy494; - } - yy506: - yych = *(marker = ++p); - if (yych <= 'P') { - if (yych == 'I') - goto yy751; - if (yych <= 'O') - goto yy494; - goto yy752; - } else { - if (yych <= 'i') { - if (yych <= 'h') - goto yy494; - goto yy751; - } else { - if (yych == 'p') - goto yy752; - goto yy494; - } - } - yy507: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy733; - case 'L': - case 'l': - goto yy732; - case 'O': - case 'o': - goto yy734; - case 'R': - case 'r': - goto yy731; - case 'S': - case 's': - goto yy730; - default: - goto yy494; - } - yy508: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'L') { - if (yych == 'E') - goto yy720; - goto yy494; - } else { - if (yych <= 'M') - goto yy719; - if (yych <= 'R') - goto yy494; - if (yych <= 'S') - goto yy718; - goto yy717; - } - } else { - if (yych <= 'm') { - if (yych == 'e') - goto yy720; - if (yych <= 'l') - goto yy494; - goto yy719; - } else { - if (yych <= 'r') - goto yy494; - if (yych <= 's') - goto yy718; - if (yych <= 't') - goto yy717; - goto yy494; - } - } - yy509: - yych = *(marker = ++p); - switch (yych) { - case 'E': - case 'e': - goto yy673; - case 'F': - case 'f': - goto yy672; - case 'G': - case 'g': - goto yy671; - case 'H': - case 'h': - goto yy676; - case 'I': - case 'i': - goto yy675; - case 'K': - case 'k': - goto yy670; - case 'M': - case 'm': - goto yy669; - case 'N': - case 'n': - goto yy674; - case 'O': - case 'o': - goto yy668; - case 'P': - case 'p': - goto yy667; - case 'S': - case 's': - goto yy666; - case 'T': - case 't': - goto yy665; - case 'V': - case 'v': - goto yy664; - default: - goto yy494; - } - yy510: - yych = *(marker = ++p); - switch (yych) { - case 'A': - case 'a': - goto yy640; - case 'E': - case 'e': - goto yy636; - case 'F': - case 'f': - goto yy639; - case 'H': - case 'h': - goto yy635; - case 'I': - case 'i': - goto yy637; - case 'N': - case 'n': - goto yy638; - case 'V': - case 'v': - goto yy533; - default: - goto yy494; - } - yy511: - yych = *(marker = ++p); - if (yych <= 'T') { - if (yych <= 'N') { - if (yych == 'D') - goto yy627; - if (yych <= 'M') - goto yy494; - goto yy626; - } else { - if (yych == 'R') - goto yy628; - if (yych <= 'S') - goto yy494; - goto yy625; - } - } else { - if (yych <= 'n') { - if (yych == 'd') - goto yy627; - if (yych <= 'm') - goto yy494; - goto yy626; - } else { - if (yych <= 'r') { - if (yych <= 'q') - goto yy494; - goto yy628; - } else { - if (yych == 't') - goto yy625; - goto yy494; - } - } - } - yy512: - yych = *(marker = ++p); - if (yych <= 'I') { - if (yych == 'E') - goto yy609; - if (yych <= 'H') - goto yy494; - goto yy608; - } else { - if (yych <= 'e') { - if (yych <= 'd') - goto yy494; - goto yy609; - } else { - if (yych == 'i') - goto yy608; - goto yy494; - } - } - yy513: - yych = *(marker = ++p); - if (yych <= 'Y') { - if (yych <= 'R') { - if (yych == 'E') - goto yy598; - goto yy494; - } else { - if (yych <= 'S') - goto yy599; - if (yych <= 'T') - goto yy597; - if (yych <= 'X') - goto yy494; - goto yy596; - } - } else { - if (yych <= 's') { - if (yych == 'e') - goto yy598; - if (yych <= 'r') - goto yy494; - goto yy599; - } else { - if (yych <= 't') - goto yy597; - if (yych == 'y') - goto yy596; - goto yy494; - } - } - yy514: - yych = *(marker = ++p); - if (yych <= 'R') { - if (yych <= 'F') { - if (yych == 'C') - goto yy575; - if (yych <= 'E') - goto yy494; - goto yy573; - } else { - if (yych == 'M') - goto yy574; - if (yych <= 'Q') - goto yy494; - goto yy572; - } - } else { - if (yych <= 'f') { - if (yych == 'c') - goto yy575; - if (yych <= 'e') - goto yy494; - goto yy573; - } else { - if (yych <= 'm') { - if (yych <= 'l') - goto yy494; - goto yy574; - } else { - if (yych == 'r') - goto yy572; - goto yy494; - } - } - } - yy515: - yych = *(marker = ++p); - if (yych == '3') - goto yy567; - goto yy494; - yy516: - yych = *(marker = ++p); - if (yych <= 'O') { - if (yych <= 'H') { - if (yych == 'E') - goto yy557; - goto yy494; - } else { - if (yych <= 'I') - goto yy556; - if (yych <= 'N') - goto yy494; - goto yy555; - } - } else { - if (yych <= 'h') { - if (yych == 'e') - goto yy557; - goto yy494; - } else { - if (yych <= 'i') - goto yy556; - if (yych == 'o') - goto yy555; - goto yy494; - } - } - yy517: - yych = *(marker = ++p); - if (yych == 'D') - goto yy553; - if (yych == 'd') - goto yy553; - goto yy494; - yy518: - yych = *(marker = ++p); - if (yych == 'E') - goto yy548; - if (yych == 'e') - goto yy548; - goto yy494; - yy519: - yych = *(marker = ++p); - if (yych == 'U') - goto yy545; - if (yych == 'u') - goto yy545; - goto yy494; - yy520: - yych = *(marker = ++p); - if (yych == 'M') - goto yy530; - if (yych == 'm') - goto yy530; - goto yy494; - yy521: - yych = *++p; - goto yy494; - yy522: - yych = *++p; - if (yych <= 0x7F) - goto yy523; - if (yych <= 0xBF) - goto yy521; - yy523: - p = marker; - goto yy494; - yy524: - yych = *++p; - if (yych <= 0x9F) - goto yy523; - if (yych <= 0xBF) - goto yy522; - goto yy523; - yy525: - yych = *++p; - if (yych <= 0x7F) - goto yy523; - if (yych <= 0xBF) - goto yy522; - goto yy523; - yy526: - yych = *++p; - if (yych <= 0x8F) - goto yy523; - if (yych <= 0xBF) - goto yy525; - goto yy523; - yy527: - yych = *++p; - if (yych <= 0x7F) - goto yy523; - if (yych <= 0xBF) - goto yy525; - goto yy523; - yy528: - yych = *++p; - if (yych <= 0x7F) - goto yy523; - if (yych <= 0x8F) - goto yy525; - goto yy523; - yy529: - yych = *++p; - if (yych <= 0x7F) - goto yy523; - if (yych <= 0x9F) - goto yy522; - goto yy523; - yy530: - yych = *++p; - if (yych == 'S') - goto yy531; - if (yych != 's') - goto yy523; - yy531: - yych = *++p; - if (yych == 'G') - goto yy532; - if (yych != 'g') - goto yy523; - yy532: - yych = *++p; - if (yych == 'R') - goto yy533; - if (yych != 'r') - goto yy523; - yy533: - yych = *++p; - if (yych != ':') - goto yy523; - yy534: - ++p; - yych = *p; - if (yybm[0 + yych] & 128) { - goto yy534; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '<') - goto yy523; - if (yych <= '>') - goto yy543; - goto yy523; - } else { - if (yych <= 0xDF) - goto yy536; - if (yych <= 0xE0) - goto yy537; - goto yy538; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy542; - if (yych <= 0xEF) - goto yy538; - goto yy539; - } else { - if (yych <= 0xF3) - goto yy540; - if (yych <= 0xF4) - goto yy541; - goto yy523; - } - } - yy536: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy523; - if (yych <= 0xBF) - goto yy534; - goto yy523; - yy537: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy523; - if (yych <= 0xBF) - goto yy536; - goto yy523; - yy538: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy523; - if (yych <= 0xBF) - goto yy536; - goto yy523; - yy539: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy523; - if (yych <= 0xBF) - goto yy538; - goto yy523; - yy540: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy523; - if (yych <= 0xBF) - goto yy538; - goto yy523; - yy541: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy523; - if (yych <= 0x8F) - goto yy538; - goto yy523; - yy542: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy523; - if (yych <= 0x9F) - goto yy536; - goto yy523; - yy543: - ++p; - { return (bufsize_t)(p - start); } - yy545: - yych = *++p; - if (yych == 'E') - goto yy546; - if (yych != 'e') - goto yy523; - yy546: - yych = *++p; - if (yych == 'R') - goto yy547; - if (yych != 'r') - goto yy523; - yy547: - yych = *++p; - if (yych == 'Y') - goto yy533; - if (yych == 'y') - goto yy533; - goto yy523; - yy548: - yych = *++p; - if (yych == 'Y') - goto yy549; - if (yych != 'y') - goto yy523; - yy549: - yych = *++p; - if (yych == 'P') - goto yy550; - if (yych != 'p') - goto yy523; - yy550: - yych = *++p; - if (yych == 'A') - goto yy551; - if (yych != 'a') - goto yy523; - yy551: - yych = *++p; - if (yych == 'R') - goto yy552; - if (yych != 'r') - goto yy523; - yy552: - yych = *++p; - if (yych == 'C') - goto yy533; - if (yych == 'c') - goto yy533; - goto yy523; - yy553: - yych = *++p; - if (yych != '2') - goto yy523; - yych = *++p; - if (yych == 'K') - goto yy533; - if (yych == 'k') - goto yy533; - goto yy523; - yy555: - yych = *++p; - if (yych == 'L') - goto yy566; - if (yych == 'l') - goto yy566; - goto yy523; - yy556: - yych = *++p; - if (yych == 'T') - goto yy562; - if (yych == 't') - goto yy562; - goto yy523; - yy557: - yych = *++p; - if (yych == 'S') - goto yy558; - if (yych != 's') - goto yy523; - yy558: - yych = *++p; - if (yych == 'H') - goto yy559; - if (yych != 'h') - goto yy523; - yy559: - yych = *++p; - if (yych == 'A') - goto yy560; - if (yych != 'a') - goto yy523; - yy560: - yych = *++p; - if (yych == 'R') - goto yy561; - if (yych != 'r') - goto yy523; - yy561: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy562: - yych = *++p; - if (yych == 'C') - goto yy563; - if (yych != 'c') - goto yy523; - yy563: - yych = *++p; - if (yych == 'O') - goto yy564; - if (yych != 'o') - goto yy523; - yy564: - yych = *++p; - if (yych == 'I') - goto yy565; - if (yych != 'i') - goto yy523; - yy565: - yych = *++p; - if (yych == 'N') - goto yy533; - if (yych == 'n') - goto yy533; - goto yy523; - yy566: - yych = *++p; - if (yych == 'O') - goto yy533; - if (yych == 'o') - goto yy533; - goto yy523; - yy567: - yych = *++p; - if (yych != '9') - goto yy523; - yych = *++p; - if (yych != '.') - goto yy523; - yych = *++p; - if (yych != '5') - goto yy523; - yych = *++p; - if (yych != '0') - goto yy523; - yych = *++p; - if (yych <= 'Q') - goto yy523; - if (yych <= 'S') - goto yy533; - if (yych <= 'q') - goto yy523; - if (yych <= 's') - goto yy533; - goto yy523; - yy572: - yych = *++p; - if (yych == 'I') - goto yy533; - if (yych == 'i') - goto yy533; - goto yy523; - yy573: - yych = *++p; - if (yych == 'I') - goto yy594; - if (yych == 'i') - goto yy594; - goto yy523; - yy574: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') - goto yy584; - if (yych <= 'O') - goto yy523; - goto yy585; - } else { - if (yych <= 'l') { - if (yych <= 'k') - goto yy523; - goto yy584; - } else { - if (yych == 'p') - goto yy585; - goto yy523; - } - } - yy575: - yych = *++p; - if (yych == 'O') - goto yy576; - if (yych != 'o') - goto yy523; - yy576: - yych = *++p; - if (yych == 'N') - goto yy577; - if (yych != 'n') - goto yy523; - yy577: - yych = *++p; - if (yych == '-') - goto yy578; - if (yych == ':') - goto yy534; - goto yy523; - yy578: - yych = *++p; - if (yych == 'U') - goto yy579; - if (yych != 'u') - goto yy523; - yy579: - yych = *++p; - if (yych == 'S') - goto yy580; - if (yych != 's') - goto yy523; - yy580: - yych = *++p; - if (yych == 'E') - goto yy581; - if (yych != 'e') - goto yy523; - yy581: - yych = *++p; - if (yych == 'R') - goto yy582; - if (yych != 'r') - goto yy523; - yy582: - yych = *++p; - if (yych == 'I') - goto yy583; - if (yych != 'i') - goto yy523; - yy583: - yych = *++p; - if (yych == 'D') - goto yy533; - if (yych == 'd') - goto yy533; - goto yy523; - yy584: - yych = *++p; - if (yych == 'R') - goto yy586; - if (yych == 'r') - goto yy586; - goto yy523; - yy585: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy586: - yych = *++p; - if (yych == 'P') - goto yy587; - if (yych != 'p') - goto yy523; - yy587: - yych = *++p; - if (yych == 'C') - goto yy588; - if (yych != 'c') - goto yy523; - yy588: - yych = *++p; - if (yych != '.') - goto yy523; - yych = *++p; - if (yych == 'B') - goto yy590; - if (yych != 'b') - goto yy523; - yy590: - yych = *++p; - if (yych == 'E') - goto yy591; - if (yych != 'e') - goto yy523; - yy591: - yych = *++p; - if (yych == 'E') - goto yy592; - if (yych != 'e') - goto yy523; - yy592: - yych = *++p; - if (yych == 'P') - goto yy593; - if (yych != 'p') - goto yy523; - yy593: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - } - yy594: - yych = *++p; - if (yych == 'R') - goto yy595; - if (yych != 'r') - goto yy523; - yy595: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy596: - yych = *++p; - if (yych == 'C') - goto yy604; - if (yych == 'c') - goto yy604; - goto yy523; - yy597: - yych = *++p; - if (yych == 'A') - goto yy603; - if (yych == 'a') - goto yy603; - goto yy523; - yy598: - yych = *++p; - if (yych == 'B') - goto yy600; - if (yych == 'b') - goto yy600; - goto yy523; - yy599: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - } - yy600: - yych = *++p; - if (yych == 'C') - goto yy601; - if (yych != 'c') - goto yy523; - yy601: - yych = *++p; - if (yych == 'A') - goto yy602; - if (yych != 'a') - goto yy523; - yy602: - yych = *++p; - if (yych == 'L') - goto yy533; - if (yych == 'l') - goto yy533; - goto yy523; - yy603: - yych = *++p; - if (yych == 'I') - goto yy533; - if (yych == 'i') - goto yy533; - goto yy523; - yy604: - yych = *++p; - if (yych == 'I') - goto yy605; - if (yych != 'i') - goto yy523; - yy605: - yych = *++p; - if (yych == 'W') - goto yy606; - if (yych != 'w') - goto yy523; - yy606: - yych = *++p; - if (yych == 'Y') - goto yy607; - if (yych != 'y') - goto yy523; - yy607: - yych = *++p; - if (yych == 'G') - goto yy533; - if (yych == 'g') - goto yy533; - goto yy523; - yy608: - yych = *++p; - if (yych == 'E') - goto yy617; - if (yych == 'e') - goto yy617; - goto yy523; - yy609: - yych = *++p; - if (yych <= 'N') { - if (yych <= 'L') - goto yy523; - if (yych >= 'N') - goto yy611; - } else { - if (yych <= 'l') - goto yy523; - if (yych <= 'm') - goto yy610; - if (yych <= 'n') - goto yy611; - goto yy523; - } - yy610: - yych = *++p; - if (yych == 'M') - goto yy616; - if (yych == 'm') - goto yy616; - goto yy523; - yy611: - yych = *++p; - if (yych == 'T') - goto yy612; - if (yych != 't') - goto yy523; - yy612: - yych = *++p; - if (yych == 'R') - goto yy613; - if (yych != 'r') - goto yy523; - yy613: - yych = *++p; - if (yych == 'I') - goto yy614; - if (yych != 'i') - goto yy523; - yy614: - yych = *++p; - if (yych == 'L') - goto yy615; - if (yych != 'l') - goto yy523; - yy615: - yych = *++p; - if (yych == 'O') - goto yy533; - if (yych == 'o') - goto yy533; - goto yy523; - yy616: - yych = *++p; - if (yych == 'I') - goto yy533; - if (yych == 'i') - goto yy533; - goto yy523; - yy617: - yych = *++p; - if (yych == 'W') - goto yy618; - if (yych != 'w') - goto yy523; - yy618: - yych = *++p; - if (yych != '-') - goto yy523; - yych = *++p; - if (yych == 'S') - goto yy620; - if (yych != 's') - goto yy523; - yy620: - yych = *++p; - if (yych == 'O') - goto yy621; - if (yych != 'o') - goto yy523; - yy621: - yych = *++p; - if (yych == 'U') - goto yy622; - if (yych != 'u') - goto yy523; - yy622: - yych = *++p; - if (yych == 'R') - goto yy623; - if (yych != 'r') - goto yy523; - yy623: - yych = *++p; - if (yych == 'C') - goto yy624; - if (yych != 'c') - goto yy523; - yy624: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy625: - yych = *++p; - if (yych == '2') - goto yy632; - goto yy523; - yy626: - yych = *++p; - if (yych == 'R') - goto yy629; - if (yych == 'r') - goto yy629; - goto yy523; - yy627: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy628: - yych = *++p; - if (yych == 'N') - goto yy533; - if (yych == 'n') - goto yy533; - goto yy523; - yy629: - yych = *++p; - if (yych == 'E') - goto yy630; - if (yych != 'e') - goto yy523; - yy630: - yych = *++p; - if (yych == 'A') - goto yy631; - if (yych != 'a') - goto yy523; - yy631: - yych = *++p; - if (yych == 'L') - goto yy533; - if (yych == 'l') - goto yy533; - goto yy523; - yy632: - yych = *++p; - if (yych != '0') - goto yy523; - yych = *++p; - if (yych != '0') - goto yy523; - yych = *++p; - if (yych == '4') - goto yy533; - goto yy523; - yy635: - yych = *++p; - if (yych == 'I') - goto yy654; - if (yych == 'i') - goto yy654; - goto yy523; - yy636: - yych = *++p; - if (yych <= 'L') { - if (yych == 'A') - goto yy646; - if (yych <= 'K') - goto yy523; - goto yy645; - } else { - if (yych <= 'a') { - if (yych <= '`') - goto yy523; - goto yy646; - } else { - if (yych == 'l') - goto yy645; - goto yy523; - } - } - yy637: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy638: - yych = *++p; - if (yych == '3') - goto yy642; - goto yy523; - yy639: - yych = *++p; - if (yych == 'T') - goto yy641; - if (yych == 't') - goto yy641; - goto yy523; - yy640: - yych = *++p; - if (yych == 'G') - goto yy533; - if (yych == 'g') - goto yy533; - goto yy523; - yy641: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy642: - yych = *++p; - if (yych != '2') - goto yy523; - yych = *++p; - if (yych != '7') - goto yy523; - yych = *++p; - if (yych == '0') - goto yy533; - goto yy523; - yy645: - yych = *++p; - if (yych <= 'M') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'N') - goto yy652; - if (yych == 'n') - goto yy652; - goto yy523; - } - yy646: - yych = *++p; - if (yych == 'M') - goto yy647; - if (yych != 'm') - goto yy523; - yy647: - yych = *++p; - if (yych == 'S') - goto yy648; - if (yych != 's') - goto yy523; - yy648: - yych = *++p; - if (yych == 'P') - goto yy649; - if (yych != 'p') - goto yy523; - yy649: - yych = *++p; - if (yych == 'E') - goto yy650; - if (yych != 'e') - goto yy523; - yy650: - yych = *++p; - if (yych == 'A') - goto yy651; - if (yych != 'a') - goto yy523; - yy651: - yych = *++p; - if (yych == 'K') - goto yy533; - if (yych == 'k') - goto yy533; - goto yy523; - yy652: - yych = *++p; - if (yych == 'E') - goto yy653; - if (yych != 'e') - goto yy523; - yy653: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy654: - yych = *++p; - if (yych <= 'S') { - if (yych == 'N') - goto yy655; - if (yych <= 'R') - goto yy523; - goto yy656; - } else { - if (yych <= 'n') { - if (yych <= 'm') - goto yy523; - } else { - if (yych == 's') - goto yy656; - goto yy523; - } - } - yy655: - yych = *++p; - if (yych == 'G') - goto yy663; - if (yych == 'g') - goto yy663; - goto yy523; - yy656: - yych = *++p; - if (yych == 'M') - goto yy657; - if (yych != 'm') - goto yy523; - yy657: - yych = *++p; - if (yych == 'E') - goto yy658; - if (yych != 'e') - goto yy523; - yy658: - yych = *++p; - if (yych == 'S') - goto yy659; - if (yych != 's') - goto yy523; - yy659: - yych = *++p; - if (yych == 'S') - goto yy660; - if (yych != 's') - goto yy523; - yy660: - yych = *++p; - if (yych == 'A') - goto yy661; - if (yych != 'a') - goto yy523; - yy661: - yych = *++p; - if (yych == 'G') - goto yy662; - if (yych != 'g') - goto yy523; - yy662: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy663: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy664: - yych = *++p; - if (yych == 'N') - goto yy533; - if (yych == 'n') - goto yy533; - goto yy523; - yy665: - yych = *++p; - if (yych == 'E') - goto yy715; - if (yych == 'e') - goto yy715; - goto yy523; - yy666: - yych = *++p; - if (yych == 'H') - goto yy533; - if (yych == 'h') - goto yy533; - goto yy523; - yy667: - yych = *++p; - if (yych == 'O') - goto yy711; - if (yych == 'o') - goto yy711; - goto yy523; - yy668: - yych = *++p; - if (yych <= 'L') { - if (yych == 'A') - goto yy701; - if (yych <= 'K') - goto yy523; - goto yy702; - } else { - if (yych <= 'a') { - if (yych <= '`') - goto yy523; - goto yy701; - } else { - if (yych == 'l') - goto yy702; - goto yy523; - } - } - yy669: - yych = *++p; - if (yych <= 'S') { - if (yych == 'B') - goto yy533; - if (yych <= 'R') - goto yy523; - goto yy533; - } else { - if (yych <= 'b') { - if (yych <= 'a') - goto yy523; - goto yy533; - } else { - if (yych == 's') - goto yy533; - goto yy523; - } - } - yy670: - yych = *++p; - if (yych == 'Y') - goto yy699; - if (yych == 'y') - goto yy699; - goto yy523; - yy671: - yych = *++p; - if (yych == 'N') - goto yy533; - if (yych == 'n') - goto yy533; - goto yy523; - yy672: - yych = *++p; - if (yych == 'T') - goto yy698; - if (yych == 't') - goto yy698; - goto yy523; - yy673: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'C') { - if (yych <= 'B') - goto yy523; - goto yy685; - } else { - if (yych <= 'Q') - goto yy523; - if (yych <= 'R') - goto yy683; - goto yy684; - } - } else { - if (yych <= 'q') { - if (yych == 'c') - goto yy685; - goto yy523; - } else { - if (yych <= 'r') - goto yy683; - if (yych <= 's') - goto yy684; - goto yy523; - } - } - yy674: - yych = *++p; - if (yych == 'M') - goto yy682; - if (yych == 'm') - goto yy682; - goto yy523; - yy675: - yych = *++p; - if (yych <= 'P') { - if (yych == 'E') - goto yy679; - if (yych <= 'O') - goto yy523; - goto yy680; - } else { - if (yych <= 'e') { - if (yych <= 'd') - goto yy523; - goto yy679; - } else { - if (yych == 'p') - goto yy680; - goto yy523; - } - } - yy676: - yych = *++p; - if (yych == 'T') - goto yy677; - if (yych != 't') - goto yy523; - yy677: - yych = *++p; - if (yych == 'T') - goto yy678; - if (yych != 't') - goto yy523; - yy678: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy679: - yych = *++p; - if (yych == 'V') - goto yy681; - if (yych == 'v') - goto yy681; - goto yy523; - yy680: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - } - yy681: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy682: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy683: - yych = *++p; - if (yych == 'V') - goto yy695; - if (yych == 'v') - goto yy695; - goto yy523; - yy684: - yych = *++p; - if (yych == 'S') - goto yy692; - if (yych == 's') - goto yy692; - goto yy523; - yy685: - yych = *++p; - if (yych == 'O') - goto yy686; - if (yych != 'o') - goto yy523; - yy686: - yych = *++p; - if (yych == 'N') - goto yy687; - if (yych != 'n') - goto yy523; - yy687: - yych = *++p; - if (yych == 'D') - goto yy688; - if (yych != 'd') - goto yy523; - yy688: - yych = *++p; - if (yych == 'L') - goto yy689; - if (yych != 'l') - goto yy523; - yy689: - yych = *++p; - if (yych == 'I') - goto yy690; - if (yych != 'i') - goto yy523; - yy690: - yych = *++p; - if (yych == 'F') - goto yy691; - if (yych != 'f') - goto yy523; - yy691: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy692: - yych = *++p; - if (yych == 'I') - goto yy693; - if (yych != 'i') - goto yy523; - yy693: - yych = *++p; - if (yych == 'O') - goto yy694; - if (yych != 'o') - goto yy523; - yy694: - yych = *++p; - if (yych == 'N') - goto yy533; - if (yych == 'n') - goto yy533; - goto yy523; - yy695: - yych = *++p; - if (yych == 'I') - goto yy696; - if (yych != 'i') - goto yy523; - yy696: - yych = *++p; - if (yych == 'C') - goto yy697; - if (yych != 'c') - goto yy523; - yy697: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy698: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy699: - yych = *++p; - if (yych == 'P') - goto yy700; - if (yych != 'p') - goto yy523; - yy700: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy701: - yych = *++p; - if (yych == 'P') - goto yy705; - if (yych == 'p') - goto yy705; - goto yy523; - yy702: - yych = *++p; - if (yych == 'D') - goto yy703; - if (yych != 'd') - goto yy523; - yy703: - yych = *++p; - if (yych == 'A') - goto yy704; - if (yych != 'a') - goto yy523; - yy704: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy705: - yych = *++p; - if (yych != '.') - goto yy523; - yych = *++p; - if (yych == 'B') - goto yy707; - if (yych != 'b') - goto yy523; - yy707: - yych = *++p; - if (yych == 'E') - goto yy708; - if (yych != 'e') - goto yy523; - yy708: - yych = *++p; - if (yych == 'E') - goto yy709; - if (yych != 'e') - goto yy523; - yy709: - yych = *++p; - if (yych == 'P') - goto yy710; - if (yych != 'p') - goto yy523; - yy710: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - } - yy711: - yych = *++p; - if (yych == 'T') - goto yy712; - if (yych != 't') - goto yy523; - yy712: - yych = *++p; - if (yych == 'I') - goto yy713; - if (yych != 'i') - goto yy523; - yy713: - yych = *++p; - if (yych == 'F') - goto yy714; - if (yych != 'f') - goto yy523; - yy714: - yych = *++p; - if (yych == 'Y') - goto yy533; - if (yych == 'y') - goto yy533; - goto yy523; - yy715: - yych = *++p; - if (yych == 'A') - goto yy716; - if (yych != 'a') - goto yy523; - yy716: - yych = *++p; - if (yych == 'M') - goto yy533; - if (yych == 'm') - goto yy533; - goto yy523; - yy717: - yych = *++p; - if (yych <= 'S') { - if (yych == 'M') - goto yy729; - if (yych <= 'R') - goto yy523; - goto yy728; - } else { - if (yych <= 'm') { - if (yych <= 'l') - goto yy523; - goto yy729; - } else { - if (yych == 's') - goto yy728; - goto yy523; - } - } - yy718: - yych = *++p; - if (yych == 'Y') - goto yy726; - if (yych == 'y') - goto yy726; - goto yy523; - yy719: - yych = *++p; - if (yych == 'I') - goto yy533; - if (yych == 'i') - goto yy533; - goto yy523; - yy720: - yych = *++p; - if (yych == 'S') - goto yy721; - if (yych != 's') - goto yy523; - yy721: - yych = *++p; - if (yych <= 'N') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'O') - goto yy722; - if (yych != 'o') - goto yy523; - } - yy722: - yych = *++p; - if (yych == 'U') - goto yy723; - if (yych != 'u') - goto yy523; - yy723: - yych = *++p; - if (yych == 'R') - goto yy724; - if (yych != 'r') - goto yy523; - yy724: - yych = *++p; - if (yych == 'C') - goto yy725; - if (yych != 'c') - goto yy523; - yy725: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy726: - yych = *++p; - if (yych == 'N') - goto yy727; - if (yych != 'n') - goto yy523; - yy727: - yych = *++p; - if (yych == 'C') - goto yy533; - if (yych == 'c') - goto yy533; - goto yy523; - yy728: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy729: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy730: - yych = *++p; - if (yych == 'Y') - goto yy750; - if (yych == 'y') - goto yy750; - goto yy523; - yy731: - yych = *++p; - if (yych <= 'O') { - if (yych == 'E') - goto yy747; - if (yych <= 'N') - goto yy523; - goto yy748; - } else { - if (yych <= 'e') { - if (yych <= 'd') - goto yy523; - goto yy747; - } else { - if (yych == 'o') - goto yy748; - goto yy523; - } - } - yy732: - yych = *++p; - if (yych == 'A') - goto yy742; - if (yych == 'a') - goto yy742; - goto yy523; - yy733: - yych = *++p; - if (yych <= 'P') { - if (yych == 'L') - goto yy735; - if (yych <= 'O') - goto yy523; - goto yy736; - } else { - if (yych <= 'l') { - if (yych <= 'k') - goto yy523; - goto yy735; - } else { - if (yych == 'p') - goto yy736; - goto yy523; - } - } - yy734: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy735: - yych = *++p; - if (yych == 'M') - goto yy533; - if (yych == 'm') - goto yy533; - goto yy523; - yy736: - yych = *++p; - if (yych == 'A') - goto yy737; - if (yych != 'a') - goto yy523; - yy737: - yych = *++p; - if (yych == 'R') - goto yy738; - if (yych != 'r') - goto yy523; - yy738: - yych = *++p; - if (yych == 'A') - goto yy739; - if (yych != 'a') - goto yy523; - yy739: - yych = *++p; - if (yych == 'Z') - goto yy740; - if (yych != 'z') - goto yy523; - yy740: - yych = *++p; - if (yych == 'Z') - goto yy741; - if (yych != 'z') - goto yy523; - yy741: - yych = *++p; - if (yych == 'I') - goto yy533; - if (yych == 'i') - goto yy533; - goto yy523; - yy742: - yych = *++p; - if (yych == 'T') - goto yy743; - if (yych != 't') - goto yy523; - yy743: - yych = *++p; - if (yych == 'F') - goto yy744; - if (yych != 'f') - goto yy523; - yy744: - yych = *++p; - if (yych == 'O') - goto yy745; - if (yych != 'o') - goto yy523; - yy745: - yych = *++p; - if (yych == 'R') - goto yy746; - if (yych != 'r') - goto yy523; - yy746: - yych = *++p; - if (yych == 'M') - goto yy533; - if (yych == 'm') - goto yy533; - goto yy523; - yy747: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy748: - yych = *++p; - if (yych == 'X') - goto yy749; - if (yych != 'x') - goto yy523; - yy749: - yych = *++p; - if (yych == 'Y') - goto yy533; - if (yych == 'y') - goto yy533; - goto yy523; - yy750: - yych = *++p; - if (yych == 'C') - goto yy533; - if (yych == 'c') - goto yy533; - goto yy523; - yy751: - yych = *++p; - if (yych == 'D') - goto yy533; - if (yych == 'd') - goto yy533; - goto yy523; - yy752: - yych = *++p; - if (yych == 'A') - goto yy753; - if (yych != 'a') - goto yy523; - yy753: - yych = *++p; - if (yych == 'Q') - goto yy754; - if (yych != 'q') - goto yy523; - yy754: - yych = *++p; - if (yych == 'U') - goto yy755; - if (yych != 'u') - goto yy523; - yy755: - yych = *++p; - if (yych == 'E') - goto yy756; - if (yych != 'e') - goto yy523; - yy756: - yych = *++p; - if (yych == 'L') - goto yy757; - if (yych != 'l') - goto yy523; - yy757: - yych = *++p; - if (yych == 'O') - goto yy758; - if (yych != 'o') - goto yy523; - yy758: - yych = *++p; - if (yych == 'C') - goto yy759; - if (yych != 'c') - goto yy523; - yy759: - yych = *++p; - if (yych == 'K') - goto yy760; - if (yych != 'k') - goto yy523; - yy760: - yych = *++p; - if (yych == 'T') - goto yy761; - if (yych != 't') - goto yy523; - yy761: - yych = *++p; - if (yych == 'O') - goto yy762; - if (yych != 'o') - goto yy523; - yy762: - yych = *++p; - if (yych == 'K') - goto yy763; - if (yych != 'k') - goto yy523; - yy763: - yych = *++p; - if (yych == 'E') - goto yy764; - if (yych != 'e') - goto yy523; - yy764: - yych = *++p; - if (yych == 'N') - goto yy533; - if (yych == 'n') - goto yy533; - goto yy523; - yy765: - yych = *++p; - if (yych == 'T') - goto yy772; - if (yych == 't') - goto yy772; - goto yy523; - yy766: - yych = *++p; - if (yych == 'T') - goto yy771; - if (yych == 't') - goto yy771; - goto yy523; - yy767: - yych = *++p; - if (yych <= 'G') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'H') - goto yy533; - if (yych == 'h') - goto yy533; - goto yy523; - } - yy768: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy769: - yych = *++p; - if (yych == 'W') - goto yy770; - if (yych != 'w') - goto yy523; - yy770: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy771: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy772: - yych = *++p; - if (yych == 'E') - goto yy773; - if (yych != 'e') - goto yy523; - yy773: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy774: - yych = *++p; - if (yych == 'N') - goto yy533; - if (yych == 'n') - goto yy533; - goto yy523; - yy775: - yych = *++p; - if (yych <= 'P') { - if (yych == 'M') - goto yy806; - if (yych <= 'O') - goto yy523; - goto yy805; - } else { - if (yych <= 'm') { - if (yych <= 'l') - goto yy523; - goto yy806; - } else { - if (yych == 'p') - goto yy805; - goto yy523; - } - } - yy776: - yych = *++p; - if (yych <= 'Q') { - if (yych <= '-') { - if (yych <= ',') - goto yy523; - goto yy798; - } else { - if (yych == 'N') - goto yy799; - goto yy523; - } - } else { - if (yych <= 'n') { - if (yych <= 'R') - goto yy797; - if (yych <= 'm') - goto yy523; - goto yy799; - } else { - if (yych == 'r') - goto yy797; - goto yy523; - } - } - yy777: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy778: - yych = *++p; - if (yych == 'S') - goto yy793; - if (yych == 's') - goto yy793; - goto yy523; - yy779: - yych = *++p; - switch (yych) { - case 'G': - case 'g': - goto yy784; - case 'I': - case 'i': - goto yy783; - case 'P': - case 'p': - goto yy785; - case 'R': - case 'r': - goto yy786; - default: - goto yy523; - } - yy780: - yych = *++p; - if (yych == 'Q') - goto yy782; - if (yych == 'q') - goto yy782; - goto yy523; - yy781: - yych = *++p; - if (yych == 'D') - goto yy533; - if (yych == 'd') - goto yy533; - goto yy523; - yy782: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy783: - yych = *++p; - if (yych == 'L') - goto yy791; - if (yych == 'l') - goto yy791; - goto yy523; - yy784: - yych = *++p; - if (yych == 'N') - goto yy789; - if (yych == 'n') - goto yy789; - goto yy523; - yy785: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy786: - yych = *++p; - if (yych == 'K') - goto yy787; - if (yych != 'k') - goto yy523; - yy787: - yych = *++p; - if (yych == 'E') - goto yy788; - if (yych != 'e') - goto yy523; - yy788: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy789: - yych = *++p; - if (yych == 'E') - goto yy790; - if (yych != 'e') - goto yy523; - yy790: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy791: - yych = *++p; - if (yych == 'T') - goto yy792; - if (yych != 't') - goto yy523; - yy792: - yych = *++p; - if (yych == 'O') - goto yy533; - if (yych == 'o') - goto yy533; - goto yy523; - yy793: - yych = *++p; - if (yych == 'S') - goto yy794; - if (yych != 's') - goto yy523; - yy794: - yych = *++p; - if (yych == 'A') - goto yy795; - if (yych != 'a') - goto yy523; - yy795: - yych = *++p; - if (yych == 'G') - goto yy796; - if (yych != 'g') - goto yy523; - yy796: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy797: - yych = *++p; - if (yych == 'P') - goto yy804; - if (yych == 'p') - goto yy804; - goto yy523; - yy798: - yych = *++p; - if (yych == 'H') - goto yy801; - if (yych == 'h') - goto yy801; - goto yy523; - yy799: - yych = *++p; - if (yych == 'I') - goto yy800; - if (yych != 'i') - goto yy523; - yy800: - yych = *++p; - if (yych == 'M') - goto yy533; - if (yych == 'm') - goto yy533; - goto yy523; - yy801: - yych = *++p; - if (yych == 'E') - goto yy802; - if (yych != 'e') - goto yy523; - yy802: - yych = *++p; - if (yych == 'L') - goto yy803; - if (yych != 'l') - goto yy523; - yy803: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy804: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - } - yy805: - yych = *++p; - if (yych == 'D') - goto yy809; - if (yych == 'd') - goto yy809; - goto yy523; - yy806: - yych = *++p; - if (yych == 'B') - goto yy807; - if (yych != 'b') - goto yy523; - yy807: - yych = *++p; - if (yych == 'L') - goto yy808; - if (yych != 'l') - goto yy523; - yy808: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy809: - yych = *++p; - if (yych == 'A') - goto yy810; - if (yych != 'a') - goto yy523; - yy810: - yych = *++p; - if (yych == 'T') - goto yy811; - if (yych != 't') - goto yy523; - yy811: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy812: - yych = *++p; - if (yych == 'A') - goto yy817; - if (yych == 'a') - goto yy817; - goto yy523; - yy813: - yych = *++p; - if (yych == 'S') - goto yy814; - if (yych != 's') - goto yy523; - yy814: - yych = *++p; - if (yych == 'T') - goto yy815; - if (yych != 't') - goto yy523; - yy815: - yych = *++p; - if (yych == 'F') - goto yy816; - if (yych != 'f') - goto yy523; - yy816: - yych = *++p; - if (yych == 'M') - goto yy533; - if (yych == 'm') - goto yy533; - goto yy523; - yy817: - yych = *++p; - if (yych == 'P') - goto yy818; - if (yych != 'p') - goto yy523; - yy818: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - } - yy819: - yych = *++p; - if (yych == 'M') - goto yy842; - if (yych == 'm') - goto yy842; - goto yy523; - yy820: - yych = *++p; - if (yych <= 'I') { - if (yych == 'C') - goto yy831; - if (yych <= 'H') - goto yy523; - goto yy830; - } else { - if (yych <= 'c') { - if (yych <= 'b') - goto yy523; - goto yy831; - } else { - if (yych == 'i') - goto yy830; - goto yy523; - } - } - yy821: - yych = *++p; - if (yych <= 'P') { - if (yych == 'N') - goto yy533; - if (yych <= 'O') - goto yy523; - goto yy533; - } else { - if (yych <= 'n') { - if (yych <= 'm') - goto yy523; - goto yy533; - } else { - if (yych == 'p') - goto yy533; - goto yy523; - } - } - yy822: - yych = *++p; - if (yych <= 'O') { - if (yych == 'A') - goto yy828; - if (yych <= 'N') - goto yy523; - goto yy829; - } else { - if (yych <= 'a') { - if (yych <= '`') - goto yy523; - goto yy828; - } else { - if (yych == 'o') - goto yy829; - goto yy523; - } - } - yy823: - yych = *++p; - if (yych == 'F') - goto yy827; - if (yych == 'f') - goto yy827; - goto yy523; - yy824: - yych = *++p; - if (yych <= '@') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'A') - goto yy826; - if (yych == 'a') - goto yy826; - goto yy523; - } - yy825: - yych = *++p; - if (yych == 'X') - goto yy533; - if (yych == 'x') - goto yy533; - goto yy523; - yy826: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy827: - yych = *++p; - if (yych == 'O') - goto yy533; - if (yych == 'o') - goto yy533; - goto yy523; - yy828: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy829: - yych = *++p; - if (yych == 'N') - goto yy533; - if (yych == 'n') - goto yy533; - goto yy523; - yy830: - yych = *++p; - if (yych == 'S') - goto yy832; - if (yych == 's') - goto yy832; - goto yy523; - yy831: - yych = *++p; - if (yych <= ':') { - if (yych == '6') - goto yy533; - if (yych <= '9') - goto yy523; - goto yy534; - } else { - if (yych <= 'S') { - if (yych <= 'R') - goto yy523; - goto yy533; - } else { - if (yych == 's') - goto yy533; - goto yy523; - } - } - yy832: - yych = *++p; - if (yych == '.') - goto yy833; - if (yych == ':') - goto yy534; - goto yy523; - yy833: - yych = *++p; - if (yych <= 'X') { - if (yych <= 'K') { - if (yych == 'B') - goto yy836; - goto yy523; - } else { - if (yych <= 'L') - goto yy834; - if (yych <= 'W') - goto yy523; - goto yy835; - } - } else { - if (yych <= 'k') { - if (yych == 'b') - goto yy836; - goto yy523; - } else { - if (yych <= 'l') - goto yy834; - if (yych == 'x') - goto yy835; - goto yy523; - } - } - yy834: - yych = *++p; - if (yych == 'W') - goto yy841; - if (yych == 'w') - goto yy841; - goto yy523; - yy835: - yych = *++p; - if (yych == 'P') - goto yy839; - if (yych == 'p') - goto yy839; - goto yy523; - yy836: - yych = *++p; - if (yych == 'E') - goto yy837; - if (yych != 'e') - goto yy523; - yy837: - yych = *++p; - if (yych == 'E') - goto yy838; - if (yych != 'e') - goto yy523; - yy838: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy839: - yych = *++p; - if (yych == 'C') - goto yy840; - if (yych != 'c') - goto yy523; - yy840: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - } - yy841: - yych = *++p; - if (yych == 'Z') - goto yy533; - if (yych == 'z') - goto yy533; - goto yy523; - yy842: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy843: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy844: - yych = *++p; - if (yych == 'T') - goto yy847; - if (yych == 't') - goto yy847; - goto yy523; - yy845: - yych = *++p; - if (yych != '2') - goto yy523; - yych = *++p; - if (yych == '3') - goto yy533; - goto yy523; - yy847: - yych = *++p; - if (yych == 'P') - goto yy848; - if (yych != 'p') - goto yy523; - yy848: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - } - yy849: - yych = *++p; - if (yych == 'A') - goto yy865; - if (yych == 'a') - goto yy865; - goto yy523; - yy850: - yych = *++p; - if (yych <= 'Z') { - if (yych == 'T') - goto yy533; - if (yych <= 'Y') - goto yy523; - goto yy856; - } else { - if (yych <= 't') { - if (yych <= 's') - goto yy523; - goto yy533; - } else { - if (yych == 'z') - goto yy856; - goto yy523; - } - } - yy851: - yych = *++p; - if (yych <= 'O') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'P') - goto yy853; - if (yych == 'p') - goto yy853; - goto yy523; - } - yy852: - yych = *++p; - if (yych == 'O') - goto yy533; - if (yych == 'o') - goto yy533; - goto yy523; - yy853: - yych = *++p; - if (yych == 'H') - goto yy854; - if (yych != 'h') - goto yy523; - yy854: - yych = *++p; - if (yych == 'E') - goto yy855; - if (yych != 'e') - goto yy523; - yy855: - yych = *++p; - if (yych == 'R') - goto yy533; - if (yych == 'r') - goto yy533; - goto yy523; - yy856: - yych = *++p; - if (yych == 'M') - goto yy857; - if (yych != 'm') - goto yy523; - yy857: - yych = *++p; - if (yych == 'O') - goto yy858; - if (yych != 'o') - goto yy523; - yy858: - yych = *++p; - if (yych == 'P') - goto yy859; - if (yych != 'p') - goto yy523; - yy859: - yych = *++p; - if (yych == 'R') - goto yy860; - if (yych != 'r') - goto yy523; - yy860: - yych = *++p; - if (yych == 'O') - goto yy861; - if (yych != 'o') - goto yy523; - yy861: - yych = *++p; - if (yych == 'J') - goto yy862; - if (yych != 'j') - goto yy523; - yy862: - yych = *++p; - if (yych == 'E') - goto yy863; - if (yych != 'e') - goto yy523; - yy863: - yych = *++p; - if (yych == 'C') - goto yy864; - if (yych != 'c') - goto yy523; - yy864: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy865: - yych = *++p; - if (yych == 'L') - goto yy866; - if (yych != 'l') - goto yy523; - yy866: - yych = *++p; - if (yych == 'K') - goto yy533; - if (yych == 'k') - goto yy533; - goto yy523; - yy867: - yych = *++p; - if (yych <= 'S') { - if (yych <= 'M') { - if (yych == 'L') - goto yy877; - goto yy523; - } else { - if (yych <= 'N') - goto yy878; - if (yych <= 'R') - goto yy523; - goto yy879; - } - } else { - if (yych <= 'm') { - if (yych == 'l') - goto yy877; - goto yy523; - } else { - if (yych <= 'n') - goto yy878; - if (yych == 's') - goto yy879; - goto yy523; - } - } - yy868: - yych = *++p; - if (yych == 'E') - goto yy876; - if (yych == 'e') - goto yy876; - goto yy523; - yy869: - yych = *++p; - if (yych == 'C') - goto yy871; - if (yych == 'c') - goto yy871; - goto yy523; - yy870: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy871: - yych = *++p; - if (yych == 'E') - goto yy872; - if (yych != 'e') - goto yy523; - yy872: - yych = *++p; - if (yych == 'T') - goto yy873; - if (yych != 't') - goto yy523; - yy873: - yych = *++p; - if (yych == 'I') - goto yy874; - if (yych != 'i') - goto yy523; - yy874: - yych = *++p; - if (yych == 'M') - goto yy875; - if (yych != 'm') - goto yy523; - yy875: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy876: - yych = *++p; - if (yych == 'D') - goto yy533; - if (yych == 'd') - goto yy533; - goto yy523; - yy877: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy878: - yych = *++p; - if (yych == 'G') - goto yy880; - if (yych == 'g') - goto yy880; - goto yy523; - yy879: - yych = *++p; - if (yych == 'H') - goto yy533; - if (yych == 'h') - goto yy533; - goto yy523; - yy880: - yych = *++p; - if (yych == 'E') - goto yy881; - if (yych != 'e') - goto yy523; - yy881: - yych = *++p; - if (yych == 'R') - goto yy533; - if (yych == 'r') - goto yy533; - goto yy523; - yy882: - yych = *++p; - if (yych == 'T') - goto yy900; - if (yych == 't') - goto yy900; - goto yy523; - yy883: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy884: - yych = *++p; - if (yych == 'M') - goto yy533; - if (yych == 'm') - goto yy533; - goto yy523; - yy885: - yych = *++p; - if (yych <= 'S') { - if (yych == 'P') - goto yy533; - if (yych <= 'R') - goto yy523; - goto yy533; - } else { - if (yych <= 'p') { - if (yych <= 'o') - goto yy523; - goto yy533; - } else { - if (yych == 's') - goto yy533; - goto yy523; - } - } - yy886: - yych = *++p; - if (yych == 'I') - goto yy894; - if (yych == 'i') - goto yy894; - goto yy523; - yy887: - yych = *++p; - if (yych == 'A') - goto yy893; - if (yych == 'a') - goto yy893; - goto yy523; - yy888: - yych = *++p; - if (yych == 'O') - goto yy891; - if (yych == 'o') - goto yy891; - goto yy523; - yy889: - yych = *++p; - if (yych == 'A') - goto yy890; - if (yych != 'a') - goto yy523; - yy890: - yych = *++p; - if (yych <= 'R') { - if (yych == ':') - goto yy534; - goto yy523; - } else { - if (yych <= 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - } - yy891: - yych = *++p; - if (yych == 'U') - goto yy892; - if (yych != 'u') - goto yy523; - yy892: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy893: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy894: - yych = *++p; - if (yych == 'U') - goto yy895; - if (yych != 'u') - goto yy523; - yy895: - yych = *++p; - if (yych == 'M') - goto yy896; - if (yych != 'm') - goto yy523; - yy896: - yych = *++p; - if (yych == 'X') - goto yy897; - if (yych != 'x') - goto yy523; - yy897: - yych = *++p; - if (yych == 'T') - goto yy898; - if (yych != 't') - goto yy523; - yy898: - yych = *++p; - if (yych == 'R') - goto yy899; - if (yych != 'r') - goto yy523; - yy899: - yych = *++p; - if (yych == 'A') - goto yy533; - if (yych == 'a') - goto yy533; - goto yy523; - yy900: - yych = *++p; - if (yych == 'A') - goto yy901; - if (yych != 'a') - goto yy523; - yy901: - yych = *++p; - if (yych == 'C') - goto yy902; - if (yych != 'c') - goto yy523; - yy902: - yych = *++p; - if (yych == 'H') - goto yy903; - if (yych != 'h') - goto yy523; - yy903: - yych = *++p; - if (yych == 'M') - goto yy904; - if (yych != 'm') - goto yy523; - yy904: - yych = *++p; - if (yych == 'E') - goto yy905; - if (yych != 'e') - goto yy523; - yy905: - yych = *++p; - if (yych == 'N') - goto yy906; - if (yych != 'n') - goto yy523; - yy906: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy907: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy908: - yych = *++p; - if (yych <= 'V') { - if (yych == 'R') - goto yy533; - if (yych <= 'U') - goto yy523; - } else { - if (yych <= 'r') { - if (yych <= 'q') - goto yy523; - goto yy533; - } else { - if (yych != 'v') - goto yy523; - } - } - yych = *++p; - if (yych == 'A') - goto yy910; - if (yych != 'a') - goto yy523; - yy910: - yych = *++p; - if (yych == 'S') - goto yy911; - if (yych != 's') - goto yy523; - yy911: - yych = *++p; - if (yych == 'C') - goto yy912; - if (yych != 'c') - goto yy523; - yy912: - yych = *++p; - if (yych == 'R') - goto yy913; - if (yych != 'r') - goto yy523; - yy913: - yych = *++p; - if (yych == 'I') - goto yy914; - if (yych != 'i') - goto yy523; - yy914: - yych = *++p; - if (yych == 'P') - goto yy915; - if (yych != 'p') - goto yy523; - yy915: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy916: - yych = *++p; - if (yych == 'B') - goto yy533; - if (yych == 'b') - goto yy533; - goto yy523; - yy917: - yych = *++p; - if (yych == 'N') - goto yy533; - if (yych == 'n') - goto yy533; - goto yy523; - yy918: - yych = *++p; - if (yych == 'N') - goto yy925; - if (yych == 'n') - goto yy925; - goto yy523; - yy919: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy920: - yych = *++p; - if (yych == 'C') - goto yy924; - if (yych == 'c') - goto yy924; - goto yy523; - yy921: - yych = *++p; - if (yych <= 'V') { - if (yych == 'T') - goto yy923; - if (yych <= 'U') - goto yy523; - goto yy533; - } else { - if (yych <= 't') { - if (yych <= 's') - goto yy523; - goto yy923; - } else { - if (yych == 'v') - goto yy533; - goto yy523; - } - } - yy922: - yych = *++p; - if (yych == 'I') - goto yy533; - if (yych == 'i') - goto yy533; - goto yy523; - yy923: - yych = *++p; - if (yych == 'A') - goto yy533; - if (yych == 'a') - goto yy533; - goto yy523; - yy924: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy925: - yych = *++p; - if (yych == 'A') - goto yy926; - if (yych != 'a') - goto yy523; - yy926: - yych = *++p; - if (yych != '-') - goto yy523; - yych = *++p; - if (yych == 'P') - goto yy928; - if (yych != 'p') - goto yy523; - yy928: - yych = *++p; - if (yych == 'L') - goto yy929; - if (yych != 'l') - goto yy523; - yy929: - yych = *++p; - if (yych == 'A') - goto yy930; - if (yych != 'a') - goto yy523; - yy930: - yych = *++p; - if (yych == 'Y') - goto yy931; - if (yych != 'y') - goto yy523; - yy931: - yych = *++p; - if (yych <= 'S') { - if (yych == 'C') - goto yy932; - if (yych <= 'R') - goto yy523; - goto yy933; - } else { - if (yych <= 'c') { - if (yych <= 'b') - goto yy523; - } else { - if (yych == 's') - goto yy933; - goto yy523; - } - } - yy932: - yych = *++p; - if (yych == 'O') - goto yy938; - if (yych == 'o') - goto yy938; - goto yy523; - yy933: - yych = *++p; - if (yych == 'I') - goto yy934; - if (yych != 'i') - goto yy523; - yy934: - yych = *++p; - if (yych == 'N') - goto yy935; - if (yych != 'n') - goto yy523; - yy935: - yych = *++p; - if (yych == 'G') - goto yy936; - if (yych != 'g') - goto yy523; - yy936: - yych = *++p; - if (yych == 'L') - goto yy937; - if (yych != 'l') - goto yy523; - yy937: - yych = *++p; - if (yych == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; - yy938: - yych = *++p; - if (yych == 'N') - goto yy939; - if (yych != 'n') - goto yy523; - yy939: - yych = *++p; - if (yych == 'T') - goto yy940; - if (yych != 't') - goto yy523; - yy940: - yych = *++p; - if (yych == 'A') - goto yy941; - if (yych != 'a') - goto yy523; - yy941: - yych = *++p; - if (yych == 'I') - goto yy942; - if (yych != 'i') - goto yy523; - yy942: - yych = *++p; - if (yych == 'N') - goto yy943; - if (yych != 'n') - goto yy523; - yy943: - yych = *++p; - if (yych == 'E') - goto yy944; - if (yych != 'e') - goto yy523; - yy944: - yych = *++p; - if (yych == 'R') - goto yy533; - if (yych == 'r') - goto yy533; - goto yy523; - yy945: - yych = *++p; - if (yych == 'S') - goto yy533; - if (yych == 's') - goto yy533; - goto yy523; - yy946: - yych = *++p; - if (yych <= 'N') { - if (yych <= 'A') { - if (yych <= '@') - goto yy523; - goto yy968; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; } else { - if (yych <= 'L') - goto yy523; - if (yych <= 'M') - goto yy969; - goto yy970; + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; } } else { - if (yych <= 'l') { - if (yych == 'a') - goto yy968; - goto yy523; + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; } else { - if (yych <= 'm') - goto yy969; - if (yych <= 'n') - goto yy970; - goto yy523; + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; } } - yy947: - yych = *++p; - if (yych == 'R') - goto yy955; - if (yych == 'r') - goto yy955; - goto yy523; - yy948: yych = *++p; - if (yych <= 'P') { - if (yych == 'L') - goto yy952; - if (yych <= 'O') - goto yy523; - goto yy533; - } else { - if (yych <= 'l') { - if (yych <= 'k') - goto yy523; - goto yy952; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; } else { - if (yych == 'p') - goto yy533; - goto yy523; + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; } - } - yy949: - yych = *++p; - if (yych == 'I') - goto yy951; - if (yych == 'i') - goto yy951; - goto yy523; - yy950: - yych = *++p; - if (yych == 'D') - goto yy533; - if (yych == 'd') - goto yy533; - goto yy523; - yy951: - yych = *++p; - if (yych == 'D') - goto yy533; - if (yych == 'd') - goto yy533; - goto yy523; - yy952: - yych = *++p; - if (yych == 'L') - goto yy953; - if (yych != 'l') - goto yy523; - yy953: - yych = *++p; - if (yych == 'T') - goto yy954; - if (yych != 't') - goto yy523; - yy954: - yych = *++p; - if (yych == 'O') - goto yy533; - if (yych == 'o') - goto yy533; - goto yy523; - yy955: - yych = *++p; - if (yych == 'O') - goto yy956; - if (yych != 'o') - goto yy523; - yy956: - yych = *++p; - if (yych == 'M') - goto yy957; - if (yych != 'm') - goto yy523; - yy957: - yych = *++p; - if (yych == 'E') - goto yy958; - if (yych != 'e') - goto yy523; - yy958: - yych = *++p; - if (yych == '-') - goto yy959; - if (yych == ':') - goto yy534; - goto yy523; - yy959: - yych = *++p; - if (yych == 'E') - goto yy960; - if (yych != 'e') - goto yy523; - yy960: - yych = *++p; - if (yych == 'X') - goto yy961; - if (yych != 'x') - goto yy523; - yy961: - yych = *++p; - if (yych == 'T') - goto yy962; - if (yych != 't') - goto yy523; - yy962: - yych = *++p; - if (yych == 'E') - goto yy963; - if (yych != 'e') - goto yy523; - yy963: - yych = *++p; - if (yych == 'N') - goto yy964; - if (yych != 'n') - goto yy523; - yy964: - yych = *++p; - if (yych == 'S') - goto yy965; - if (yych != 's') - goto yy523; - yy965: - yych = *++p; - if (yych == 'I') - goto yy966; - if (yych != 'i') - goto yy523; - yy966: - yych = *++p; - if (yych == 'O') - goto yy967; - if (yych != 'o') - goto yy523; - yy967: - yych = *++p; - if (yych == 'N') - goto yy533; - if (yych == 'n') - goto yy533; - goto yy523; - yy968: - yych = *++p; - if (yych == 'P') - goto yy533; - if (yych == 'p') - goto yy533; - goto yy523; - yy969: - yych = *++p; - if (yych == '-') - goto yy974; - goto yy523; - yy970: - yych = *++p; - if (yych == 'T') - goto yy971; - if (yych != 't') - goto yy523; - yy971: - yych = *++p; - if (yych == 'E') - goto yy972; - if (yych != 'e') - goto yy523; - yy972: - yych = *++p; - if (yych == 'N') - goto yy973; - if (yych != 'n') - goto yy523; - yy973: - yych = *++p; - if (yych == 'T') - goto yy533; - if (yych == 't') - goto yy533; - goto yy523; - yy974: - yych = *++p; - if (yych == 'E') - goto yy975; - if (yych != 'e') - goto yy523; - yy975: - yych = *++p; - if (yych == 'V') - goto yy976; - if (yych != 'v') - goto yy523; - yy976: - yych = *++p; - if (yych == 'E') - goto yy977; - if (yych != 'e') - goto yy523; - yy977: - yych = *++p; - if (yych == 'N') - goto yy978; - if (yych != 'n') - goto yy523; - yy978: - yych = *++p; - if (yych == 'T') - goto yy979; - if (yych != 't') - goto yy523; - yy979: - yych = *++p; - if (yych == 'B') - goto yy980; - if (yych != 'b') - goto yy523; - yy980: + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'R') - goto yy981; - if (yych != 'r') - goto yy523; - yy981: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'I') - goto yy982; - if (yych != 'i') - goto yy523; - yy982: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'T') - goto yy983; - if (yych != 't') - goto yy523; - yy983: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'E') - goto yy984; - if (yych != 'e') - goto yy523; - yy984: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych != '-') - goto yy523; + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'A') - goto yy986; - if (yych != 'a') - goto yy523; - yy986: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'T') - goto yy987; - if (yych != 't') - goto yy523; - yy987: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'T') - goto yy988; - if (yych != 't') - goto yy523; - yy988: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'E') - goto yy989; - if (yych != 'e') - goto yy523; - yy989: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'N') - goto yy990; - if (yych != 'n') - goto yy523; - yy990: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'D') - goto yy991; - if (yych != 'd') - goto yy523; - yy991: + if (yych <= '9') { + if (yych <= '+') { + if (yych <= '*') + goto yy52; + } else { + if (yych <= ',') + goto yy52; + if (yych >= '/') + goto yy52; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy60; + if (yych <= '@') + goto yy52; + } else { + if (yych <= '`') + goto yy52; + if (yych >= '{') + goto yy52; + } + } yych = *++p; - if (yych == 'E') - goto yy992; - if (yych != 'e') - goto yy523; - yy992: + if (yych == ':') + goto yy60; + goto yy52; + yy92: ++p; - if ((yych = *p) == 'E') - goto yy533; - if (yych == 'e') - goto yy533; - goto yy523; + yych = *p; + if (yych <= 0x7F) + goto yy52; + if (yych <= 0xBF) + goto yy60; + goto yy52; + yy93: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy52; + if (yych <= 0xBF) + goto yy92; + goto yy52; + yy94: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy52; + if (yych <= 0xBF) + goto yy92; + goto yy52; + yy95: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy52; + if (yych <= 0xBF) + goto yy94; + goto yy52; + yy96: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy52; + if (yych <= 0xBF) + goto yy94; + goto yy52; + yy97: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy52; + if (yych <= 0x8F) + goto yy94; + goto yy52; + yy98: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy52; + if (yych <= 0x9F) + goto yy92; + goto yy52; + yy99: + ++p; + { return (bufsize_t)(p - start); } } } @@ -8472,6355 +1897,6595 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { if (yych <= ')') { if (yych <= ' ') { if (yych != '\n') - goto yy997; + goto yy105; } else { if (yych == '"') - goto yy997; + goto yy105; if (yych <= '\'') - goto yy996; - goto yy997; + goto yy104; + goto yy105; } } else { if (yych <= '9') { if (yych == ',') - goto yy997; - goto yy996; + goto yy105; + goto yy104; } else { if (yych == '=') - goto yy996; + goto yy104; if (yych <= '>') - goto yy997; - goto yy996; + goto yy105; + goto yy104; } } } else { if (yych <= 0xDF) { if (yych <= ']') { if (yych <= '@') - goto yy997; + goto yy105; if (yych <= 'Z') - goto yy996; - goto yy997; + goto yy104; + goto yy105; } else { if (yych <= '~') - goto yy996; + goto yy104; if (yych <= 0x7F) - goto yy997; + goto yy105; if (yych >= 0xC2) - goto yy998; + goto yy106; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1000; + goto yy108; if (yych == 0xED) - goto yy1005; - goto yy1001; + goto yy113; + goto yy109; } else { if (yych <= 0xF0) - goto yy1002; + goto yy110; if (yych <= 0xF3) - goto yy1003; + goto yy111; if (yych <= 0xF4) - goto yy1004; + goto yy112; } } } - yy995 : { return 0; } - yy996: + yy103 : { return 0; } + yy104: yych = *(marker = ++p); if (yych <= ',') { if (yych <= '"') { if (yych == '!') - goto yy1008; - goto yy995; + goto yy116; + goto yy103; } else { if (yych <= '\'') - goto yy1008; + goto yy116; if (yych <= ')') - goto yy995; + goto yy103; if (yych <= '+') - goto yy1008; - goto yy995; + goto yy116; + goto yy103; } } else { if (yych <= '>') { if (yych <= '9') - goto yy1008; + goto yy116; if (yych == '=') - goto yy1008; - goto yy995; + goto yy116; + goto yy103; } else { if (yych <= 'Z') - goto yy1008; + goto yy116; if (yych <= ']') - goto yy995; + goto yy103; if (yych <= '~') - goto yy1008; - goto yy995; + goto yy116; + goto yy103; } } - yy997: + yy105: yych = *++p; - goto yy995; - yy998: + goto yy103; + yy106: yych = *++p; if (yych <= 0x7F) - goto yy999; + goto yy107; if (yych <= 0xBF) - goto yy997; - yy999: + goto yy105; + yy107: p = marker; - goto yy995; - yy1000: + goto yy103; + yy108: yych = *++p; if (yych <= 0x9F) - goto yy999; + goto yy107; if (yych <= 0xBF) - goto yy998; - goto yy999; - yy1001: + goto yy106; + goto yy107; + yy109: yych = *++p; if (yych <= 0x7F) - goto yy999; + goto yy107; if (yych <= 0xBF) - goto yy998; - goto yy999; - yy1002: + goto yy106; + goto yy107; + yy110: yych = *++p; if (yych <= 0x8F) - goto yy999; + goto yy107; if (yych <= 0xBF) - goto yy1001; - goto yy999; - yy1003: + goto yy109; + goto yy107; + yy111: yych = *++p; if (yych <= 0x7F) - goto yy999; + goto yy107; if (yych <= 0xBF) - goto yy1001; - goto yy999; - yy1004: + goto yy109; + goto yy107; + yy112: yych = *++p; if (yych <= 0x7F) - goto yy999; + goto yy107; if (yych <= 0x8F) - goto yy1001; - goto yy999; - yy1005: + goto yy109; + goto yy107; + yy113: yych = *++p; if (yych <= 0x7F) - goto yy999; + goto yy107; if (yych <= 0x9F) - goto yy998; - goto yy999; - yy1006: + goto yy106; + goto yy107; + yy114: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1009; - goto yy999; + goto yy117; + goto yy107; } else { if (yych <= 'Z') - goto yy1009; + goto yy117; if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1009; - goto yy999; + goto yy117; + goto yy107; } - yy1007: + yy115: ++p; yych = *p; - yy1008: + yy116: if (yybm[0 + yych] & 128) { - goto yy1007; + goto yy115; } if (yych <= '>') - goto yy999; + goto yy107; if (yych <= '@') - goto yy1006; - goto yy999; - yy1009: + goto yy114; + goto yy107; + yy117: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1011; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; - if (yych >= ':') - goto yy999; + goto yy107; + if (yych <= '9') + goto yy119; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; + goto yy107; + goto yy119; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy119; + goto yy107; } } yych = *++p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1140; - goto yy1012; - } else { - if (yych <= '/') - goto yy999; - if (yych <= '9') - goto yy1139; - goto yy999; - } + if (yych <= '9') { + if (yych == '-') + goto yy247; + if (yych <= '/') + goto yy107; + goto yy248; } else { if (yych <= 'Z') { - if (yych <= '>') - goto yy1013; if (yych <= '@') - goto yy999; - goto yy1139; + goto yy107; + goto yy248; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1139; - goto yy999; + goto yy248; + goto yy107; } } - yy1011: + yy119: yych = *++p; - if (yych <= '9') { - if (yych == '-') - goto yy1140; - if (yych <= '/') - goto yy999; - goto yy1139; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy107; + if (yych <= '-') + goto yy247; + } else { + if (yych <= '/') + goto yy107; + if (yych <= '9') + goto yy248; + goto yy107; + } } else { if (yych <= 'Z') { + if (yych <= '>') + goto yy121; if (yych <= '@') - goto yy999; - goto yy1139; + goto yy107; + goto yy248; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1139; - goto yy999; + goto yy248; + goto yy107; } } - yy1012: + yy120: ++p; yych = *p; if (yych <= '@') { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1015; - goto yy999; + goto yy123; + goto yy107; } else { if (yych <= 'Z') - goto yy1015; + goto yy123; if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1015; - goto yy999; + goto yy123; + goto yy107; } - yy1013: + yy121: ++p; { return (bufsize_t)(p - start); } - yy1015: - ++p; - yych = *p; - if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1017; - goto yy1012; - } else { - if (yych <= '/') - goto yy999; - if (yych >= ':') - goto yy999; - } - } else { - if (yych <= 'Z') { - if (yych <= '>') - goto yy1013; - if (yych <= '@') - goto yy999; - } else { - if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; - } - } + yy123: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1019; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1018; - goto yy999; + goto yy125; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1018; + goto yy107; + goto yy125; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1018; - goto yy999; + goto yy125; + goto yy107; } } - yy1017: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1019; + goto yy126; if (yych <= '/') - goto yy999; + goto yy107; + goto yy127; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy127; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy127; + goto yy107; } } - yy1018: + yy125: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1021; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1020; - goto yy999; + goto yy127; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1020; + goto yy107; + goto yy127; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1020; - goto yy999; + goto yy127; + goto yy107; } } - yy1019: + yy126: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1021; + goto yy128; if (yych <= '/') - goto yy999; + goto yy107; + goto yy129; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy129; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy129; + goto yy107; } } - yy1020: + yy127: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1023; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1022; - goto yy999; + goto yy129; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1022; + goto yy107; + goto yy129; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1022; - goto yy999; + goto yy129; + goto yy107; } } - yy1021: + yy128: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1023; + goto yy130; if (yych <= '/') - goto yy999; + goto yy107; + goto yy131; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy131; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy131; + goto yy107; } } - yy1022: + yy129: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1025; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1024; - goto yy999; + goto yy131; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1024; + goto yy107; + goto yy131; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1024; - goto yy999; + goto yy131; + goto yy107; } } - yy1023: + yy130: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1025; + goto yy132; if (yych <= '/') - goto yy999; + goto yy107; + goto yy133; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy133; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy133; + goto yy107; } } - yy1024: + yy131: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1027; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1026; - goto yy999; + goto yy133; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1026; + goto yy107; + goto yy133; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1026; - goto yy999; + goto yy133; + goto yy107; } } - yy1025: + yy132: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1027; + goto yy134; if (yych <= '/') - goto yy999; + goto yy107; + goto yy135; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; - } else { - if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + goto yy135; + } else { + if (yych <= '`') + goto yy107; + if (yych <= 'z') + goto yy135; + goto yy107; } } - yy1026: + yy133: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1029; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1028; - goto yy999; + goto yy135; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1028; + goto yy107; + goto yy135; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1028; - goto yy999; + goto yy135; + goto yy107; } } - yy1027: + yy134: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1029; + goto yy136; if (yych <= '/') - goto yy999; + goto yy107; + goto yy137; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy137; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy137; + goto yy107; } } - yy1028: + yy135: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1031; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1030; - goto yy999; + goto yy137; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1030; + goto yy107; + goto yy137; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1030; - goto yy999; + goto yy137; + goto yy107; } } - yy1029: + yy136: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1031; + goto yy138; if (yych <= '/') - goto yy999; + goto yy107; + goto yy139; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy139; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy139; + goto yy107; } } - yy1030: + yy137: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1033; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1032; - goto yy999; + goto yy139; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1032; + goto yy107; + goto yy139; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1032; - goto yy999; + goto yy139; + goto yy107; } } - yy1031: + yy138: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1033; + goto yy140; if (yych <= '/') - goto yy999; + goto yy107; + goto yy141; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy141; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy141; + goto yy107; } } - yy1032: + yy139: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1035; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1034; - goto yy999; + goto yy141; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1034; + goto yy107; + goto yy141; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1034; - goto yy999; + goto yy141; + goto yy107; } } - yy1033: + yy140: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1035; + goto yy142; if (yych <= '/') - goto yy999; + goto yy107; + goto yy143; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy143; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy143; + goto yy107; } } - yy1034: + yy141: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1037; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1036; - goto yy999; + goto yy143; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1036; + goto yy107; + goto yy143; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1036; - goto yy999; + goto yy143; + goto yy107; } } - yy1035: + yy142: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1037; + goto yy144; if (yych <= '/') - goto yy999; + goto yy107; + goto yy145; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy145; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy145; + goto yy107; } } - yy1036: + yy143: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1039; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1038; - goto yy999; + goto yy145; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1038; + goto yy107; + goto yy145; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1038; - goto yy999; + goto yy145; + goto yy107; } } - yy1037: + yy144: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1039; + goto yy146; if (yych <= '/') - goto yy999; + goto yy107; + goto yy147; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy147; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy147; + goto yy107; } } - yy1038: + yy145: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1041; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1040; - goto yy999; + goto yy147; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1040; + goto yy107; + goto yy147; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1040; - goto yy999; + goto yy147; + goto yy107; } } - yy1039: + yy146: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1041; + goto yy148; if (yych <= '/') - goto yy999; + goto yy107; + goto yy149; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy149; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy149; + goto yy107; } } - yy1040: + yy147: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1043; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1042; - goto yy999; + goto yy149; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1042; + goto yy107; + goto yy149; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1042; - goto yy999; + goto yy149; + goto yy107; } } - yy1041: + yy148: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1043; + goto yy150; if (yych <= '/') - goto yy999; + goto yy107; + goto yy151; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy151; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy151; + goto yy107; } } - yy1042: + yy149: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1045; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1044; - goto yy999; + goto yy151; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1044; + goto yy107; + goto yy151; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1044; - goto yy999; + goto yy151; + goto yy107; } } - yy1043: + yy150: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1045; + goto yy152; if (yych <= '/') - goto yy999; + goto yy107; + goto yy153; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy153; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy153; + goto yy107; } } - yy1044: + yy151: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1047; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1046; - goto yy999; + goto yy153; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1046; + goto yy107; + goto yy153; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1046; - goto yy999; + goto yy153; + goto yy107; } } - yy1045: + yy152: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1047; + goto yy154; if (yych <= '/') - goto yy999; + goto yy107; + goto yy155; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy155; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy155; + goto yy107; } } - yy1046: + yy153: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1049; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1048; - goto yy999; + goto yy155; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1048; + goto yy107; + goto yy155; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1048; - goto yy999; + goto yy155; + goto yy107; } } - yy1047: + yy154: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1049; + goto yy156; if (yych <= '/') - goto yy999; + goto yy107; + goto yy157; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; - } else { - if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + goto yy157; + } else { + if (yych <= '`') + goto yy107; + if (yych <= 'z') + goto yy157; + goto yy107; } } - yy1048: + yy155: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1051; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1050; - goto yy999; + goto yy157; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1050; + goto yy107; + goto yy157; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1050; - goto yy999; + goto yy157; + goto yy107; } } - yy1049: + yy156: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1051; + goto yy158; if (yych <= '/') - goto yy999; + goto yy107; + goto yy159; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy159; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy159; + goto yy107; } } - yy1050: + yy157: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1053; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1052; - goto yy999; + goto yy159; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1052; + goto yy107; + goto yy159; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1052; - goto yy999; + goto yy159; + goto yy107; } } - yy1051: + yy158: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1053; + goto yy160; if (yych <= '/') - goto yy999; + goto yy107; + goto yy161; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy161; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy161; + goto yy107; } } - yy1052: + yy159: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1055; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1054; - goto yy999; + goto yy161; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1054; + goto yy107; + goto yy161; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1054; - goto yy999; + goto yy161; + goto yy107; } } - yy1053: + yy160: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1055; + goto yy162; if (yych <= '/') - goto yy999; + goto yy107; + goto yy163; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy163; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy163; + goto yy107; } } - yy1054: + yy161: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1057; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1056; - goto yy999; + goto yy163; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1056; + goto yy107; + goto yy163; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1056; - goto yy999; + goto yy163; + goto yy107; } } - yy1055: + yy162: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1057; + goto yy164; if (yych <= '/') - goto yy999; + goto yy107; + goto yy165; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy165; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy165; + goto yy107; } } - yy1056: + yy163: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1059; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1058; - goto yy999; + goto yy165; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1058; + goto yy107; + goto yy165; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1058; - goto yy999; + goto yy165; + goto yy107; } } - yy1057: + yy164: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1059; + goto yy166; if (yych <= '/') - goto yy999; + goto yy107; + goto yy167; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy167; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy167; + goto yy107; } } - yy1058: + yy165: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1061; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1060; - goto yy999; + goto yy167; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1060; + goto yy107; + goto yy167; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1060; - goto yy999; + goto yy167; + goto yy107; } } - yy1059: + yy166: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1061; + goto yy168; if (yych <= '/') - goto yy999; + goto yy107; + goto yy169; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy169; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy169; + goto yy107; } } - yy1060: + yy167: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1063; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1062; - goto yy999; + goto yy169; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1062; + goto yy107; + goto yy169; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1062; - goto yy999; + goto yy169; + goto yy107; } } - yy1061: + yy168: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1063; + goto yy170; if (yych <= '/') - goto yy999; + goto yy107; + goto yy171; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy171; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy171; + goto yy107; } } - yy1062: + yy169: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1065; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1064; - goto yy999; + goto yy171; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1064; + goto yy107; + goto yy171; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1064; - goto yy999; + goto yy171; + goto yy107; } } - yy1063: + yy170: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1065; + goto yy172; if (yych <= '/') - goto yy999; + goto yy107; + goto yy173; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy173; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy173; + goto yy107; } } - yy1064: + yy171: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1067; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1066; - goto yy999; + goto yy173; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1066; + goto yy107; + goto yy173; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1066; - goto yy999; + goto yy173; + goto yy107; } } - yy1065: + yy172: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1067; + goto yy174; if (yych <= '/') - goto yy999; + goto yy107; + goto yy175; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy175; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy175; + goto yy107; } } - yy1066: + yy173: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1069; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1068; - goto yy999; + goto yy175; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1068; + goto yy107; + goto yy175; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1068; - goto yy999; + goto yy175; + goto yy107; } } - yy1067: + yy174: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1069; + goto yy176; if (yych <= '/') - goto yy999; + goto yy107; + goto yy177; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy177; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy177; + goto yy107; } } - yy1068: + yy175: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1071; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1070; - goto yy999; + goto yy177; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1070; + goto yy107; + goto yy177; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1070; - goto yy999; + goto yy177; + goto yy107; } } - yy1069: + yy176: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1071; + goto yy178; if (yych <= '/') - goto yy999; + goto yy107; + goto yy179; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy179; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy179; + goto yy107; } } - yy1070: + yy177: ++p; yych = *p; if (yych <= '=') { - if (yych <= '.') { - if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1073; - goto yy1012; + if (yych <= '.') { + if (yych <= ',') + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1072; - goto yy999; + goto yy179; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1072; + goto yy107; + goto yy179; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1072; - goto yy999; + goto yy179; + goto yy107; } } - yy1071: + yy178: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1073; + goto yy180; if (yych <= '/') - goto yy999; + goto yy107; + goto yy181; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy181; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy181; + goto yy107; } } - yy1072: + yy179: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1075; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1074; - goto yy999; + goto yy181; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1074; + goto yy107; + goto yy181; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1074; - goto yy999; + goto yy181; + goto yy107; } } - yy1073: + yy180: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1075; + goto yy182; if (yych <= '/') - goto yy999; + goto yy107; + goto yy183; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy183; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy183; + goto yy107; } } - yy1074: + yy181: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1077; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1076; - goto yy999; + goto yy183; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1076; + goto yy107; + goto yy183; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1076; - goto yy999; + goto yy183; + goto yy107; } } - yy1075: + yy182: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1077; + goto yy184; if (yych <= '/') - goto yy999; + goto yy107; + goto yy185; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy185; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy185; + goto yy107; } } - yy1076: + yy183: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1079; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1078; - goto yy999; + goto yy185; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1078; + goto yy107; + goto yy185; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1078; - goto yy999; + goto yy185; + goto yy107; } } - yy1077: + yy184: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1079; + goto yy186; if (yych <= '/') - goto yy999; + goto yy107; + goto yy187; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy187; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy187; + goto yy107; } } - yy1078: + yy185: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1081; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1080; - goto yy999; + goto yy187; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1080; + goto yy107; + goto yy187; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1080; - goto yy999; + goto yy187; + goto yy107; } } - yy1079: + yy186: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1081; + goto yy188; if (yych <= '/') - goto yy999; + goto yy107; + goto yy189; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy189; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy189; + goto yy107; } } - yy1080: + yy187: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1083; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1082; - goto yy999; + goto yy189; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1082; + goto yy107; + goto yy189; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1082; - goto yy999; + goto yy189; + goto yy107; } } - yy1081: + yy188: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1083; + goto yy190; if (yych <= '/') - goto yy999; + goto yy107; + goto yy191; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy191; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy191; + goto yy107; } } - yy1082: + yy189: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1085; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1084; - goto yy999; + goto yy191; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1084; + goto yy107; + goto yy191; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1084; - goto yy999; + goto yy191; + goto yy107; } } - yy1083: + yy190: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1085; + goto yy192; if (yych <= '/') - goto yy999; + goto yy107; + goto yy193; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy193; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy193; + goto yy107; } } - yy1084: + yy191: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1087; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1086; - goto yy999; + goto yy193; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1086; + goto yy107; + goto yy193; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1086; - goto yy999; + goto yy193; + goto yy107; } } - yy1085: + yy192: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1087; + goto yy194; if (yych <= '/') - goto yy999; + goto yy107; + goto yy195; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy195; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy195; + goto yy107; } } - yy1086: + yy193: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1089; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1088; - goto yy999; + goto yy195; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1088; + goto yy107; + goto yy195; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1088; - goto yy999; + goto yy195; + goto yy107; } } - yy1087: + yy194: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1089; + goto yy196; if (yych <= '/') - goto yy999; + goto yy107; + goto yy197; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy197; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy197; + goto yy107; } } - yy1088: + yy195: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1091; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1090; - goto yy999; + goto yy197; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1090; + goto yy107; + goto yy197; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1090; - goto yy999; + goto yy197; + goto yy107; } } - yy1089: + yy196: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1091; + goto yy198; if (yych <= '/') - goto yy999; + goto yy107; + goto yy199; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy199; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy199; + goto yy107; } } - yy1090: + yy197: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1093; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1092; - goto yy999; + goto yy199; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1092; + goto yy107; + goto yy199; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1092; - goto yy999; + goto yy199; + goto yy107; } } - yy1091: + yy198: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1093; + goto yy200; if (yych <= '/') - goto yy999; + goto yy107; + goto yy201; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy201; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy201; + goto yy107; } } - yy1092: + yy199: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1095; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1094; - goto yy999; + goto yy201; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1094; + goto yy107; + goto yy201; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1094; - goto yy999; + goto yy201; + goto yy107; } } - yy1093: + yy200: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1095; + goto yy202; if (yych <= '/') - goto yy999; + goto yy107; + goto yy203; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy203; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy203; + goto yy107; } } - yy1094: + yy201: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1097; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1096; - goto yy999; + goto yy203; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1096; + goto yy107; + goto yy203; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1096; - goto yy999; + goto yy203; + goto yy107; } } - yy1095: + yy202: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1097; + goto yy204; if (yych <= '/') - goto yy999; + goto yy107; + goto yy205; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy205; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy205; + goto yy107; } } - yy1096: + yy203: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1099; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1098; - goto yy999; + goto yy205; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1098; + goto yy107; + goto yy205; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1098; - goto yy999; + goto yy205; + goto yy107; } } - yy1097: + yy204: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1099; + goto yy206; if (yych <= '/') - goto yy999; + goto yy107; + goto yy207; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy207; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy207; + goto yy107; } } - yy1098: + yy205: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1101; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1100; - goto yy999; + goto yy207; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1100; + goto yy107; + goto yy207; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1100; - goto yy999; + goto yy207; + goto yy107; } } - yy1099: + yy206: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1101; + goto yy208; if (yych <= '/') - goto yy999; + goto yy107; + goto yy209; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy209; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy209; + goto yy107; } } - yy1100: + yy207: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1103; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1102; - goto yy999; + goto yy209; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1102; + goto yy107; + goto yy209; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1102; - goto yy999; + goto yy209; + goto yy107; } } - yy1101: + yy208: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1103; + goto yy210; if (yych <= '/') - goto yy999; + goto yy107; + goto yy211; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy211; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy211; + goto yy107; } } - yy1102: + yy209: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1105; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1104; - goto yy999; + goto yy211; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1104; + goto yy107; + goto yy211; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1104; - goto yy999; + goto yy211; + goto yy107; } } - yy1103: + yy210: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1105; + goto yy212; if (yych <= '/') - goto yy999; + goto yy107; + goto yy213; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy213; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy213; + goto yy107; } } - yy1104: + yy211: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1107; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1106; - goto yy999; + goto yy213; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1106; + goto yy107; + goto yy213; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1106; - goto yy999; + goto yy213; + goto yy107; } } - yy1105: + yy212: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1107; + goto yy214; if (yych <= '/') - goto yy999; + goto yy107; + goto yy215; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy215; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy215; + goto yy107; } } - yy1106: + yy213: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1109; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1108; - goto yy999; + goto yy215; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1108; + goto yy107; + goto yy215; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1108; - goto yy999; + goto yy215; + goto yy107; } } - yy1107: + yy214: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1109; + goto yy216; if (yych <= '/') - goto yy999; + goto yy107; + goto yy217; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy217; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy217; + goto yy107; } } - yy1108: + yy215: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1111; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1110; - goto yy999; + goto yy217; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1110; + goto yy107; + goto yy217; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1110; - goto yy999; + goto yy217; + goto yy107; } } - yy1109: + yy216: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1111; + goto yy218; if (yych <= '/') - goto yy999; + goto yy107; + goto yy219; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy219; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy219; + goto yy107; } } - yy1110: + yy217: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1113; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1112; - goto yy999; + goto yy219; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1112; + goto yy107; + goto yy219; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1112; - goto yy999; + goto yy219; + goto yy107; } } - yy1111: + yy218: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1113; + goto yy220; if (yych <= '/') - goto yy999; + goto yy107; + goto yy221; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy221; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy221; + goto yy107; } } - yy1112: + yy219: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1115; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1114; - goto yy999; + goto yy221; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1114; + goto yy107; + goto yy221; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1114; - goto yy999; + goto yy221; + goto yy107; } } - yy1113: + yy220: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1115; + goto yy222; if (yych <= '/') - goto yy999; + goto yy107; + goto yy223; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy223; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy223; + goto yy107; } } - yy1114: + yy221: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1117; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1116; - goto yy999; + goto yy223; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1116; + goto yy107; + goto yy223; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1116; - goto yy999; + goto yy223; + goto yy107; } } - yy1115: + yy222: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1117; + goto yy224; if (yych <= '/') - goto yy999; + goto yy107; + goto yy225; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy225; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy225; + goto yy107; } } - yy1116: + yy223: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1119; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1118; - goto yy999; + goto yy225; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1118; + goto yy107; + goto yy225; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1118; - goto yy999; + goto yy225; + goto yy107; } } - yy1117: + yy224: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1119; + goto yy226; if (yych <= '/') - goto yy999; + goto yy107; + goto yy227; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy227; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy227; + goto yy107; } } - yy1118: + yy225: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1121; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1120; - goto yy999; + goto yy227; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1120; + goto yy107; + goto yy227; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1120; - goto yy999; + goto yy227; + goto yy107; } } - yy1119: + yy226: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1121; + goto yy228; if (yych <= '/') - goto yy999; + goto yy107; + goto yy229; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy229; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy229; + goto yy107; } } - yy1120: + yy227: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1123; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1122; - goto yy999; + goto yy229; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1122; + goto yy107; + goto yy229; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1122; - goto yy999; + goto yy229; + goto yy107; } } - yy1121: + yy228: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1123; + goto yy230; if (yych <= '/') - goto yy999; + goto yy107; + goto yy231; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy231; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy231; + goto yy107; } } - yy1122: + yy229: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1125; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1124; - goto yy999; + goto yy231; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1124; + goto yy107; + goto yy231; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1124; - goto yy999; + goto yy231; + goto yy107; } } - yy1123: + yy230: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1125; + goto yy232; if (yych <= '/') - goto yy999; + goto yy107; + goto yy233; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy233; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy233; + goto yy107; } } - yy1124: + yy231: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1127; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1126; - goto yy999; + goto yy233; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1126; + goto yy107; + goto yy233; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1126; - goto yy999; + goto yy233; + goto yy107; } } - yy1125: + yy232: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1127; + goto yy234; if (yych <= '/') - goto yy999; + goto yy107; + goto yy235; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy235; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy235; + goto yy107; } } - yy1126: + yy233: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1129; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1128; - goto yy999; + goto yy235; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1128; + goto yy107; + goto yy235; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1128; - goto yy999; + goto yy235; + goto yy107; } } - yy1127: + yy234: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1129; + goto yy236; if (yych <= '/') - goto yy999; + goto yy107; + goto yy237; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy237; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy237; + goto yy107; } } - yy1128: + yy235: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1131; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1130; - goto yy999; + goto yy237; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1130; + goto yy107; + goto yy237; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1130; - goto yy999; + goto yy237; + goto yy107; } } - yy1129: + yy236: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1131; + goto yy238; if (yych <= '/') - goto yy999; + goto yy107; + goto yy239; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy239; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy239; + goto yy107; } } - yy1130: + yy237: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1133; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1132; - goto yy999; + goto yy239; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1132; + goto yy107; + goto yy239; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1132; - goto yy999; + goto yy239; + goto yy107; } } - yy1131: + yy238: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1133; + goto yy240; if (yych <= '/') - goto yy999; + goto yy107; + goto yy241; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy241; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy241; + goto yy107; } } - yy1132: + yy239: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1135; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1134; - goto yy999; + goto yy241; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1134; + goto yy107; + goto yy241; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1134; - goto yy999; + goto yy241; + goto yy107; } } - yy1133: + yy240: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1135; + goto yy242; if (yych <= '/') - goto yy999; + goto yy107; + goto yy243; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy243; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy243; + goto yy107; } } - yy1134: + yy241: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1137; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1136; - goto yy999; + goto yy243; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1136; + goto yy107; + goto yy243; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1136; - goto yy999; + goto yy243; + goto yy107; } } - yy1135: + yy242: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy1137; + goto yy244; if (yych <= '/') - goto yy999; + goto yy107; + goto yy245; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy245; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy245; + goto yy107; } } - yy1136: + yy243: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { - if (yych <= '-') - goto yy999; - goto yy1012; + if (yych <= ',') + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1138; - goto yy999; + goto yy245; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1138; + goto yy107; + goto yy245; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1138; - goto yy999; + goto yy245; + goto yy107; } } - yy1137: + yy244: ++p; yych = *p; if (yych <= '@') { if (yych <= '/') - goto yy999; - if (yych >= ':') - goto yy999; + goto yy107; + if (yych <= '9') + goto yy246; + goto yy107; } else { if (yych <= 'Z') - goto yy1138; + goto yy246; if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy246; + goto yy107; } - yy1138: + yy245: ++p; yych = *p; - if (yych == '.') - goto yy1012; - if (yych == '>') - goto yy1013; - goto yy999; - yy1139: - yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') - goto yy999; if (yych <= '-') - goto yy1142; - goto yy1012; + goto yy107; + goto yy120; } else { if (yych <= '/') - goto yy999; - if (yych <= '9') - goto yy1141; - goto yy999; + goto yy107; + if (yych >= ':') + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1141; + goto yy107; } else { if (yych <= '`') - goto yy999; - if (yych <= 'z') - goto yy1141; - goto yy999; + goto yy107; + if (yych >= '{') + goto yy107; } } - yy1140: + yy246: + ++p; + yych = *p; + if (yych == '.') + goto yy120; + if (yych == '>') + goto yy121; + goto yy107; + yy247: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1142; + goto yy249; if (yych <= '/') - goto yy999; + goto yy107; + goto yy250; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy250; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy250; + goto yy107; } } - yy1141: + yy248: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1144; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1143; - goto yy999; + goto yy250; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1143; + goto yy107; + goto yy250; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1143; - goto yy999; + goto yy250; + goto yy107; } } - yy1142: + yy249: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1144; + goto yy251; if (yych <= '/') - goto yy999; + goto yy107; + goto yy252; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy252; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy252; + goto yy107; } } - yy1143: + yy250: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1146; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1145; - goto yy999; + goto yy252; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1145; + goto yy107; + goto yy252; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1145; - goto yy999; + goto yy252; + goto yy107; } } - yy1144: + yy251: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1146; + goto yy253; if (yych <= '/') - goto yy999; + goto yy107; + goto yy254; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy254; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy254; + goto yy107; } } - yy1145: + yy252: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1148; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1147; - goto yy999; + goto yy254; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1147; + goto yy107; + goto yy254; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1147; - goto yy999; + goto yy254; + goto yy107; } } - yy1146: + yy253: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1148; + goto yy255; if (yych <= '/') - goto yy999; + goto yy107; + goto yy256; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy256; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy256; + goto yy107; } } - yy1147: + yy254: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1150; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1149; - goto yy999; + goto yy256; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1149; + goto yy107; + goto yy256; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1149; - goto yy999; + goto yy256; + goto yy107; } } - yy1148: + yy255: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1150; + goto yy257; if (yych <= '/') - goto yy999; + goto yy107; + goto yy258; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy258; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy258; + goto yy107; } } - yy1149: + yy256: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1152; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1151; - goto yy999; + goto yy258; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1151; + goto yy107; + goto yy258; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1151; - goto yy999; + goto yy258; + goto yy107; } } - yy1150: + yy257: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1152; + goto yy259; if (yych <= '/') - goto yy999; + goto yy107; + goto yy260; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy260; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy260; + goto yy107; } } - yy1151: + yy258: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1154; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1153; - goto yy999; + goto yy260; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1153; + goto yy107; + goto yy260; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1153; - goto yy999; + goto yy260; + goto yy107; } } - yy1152: + yy259: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1154; + goto yy261; if (yych <= '/') - goto yy999; + goto yy107; + goto yy262; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy262; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy262; + goto yy107; } } - yy1153: + yy260: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1156; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1155; - goto yy999; + goto yy262; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1155; + goto yy107; + goto yy262; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1155; - goto yy999; + goto yy262; + goto yy107; } } - yy1154: + yy261: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1156; + goto yy263; if (yych <= '/') - goto yy999; + goto yy107; + goto yy264; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy264; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy264; + goto yy107; } } - yy1155: + yy262: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1158; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1157; - goto yy999; + goto yy264; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1157; + goto yy107; + goto yy264; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1157; - goto yy999; + goto yy264; + goto yy107; } } - yy1156: + yy263: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1158; + goto yy265; if (yych <= '/') - goto yy999; + goto yy107; + goto yy266; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy266; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy266; + goto yy107; } } - yy1157: + yy264: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1160; - goto yy1012; + if (yych <= ',') + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1159; - goto yy999; + goto yy266; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1159; + goto yy107; + goto yy266; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1159; - goto yy999; + goto yy266; + goto yy107; } } - yy1158: + yy265: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1160; + goto yy267; if (yych <= '/') - goto yy999; + goto yy107; + goto yy268; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy268; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy268; + goto yy107; } } - yy1159: + yy266: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1162; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1161; - goto yy999; + goto yy268; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1161; + goto yy107; + goto yy268; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1161; - goto yy999; + goto yy268; + goto yy107; } } - yy1160: + yy267: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1162; + goto yy269; if (yych <= '/') - goto yy999; + goto yy107; + goto yy270; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy270; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy270; + goto yy107; } } - yy1161: + yy268: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1164; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1163; - goto yy999; + goto yy270; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1163; + goto yy107; + goto yy270; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1163; - goto yy999; + goto yy270; + goto yy107; } } - yy1162: + yy269: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1164; + goto yy271; if (yych <= '/') - goto yy999; + goto yy107; + goto yy272; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy272; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy272; + goto yy107; } } - yy1163: + yy270: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1166; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1165; - goto yy999; + goto yy272; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1165; + goto yy107; + goto yy272; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1165; - goto yy999; + goto yy272; + goto yy107; } } - yy1164: + yy271: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1166; + goto yy273; if (yych <= '/') - goto yy999; + goto yy107; + goto yy274; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy274; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy274; + goto yy107; } } - yy1165: + yy272: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1168; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1167; - goto yy999; + goto yy274; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1167; + goto yy107; + goto yy274; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1167; - goto yy999; + goto yy274; + goto yy107; } } - yy1166: + yy273: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1168; + goto yy275; if (yych <= '/') - goto yy999; + goto yy107; + goto yy276; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy276; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy276; + goto yy107; } } - yy1167: + yy274: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1170; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1169; - goto yy999; + goto yy276; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1169; + goto yy107; + goto yy276; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1169; - goto yy999; + goto yy276; + goto yy107; } } - yy1168: + yy275: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1170; + goto yy277; if (yych <= '/') - goto yy999; + goto yy107; + goto yy278; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy278; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy278; + goto yy107; } } - yy1169: + yy276: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1172; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1171; - goto yy999; + goto yy278; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1171; + goto yy107; + goto yy278; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1171; - goto yy999; + goto yy278; + goto yy107; } } - yy1170: + yy277: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1172; + goto yy279; if (yych <= '/') - goto yy999; + goto yy107; + goto yy280; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy280; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy280; + goto yy107; } } - yy1171: + yy278: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1174; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1173; - goto yy999; + goto yy280; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1173; + goto yy107; + goto yy280; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1173; - goto yy999; + goto yy280; + goto yy107; } } - yy1172: + yy279: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1174; + goto yy281; if (yych <= '/') - goto yy999; + goto yy107; + goto yy282; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy282; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy282; + goto yy107; } } - yy1173: + yy280: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1176; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1175; - goto yy999; + goto yy282; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1175; + goto yy107; + goto yy282; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1175; - goto yy999; + goto yy282; + goto yy107; } } - yy1174: + yy281: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1176; + goto yy283; if (yych <= '/') - goto yy999; + goto yy107; + goto yy284; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy284; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy284; + goto yy107; } } - yy1175: + yy282: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1178; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1177; - goto yy999; + goto yy284; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1177; + goto yy107; + goto yy284; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1177; - goto yy999; + goto yy284; + goto yy107; } } - yy1176: + yy283: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1178; + goto yy285; if (yych <= '/') - goto yy999; + goto yy107; + goto yy286; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy286; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy286; + goto yy107; } } - yy1177: + yy284: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1180; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1179; - goto yy999; + goto yy286; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1179; + goto yy107; + goto yy286; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1179; - goto yy999; + goto yy286; + goto yy107; } } - yy1178: + yy285: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1180; + goto yy287; if (yych <= '/') - goto yy999; + goto yy107; + goto yy288; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy288; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy288; + goto yy107; } } - yy1179: + yy286: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1182; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1181; - goto yy999; + goto yy288; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1181; + goto yy107; + goto yy288; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1181; - goto yy999; + goto yy288; + goto yy107; } } - yy1180: + yy287: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1182; + goto yy289; if (yych <= '/') - goto yy999; + goto yy107; + goto yy290; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy290; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy290; + goto yy107; } } - yy1181: + yy288: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1184; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1183; - goto yy999; + goto yy290; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1183; + goto yy107; + goto yy290; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1183; - goto yy999; + goto yy290; + goto yy107; } } - yy1182: + yy289: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1184; + goto yy291; if (yych <= '/') - goto yy999; + goto yy107; + goto yy292; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy292; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy292; + goto yy107; } } - yy1183: + yy290: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1186; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1185; - goto yy999; + goto yy292; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1185; + goto yy107; + goto yy292; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1185; - goto yy999; + goto yy292; + goto yy107; } } - yy1184: + yy291: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1186; + goto yy293; if (yych <= '/') - goto yy999; + goto yy107; + goto yy294; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy294; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy294; + goto yy107; } } - yy1185: + yy292: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1188; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1187; - goto yy999; + goto yy294; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1187; + goto yy107; + goto yy294; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1187; - goto yy999; + goto yy294; + goto yy107; } } - yy1186: + yy293: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1188; + goto yy295; if (yych <= '/') - goto yy999; + goto yy107; + goto yy296; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy296; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy296; + goto yy107; } } - yy1187: + yy294: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1190; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1189; - goto yy999; + goto yy296; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1189; + goto yy107; + goto yy296; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1189; - goto yy999; + goto yy296; + goto yy107; } } - yy1188: + yy295: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1190; + goto yy297; if (yych <= '/') - goto yy999; + goto yy107; + goto yy298; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy298; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy298; + goto yy107; } } - yy1189: + yy296: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1192; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1191; - goto yy999; + goto yy298; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1191; + goto yy107; + goto yy298; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1191; - goto yy999; + goto yy298; + goto yy107; } } - yy1190: + yy297: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1192; + goto yy299; if (yych <= '/') - goto yy999; + goto yy107; + goto yy300; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy300; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy300; + goto yy107; } } - yy1191: + yy298: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1194; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1193; - goto yy999; + goto yy300; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1193; + goto yy107; + goto yy300; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1193; - goto yy999; + goto yy300; + goto yy107; } } - yy1192: + yy299: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1194; + goto yy301; if (yych <= '/') - goto yy999; + goto yy107; + goto yy302; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy302; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy302; + goto yy107; } } - yy1193: + yy300: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1196; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1195; - goto yy999; + goto yy302; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1195; + goto yy107; + goto yy302; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1195; - goto yy999; + goto yy302; + goto yy107; } } - yy1194: + yy301: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1196; + goto yy303; if (yych <= '/') - goto yy999; + goto yy107; + goto yy304; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy304; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy304; + goto yy107; } } - yy1195: + yy302: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1198; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1197; - goto yy999; + goto yy304; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1197; + goto yy107; + goto yy304; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1197; - goto yy999; + goto yy304; + goto yy107; } } - yy1196: + yy303: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1198; + goto yy305; if (yych <= '/') - goto yy999; + goto yy107; + goto yy306; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy306; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy306; + goto yy107; } } - yy1197: + yy304: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1200; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1199; - goto yy999; + goto yy306; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1199; + goto yy107; + goto yy306; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1199; - goto yy999; + goto yy306; + goto yy107; } } - yy1198: + yy305: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1200; + goto yy307; if (yych <= '/') - goto yy999; + goto yy107; + goto yy308; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy308; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy308; + goto yy107; } } - yy1199: + yy306: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1202; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1201; - goto yy999; + goto yy308; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1201; + goto yy107; + goto yy308; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1201; - goto yy999; + goto yy308; + goto yy107; } } - yy1200: + yy307: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1202; + goto yy309; if (yych <= '/') - goto yy999; + goto yy107; + goto yy310; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy310; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy310; + goto yy107; } } - yy1201: + yy308: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1204; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1203; - goto yy999; + goto yy310; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1203; + goto yy107; + goto yy310; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1203; - goto yy999; + goto yy310; + goto yy107; } } - yy1202: + yy309: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1204; + goto yy311; if (yych <= '/') - goto yy999; + goto yy107; + goto yy312; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy312; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy312; + goto yy107; } } - yy1203: + yy310: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1206; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1205; - goto yy999; + goto yy312; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1205; + goto yy107; + goto yy312; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1205; - goto yy999; + goto yy312; + goto yy107; } } - yy1204: + yy311: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1206; + goto yy313; if (yych <= '/') - goto yy999; + goto yy107; + goto yy314; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy314; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy314; + goto yy107; } } - yy1205: + yy312: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1208; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1207; - goto yy999; + goto yy314; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1207; + goto yy107; + goto yy314; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1207; - goto yy999; + goto yy314; + goto yy107; } } - yy1206: + yy313: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1208; + goto yy315; if (yych <= '/') - goto yy999; + goto yy107; + goto yy316; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy316; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy316; + goto yy107; } } - yy1207: + yy314: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1210; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1209; - goto yy999; + goto yy316; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1209; + goto yy107; + goto yy316; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1209; - goto yy999; + goto yy316; + goto yy107; } } - yy1208: + yy315: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1210; + goto yy317; if (yych <= '/') - goto yy999; + goto yy107; + goto yy318; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy318; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy318; + goto yy107; } } - yy1209: + yy316: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1212; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1211; - goto yy999; + goto yy318; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1211; + goto yy107; + goto yy318; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1211; - goto yy999; + goto yy318; + goto yy107; } } - yy1210: + yy317: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1212; + goto yy319; if (yych <= '/') - goto yy999; + goto yy107; + goto yy320; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy320; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy320; + goto yy107; } } - yy1211: + yy318: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1214; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1213; - goto yy999; + goto yy320; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1213; + goto yy107; + goto yy320; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1213; - goto yy999; + goto yy320; + goto yy107; } } - yy1212: + yy319: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1214; + goto yy321; if (yych <= '/') - goto yy999; + goto yy107; + goto yy322; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy322; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy322; + goto yy107; } } - yy1213: + yy320: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1216; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1215; - goto yy999; + goto yy322; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1215; + goto yy107; + goto yy322; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1215; - goto yy999; + goto yy322; + goto yy107; } } - yy1214: + yy321: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1216; + goto yy323; if (yych <= '/') - goto yy999; + goto yy107; + goto yy324; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy324; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy324; + goto yy107; } } - yy1215: + yy322: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1218; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1217; - goto yy999; + goto yy324; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1217; + goto yy107; + goto yy324; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1217; - goto yy999; + goto yy324; + goto yy107; } } - yy1216: + yy323: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1218; + goto yy325; if (yych <= '/') - goto yy999; + goto yy107; + goto yy326; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy326; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy326; + goto yy107; } } - yy1217: + yy324: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1220; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1219; - goto yy999; + goto yy326; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1219; + goto yy107; + goto yy326; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1219; - goto yy999; + goto yy326; + goto yy107; } } - yy1218: + yy325: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1220; + goto yy327; if (yych <= '/') - goto yy999; + goto yy107; + goto yy328; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy328; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy328; + goto yy107; } } - yy1219: + yy326: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1222; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1221; - goto yy999; + goto yy328; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1221; + goto yy107; + goto yy328; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1221; - goto yy999; + goto yy328; + goto yy107; } } - yy1220: + yy327: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1222; + goto yy329; if (yych <= '/') - goto yy999; + goto yy107; + goto yy330; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy330; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy330; + goto yy107; } } - yy1221: + yy328: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1224; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1223; - goto yy999; + goto yy330; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1223; + goto yy107; + goto yy330; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1223; - goto yy999; + goto yy330; + goto yy107; } } - yy1222: + yy329: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1224; + goto yy331; if (yych <= '/') - goto yy999; + goto yy107; + goto yy332; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy332; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy332; + goto yy107; } } - yy1223: + yy330: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1226; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1225; - goto yy999; + goto yy332; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1225; + goto yy107; + goto yy332; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1225; - goto yy999; + goto yy332; + goto yy107; } } - yy1224: + yy331: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1226; + goto yy333; if (yych <= '/') - goto yy999; + goto yy107; + goto yy334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy334; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy334; + goto yy107; } } - yy1225: + yy332: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1228; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1227; - goto yy999; + goto yy334; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1227; + goto yy107; + goto yy334; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1227; - goto yy999; + goto yy334; + goto yy107; } } - yy1226: + yy333: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1228; + goto yy335; if (yych <= '/') - goto yy999; + goto yy107; + goto yy336; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy336; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy336; + goto yy107; } } - yy1227: + yy334: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1230; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1229; - goto yy999; + goto yy336; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1229; + goto yy107; + goto yy336; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1229; - goto yy999; + goto yy336; + goto yy107; } } - yy1228: + yy335: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1230; + goto yy337; if (yych <= '/') - goto yy999; + goto yy107; + goto yy338; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy338; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy338; + goto yy107; } } - yy1229: + yy336: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1232; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1231; - goto yy999; + goto yy338; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1231; + goto yy107; + goto yy338; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1231; - goto yy999; + goto yy338; + goto yy107; } } - yy1230: + yy337: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1232; + goto yy339; if (yych <= '/') - goto yy999; + goto yy107; + goto yy340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy340; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy340; + goto yy107; } } - yy1231: + yy338: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1234; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1233; - goto yy999; + goto yy340; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1233; + goto yy107; + goto yy340; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1233; - goto yy999; + goto yy340; + goto yy107; } } - yy1232: + yy339: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1234; + goto yy341; if (yych <= '/') - goto yy999; + goto yy107; + goto yy342; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy342; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy342; + goto yy107; } } - yy1233: + yy340: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1236; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1235; - goto yy999; + goto yy342; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1235; + goto yy107; + goto yy342; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1235; - goto yy999; + goto yy342; + goto yy107; } } - yy1234: + yy341: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1236; + goto yy343; if (yych <= '/') - goto yy999; + goto yy107; + goto yy344; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy344; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy344; + goto yy107; } } - yy1235: + yy342: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1238; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1237; - goto yy999; + goto yy344; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1237; + goto yy107; + goto yy344; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1237; - goto yy999; + goto yy344; + goto yy107; } } - yy1236: + yy343: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1238; + goto yy345; if (yych <= '/') - goto yy999; + goto yy107; + goto yy346; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy346; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy346; + goto yy107; } } - yy1237: + yy344: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1240; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1239; - goto yy999; + goto yy346; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1239; + goto yy107; + goto yy346; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1239; - goto yy999; + goto yy346; + goto yy107; } } - yy1238: + yy345: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1240; + goto yy347; if (yych <= '/') - goto yy999; + goto yy107; + goto yy348; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy348; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy348; + goto yy107; } } - yy1239: + yy346: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1242; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1241; - goto yy999; + goto yy348; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1241; + goto yy107; + goto yy348; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1241; - goto yy999; + goto yy348; + goto yy107; } } - yy1240: + yy347: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1242; + goto yy349; if (yych <= '/') - goto yy999; + goto yy107; + goto yy350; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy350; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy350; + goto yy107; } } - yy1241: + yy348: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1244; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1243; - goto yy999; + goto yy350; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1243; + goto yy107; + goto yy350; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1243; - goto yy999; + goto yy350; + goto yy107; } } - yy1242: + yy349: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1244; + goto yy351; if (yych <= '/') - goto yy999; + goto yy107; + goto yy352; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy352; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy352; + goto yy107; } } - yy1243: + yy350: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1246; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1245; - goto yy999; + goto yy352; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1245; + goto yy107; + goto yy352; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1245; - goto yy999; + goto yy352; + goto yy107; } } - yy1244: + yy351: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1246; + goto yy353; if (yych <= '/') - goto yy999; + goto yy107; + goto yy354; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy354; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy354; + goto yy107; } } - yy1245: + yy352: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1248; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1247; - goto yy999; + goto yy354; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1247; + goto yy107; + goto yy354; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1247; - goto yy999; + goto yy354; + goto yy107; } } - yy1246: + yy353: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1248; + goto yy355; if (yych <= '/') - goto yy999; + goto yy107; + goto yy356; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy356; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy356; + goto yy107; } } - yy1247: + yy354: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1250; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1249; - goto yy999; + goto yy356; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1249; + goto yy107; + goto yy356; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1249; - goto yy999; + goto yy356; + goto yy107; } } - yy1248: + yy355: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1250; + goto yy357; if (yych <= '/') - goto yy999; + goto yy107; + goto yy358; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy358; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy358; + goto yy107; } } - yy1249: + yy356: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1252; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1251; - goto yy999; + goto yy358; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1251; + goto yy107; + goto yy358; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1251; - goto yy999; + goto yy358; + goto yy107; } } - yy1250: + yy357: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1252; + goto yy359; if (yych <= '/') - goto yy999; + goto yy107; + goto yy360; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy360; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy360; + goto yy107; } } - yy1251: + yy358: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1254; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1253; - goto yy999; + goto yy360; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1253; + goto yy107; + goto yy360; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1253; - goto yy999; + goto yy360; + goto yy107; } } - yy1252: + yy359: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1254; + goto yy361; if (yych <= '/') - goto yy999; + goto yy107; + goto yy362; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy362; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy362; + goto yy107; } } - yy1253: + yy360: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1256; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1255; - goto yy999; + goto yy362; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1255; + goto yy107; + goto yy362; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1255; - goto yy999; + goto yy362; + goto yy107; } } - yy1254: + yy361: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1256; + goto yy363; if (yych <= '/') - goto yy999; + goto yy107; + goto yy364; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy364; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy364; + goto yy107; } } - yy1255: + yy362: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy999; - if (yych <= '-') - goto yy1258; - goto yy1012; + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1257; - goto yy999; + goto yy364; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1257; + goto yy107; + goto yy364; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1257; - goto yy999; + goto yy364; + goto yy107; } } - yy1256: + yy363: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy1258; + goto yy365; if (yych <= '/') - goto yy999; + goto yy107; + goto yy366; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy999; + goto yy107; + goto yy366; } else { if (yych <= '`') - goto yy999; - if (yych >= '{') - goto yy999; + goto yy107; + if (yych <= 'z') + goto yy366; + goto yy107; } } - yy1257: + yy364: yych = *++p; if (yych <= '=') { if (yych <= '.') { - if (yych <= '-') - goto yy999; - goto yy1012; + if (yych <= ',') + goto yy107; + if (yych >= '.') + goto yy120; } else { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1138; - goto yy999; + goto yy366; + goto yy107; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1013; + goto yy121; if (yych <= '@') - goto yy999; - goto yy1138; + goto yy107; + goto yy366; } else { if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1138; - goto yy999; + goto yy366; + goto yy107; } } - yy1258: - ++p; - if ((yych = *p) <= '@') { + yy365: + yych = *++p; + if (yych <= '@') { if (yych <= '/') - goto yy999; + goto yy107; if (yych <= '9') - goto yy1138; - goto yy999; + goto yy246; + goto yy107; } else { if (yych <= 'Z') - goto yy1138; + goto yy246; if (yych <= '`') - goto yy999; + goto yy107; if (yych <= 'z') - goto yy1138; - goto yy999; + goto yy246; + goto yy107; + } + yy366: + ++p; + if ((yych = *p) <= '=') { + if (yych <= '.') { + if (yych <= '-') + goto yy107; + goto yy120; + } else { + if (yych <= '/') + goto yy107; + if (yych <= '9') + goto yy246; + goto yy107; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy121; + if (yych <= '@') + goto yy107; + goto yy246; + } else { + if (yych <= '`') + goto yy107; + if (yych <= 'z') + goto yy246; + goto yy107; + } } } } @@ -14834,954 +8499,946 @@ bufsize_t _scan_html_tag(const unsigned char *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, + 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, 230, 199, 230, 70, 230, 230, 230, 230, 134, 230, 230, - 230, 230, 230, 254, 246, 230, 254, 254, 254, 254, 254, 254, 254, 254, - 254, 254, 246, 230, 198, 198, 196, 230, 230, 254, 254, 254, 254, 254, + 230, 230, 230, 199, 230, 70, 230, 230, 230, 230, 134, 230, 230, 230, + 230, 230, 254, 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, 254, 230, 230, 226, 230, 246, 198, 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, 254, 230, 230, 230, - 230, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, + 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 230, 230, 230, 230, + 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* table 9 .. 11: 256 */ - 0, 160, 160, 160, 160, 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, 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, + 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, 224, 160, 160, 160, 160, 160, 160, 160, + 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, + 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); if (yych <= '`') { if (yych <= '.') { if (yych <= '\n') { if (yych <= '\t') - goto yy1266; + goto yy374; } else { if (yych == '!') - goto yy1264; - goto yy1266; + goto yy372; + goto yy374; } } else { if (yych <= '?') { if (yych <= '/') - goto yy1263; + goto yy371; if (yych <= '>') - goto yy1266; - goto yy1265; + goto yy374; + goto yy373; } else { if (yych <= '@') - goto yy1266; + goto yy374; if (yych <= 'Z') - goto yy1262; - goto yy1266; + goto yy370; + goto yy374; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 'z') - goto yy1262; + goto yy370; if (yych <= 0x7F) - goto yy1266; + goto yy374; } else { if (yych <= 0xDF) - goto yy1267; + goto yy375; if (yych <= 0xE0) - goto yy1269; - goto yy1270; + goto yy377; + goto yy378; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1274; + goto yy382; if (yych <= 0xEF) - goto yy1270; - goto yy1271; + goto yy378; + goto yy379; } else { if (yych <= 0xF3) - goto yy1272; + goto yy380; if (yych <= 0xF4) - goto yy1273; + goto yy381; } } } - yy1261 : { return 0; } - yy1262: + yy369 : { return 0; } + yy370: yych = *(marker = ++p); if (yych <= '/') { if (yych <= ' ') { if (yych <= 0x08) - goto yy1261; + goto yy369; if (yych <= '\r') - goto yy1366; + goto yy474; if (yych <= 0x1F) - goto yy1261; - goto yy1366; + goto yy369; + goto yy474; } else { if (yych == '-') - goto yy1364; + goto yy472; if (yych <= '.') - goto yy1261; - goto yy1368; + goto yy369; + goto yy476; } } else { if (yych <= '@') { if (yych <= '9') - goto yy1364; + goto yy472; if (yych == '>') - goto yy1285; - goto yy1261; + goto yy393; + goto yy369; } else { if (yych <= 'Z') - goto yy1364; + goto yy472; if (yych <= '`') - goto yy1261; + goto yy369; if (yych <= 'z') - goto yy1364; - goto yy1261; + goto yy472; + goto yy369; } } - yy1263: + yy371: yych = *(marker = ++p); if (yych <= '@') - goto yy1261; + goto yy369; if (yych <= 'Z') - goto yy1360; + goto yy468; if (yych <= '`') - goto yy1261; + goto yy369; if (yych <= 'z') - goto yy1360; - goto yy1261; - yy1264: + goto yy468; + goto yy369; + yy372: yych = *(marker = ++p); if (yybm[256 + yych] & 64) { - goto yy1295; + goto yy403; } if (yych == '-') - goto yy1297; + goto yy405; if (yych <= '@') - goto yy1261; + goto yy369; if (yych <= '[') - goto yy1294; - goto yy1261; - yy1265: + goto yy402; + goto yy369; + yy373: yych = *(marker = ++p); if (yych <= 0x00) - goto yy1261; + goto yy369; if (yych <= 0x7F) - goto yy1276; + goto yy384; if (yych <= 0xC1) - goto yy1261; + goto yy369; if (yych <= 0xF4) - goto yy1276; - goto yy1261; - yy1266: + goto yy384; + goto yy369; + yy374: yych = *++p; - goto yy1261; - yy1267: + goto yy369; + yy375: yych = *++p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1266; - yy1268: + goto yy374; + yy376: p = marker; - goto yy1261; - yy1269: + goto yy369; + yy377: yych = *++p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1267; - goto yy1268; - yy1270: + goto yy375; + goto yy376; + yy378: yych = *++p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1267; - goto yy1268; - yy1271: + goto yy375; + goto yy376; + yy379: yych = *++p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1270; - goto yy1268; - yy1272: + goto yy378; + goto yy376; + yy380: yych = *++p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1270; - goto yy1268; - yy1273: + goto yy378; + goto yy376; + yy381: yych = *++p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1270; - goto yy1268; - yy1274: + goto yy378; + goto yy376; + yy382: yych = *++p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1267; - goto yy1268; - yy1275: + goto yy375; + goto yy376; + yy383: ++p; yych = *p; - yy1276: + yy384: if (yybm[256 + yych] & 32) { - goto yy1275; + goto yy383; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= '?') - goto yy1284; - goto yy1268; + goto yy392; + goto yy376; } else { if (yych <= 0xDF) - goto yy1277; + goto yy385; if (yych <= 0xE0) - goto yy1278; - goto yy1279; + goto yy386; + goto yy387; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1283; + goto yy391; if (yych <= 0xEF) - goto yy1279; - goto yy1280; + goto yy387; + goto yy388; } else { if (yych <= 0xF3) - goto yy1281; + goto yy389; if (yych <= 0xF4) - goto yy1282; - goto yy1268; + goto yy390; + goto yy376; } } - yy1277: + yy385: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1275; - goto yy1268; - yy1278: + goto yy383; + goto yy376; + yy386: ++p; yych = *p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1277; - goto yy1268; - yy1279: + goto yy385; + goto yy376; + yy387: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1277; - goto yy1268; - yy1280: + goto yy385; + goto yy376; + yy388: ++p; yych = *p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1279; - goto yy1268; - yy1281: + goto yy387; + goto yy376; + yy389: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1279; - goto yy1268; - yy1282: + goto yy387; + goto yy376; + yy390: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1279; - goto yy1268; - yy1283: + goto yy387; + goto yy376; + yy391: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1277; - goto yy1268; - yy1284: + goto yy385; + goto yy376; + yy392: ++p; yych = *p; if (yych <= 0xE0) { if (yych <= '>') { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= '=') - goto yy1275; + goto yy383; } else { if (yych <= 0x7F) - goto yy1275; + goto yy383; if (yych <= 0xC1) - goto yy1268; + goto yy376; if (yych <= 0xDF) - goto yy1287; - goto yy1288; + goto yy395; + goto yy396; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1293; - goto yy1289; + goto yy401; + goto yy397; } else { if (yych <= 0xF0) - goto yy1290; + goto yy398; if (yych <= 0xF3) - goto yy1291; + goto yy399; if (yych <= 0xF4) - goto yy1292; - goto yy1268; + goto yy400; + goto yy376; } } - yy1285: + yy393: ++p; { return (bufsize_t)(p - start); } - yy1287: + yy395: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1275; - goto yy1268; - yy1288: + goto yy383; + goto yy376; + yy396: ++p; yych = *p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1287; - goto yy1268; - yy1289: + goto yy395; + goto yy376; + yy397: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1287; - goto yy1268; - yy1290: + goto yy395; + goto yy376; + yy398: ++p; yych = *p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1289; - goto yy1268; - yy1291: + goto yy397; + goto yy376; + yy399: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1289; - goto yy1268; - yy1292: + goto yy397; + goto yy376; + yy400: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1289; - goto yy1268; - yy1293: + goto yy397; + goto yy376; + yy401: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1287; - goto yy1268; - yy1294: + goto yy395; + goto yy376; + yy402: yych = *++p; if (yych == 'C') - goto yy1330; + goto yy438; if (yych == 'c') - goto yy1330; - goto yy1268; - yy1295: + goto yy438; + goto yy376; + yy403: ++p; yych = *p; if (yybm[0 + yych] & 1) { - goto yy1319; + goto yy427; } if (yych <= '@') - goto yy1268; + goto yy376; if (yych <= 'Z') - goto yy1295; - goto yy1268; - yy1297: + goto yy403; + goto yy376; + yy405: yych = *++p; if (yych != '-') - goto yy1268; + goto yy376; yych = *++p; if (yych <= 0xE0) { if (yych <= '=') { if (yych != '-') - goto yy1301; + goto yy409; } else { if (yych <= '>') - goto yy1268; + goto yy376; if (yych <= 0xC1) - goto yy1301; + goto yy409; if (yych <= 0xDF) - goto yy1302; - goto yy1303; + goto yy410; + goto yy411; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1308; - goto yy1304; + goto yy416; + goto yy412; } else { if (yych <= 0xF0) - goto yy1305; + goto yy413; if (yych <= 0xF3) - goto yy1306; + goto yy414; if (yych <= 0xF4) - goto yy1307; - goto yy1301; + goto yy415; + goto yy409; } } yych = *++p; if (yych <= 0xE0) { if (yych <= '=') { if (yych == '-') - goto yy1318; - goto yy1301; + goto yy426; + goto yy409; } else { if (yych <= '>') - goto yy1268; + goto yy376; if (yych <= 0xC1) - goto yy1301; + goto yy409; if (yych <= 0xDF) - goto yy1302; - goto yy1303; + goto yy410; + goto yy411; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1308; - goto yy1304; + goto yy416; + goto yy412; } else { if (yych <= 0xF0) - goto yy1305; + goto yy413; if (yych <= 0xF3) - goto yy1306; + goto yy414; if (yych <= 0xF4) - goto yy1307; - goto yy1301; + goto yy415; + goto yy409; } } - yy1300: + yy408: ++p; yych = *p; - yy1301: + yy409: if (yybm[256 + yych] & 128) { - goto yy1300; + goto yy408; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= '-') - goto yy1309; - goto yy1268; + goto yy417; + goto yy376; } else { if (yych <= 0xDF) - goto yy1310; + goto yy418; if (yych <= 0xE0) - goto yy1311; - goto yy1312; + goto yy419; + goto yy420; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1316; + goto yy424; if (yych <= 0xEF) - goto yy1312; - goto yy1313; + goto yy420; + goto yy421; } else { if (yych <= 0xF3) - goto yy1314; + goto yy422; if (yych <= 0xF4) - goto yy1315; - goto yy1268; + goto yy423; + goto yy376; } } - yy1302: + yy410: yych = *++p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1300; - goto yy1268; - yy1303: + goto yy408; + goto yy376; + yy411: yych = *++p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1302; - goto yy1268; - yy1304: + goto yy410; + goto yy376; + yy412: yych = *++p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1302; - goto yy1268; - yy1305: + goto yy410; + goto yy376; + yy413: yych = *++p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1304; - goto yy1268; - yy1306: + goto yy412; + goto yy376; + yy414: yych = *++p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1304; - goto yy1268; - yy1307: + goto yy412; + goto yy376; + yy415: yych = *++p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1304; - goto yy1268; - yy1308: + goto yy412; + goto yy376; + yy416: yych = *++p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1302; - goto yy1268; - yy1309: + goto yy410; + goto yy376; + yy417: ++p; yych = *p; if (yybm[256 + yych] & 128) { - goto yy1300; + goto yy408; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= '-') - goto yy1317; - goto yy1268; + goto yy425; + goto yy376; } else { if (yych <= 0xDF) - goto yy1310; + goto yy418; if (yych <= 0xE0) - goto yy1311; - goto yy1312; + goto yy419; + goto yy420; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1316; + goto yy424; if (yych <= 0xEF) - goto yy1312; - goto yy1313; + goto yy420; + goto yy421; } else { if (yych <= 0xF3) - goto yy1314; + goto yy422; if (yych <= 0xF4) - goto yy1315; - goto yy1268; + goto yy423; + goto yy376; } } - yy1310: + yy418: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1300; - goto yy1268; - yy1311: + goto yy408; + goto yy376; + yy419: ++p; yych = *p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1310; - goto yy1268; - yy1312: + goto yy418; + goto yy376; + yy420: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1310; - goto yy1268; - yy1313: + goto yy418; + goto yy376; + yy421: ++p; yych = *p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1312; - goto yy1268; - yy1314: + goto yy420; + goto yy376; + yy422: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1312; - goto yy1268; - yy1315: + goto yy420; + goto yy376; + yy423: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1312; - goto yy1268; - yy1316: + goto yy420; + goto yy376; + yy424: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1310; - goto yy1268; - yy1317: + goto yy418; + goto yy376; + yy425: yych = *++p; if (yych == '>') - goto yy1285; - goto yy1268; - yy1318: + goto yy393; + goto yy376; + yy426: yych = *++p; if (yych == '>') - goto yy1285; - goto yy1268; - yy1319: + goto yy393; + goto yy376; + yy427: ++p; yych = *p; if (yybm[0 + yych] & 1) { - goto yy1319; + goto yy427; } if (yych <= 0xE0) { if (yych <= '>') { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych >= '>') - goto yy1285; + goto yy393; } else { if (yych <= 0x7F) - goto yy1321; + goto yy429; if (yych <= 0xC1) - goto yy1268; + goto yy376; if (yych <= 0xDF) - goto yy1323; - goto yy1324; + goto yy431; + goto yy432; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1329; - goto yy1325; + goto yy437; + goto yy433; } else { if (yych <= 0xF0) - goto yy1326; + goto yy434; if (yych <= 0xF3) - goto yy1327; + goto yy435; if (yych <= 0xF4) - goto yy1328; - goto yy1268; + goto yy436; + goto yy376; } } - yy1321: + yy429: ++p; yych = *p; if (yybm[0 + yych] & 2) { - goto yy1321; + goto yy429; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= '>') - goto yy1285; - goto yy1268; + goto yy393; + goto yy376; } else { if (yych <= 0xDF) - goto yy1323; + goto yy431; if (yych <= 0xE0) - goto yy1324; - goto yy1325; + goto yy432; + goto yy433; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1329; + goto yy437; if (yych <= 0xEF) - goto yy1325; - goto yy1326; + goto yy433; + goto yy434; } else { if (yych <= 0xF3) - goto yy1327; + goto yy435; if (yych <= 0xF4) - goto yy1328; - goto yy1268; + goto yy436; + goto yy376; } } - yy1323: + yy431: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1321; - goto yy1268; - yy1324: + goto yy429; + goto yy376; + yy432: ++p; yych = *p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1323; - goto yy1268; - yy1325: + goto yy431; + goto yy376; + yy433: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1323; - goto yy1268; - yy1326: + goto yy431; + goto yy376; + yy434: ++p; yych = *p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1325; - goto yy1268; - yy1327: + goto yy433; + goto yy376; + yy435: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1325; - goto yy1268; - yy1328: + goto yy433; + goto yy376; + yy436: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1325; - goto yy1268; - yy1329: + goto yy433; + goto yy376; + yy437: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1323; - goto yy1268; - yy1330: + goto yy431; + goto yy376; + yy438: yych = *++p; if (yych == 'D') - goto yy1331; + goto yy439; if (yych != 'd') - goto yy1268; - yy1331: + goto yy376; + yy439: yych = *++p; if (yych == 'A') - goto yy1332; + goto yy440; if (yych != 'a') - goto yy1268; - yy1332: + goto yy376; + yy440: yych = *++p; if (yych == 'T') - goto yy1333; + goto yy441; if (yych != 't') - goto yy1268; - yy1333: + goto yy376; + yy441: yych = *++p; if (yych == 'A') - goto yy1334; + goto yy442; if (yych != 'a') - goto yy1268; - yy1334: + goto yy376; + yy442: yych = *++p; if (yych != '[') - goto yy1268; - yy1335: + goto yy376; + yy443: ++p; yych = *p; if (yybm[0 + yych] & 4) { - goto yy1335; + goto yy443; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= ']') - goto yy1344; - goto yy1268; + goto yy452; + goto yy376; } else { if (yych <= 0xDF) - goto yy1337; + goto yy445; if (yych <= 0xE0) - goto yy1338; - goto yy1339; + goto yy446; + goto yy447; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1343; + goto yy451; if (yych <= 0xEF) - goto yy1339; - goto yy1340; + goto yy447; + goto yy448; } else { if (yych <= 0xF3) - goto yy1341; + goto yy449; if (yych <= 0xF4) - goto yy1342; - goto yy1268; + goto yy450; + goto yy376; } } - yy1337: + yy445: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1335; - goto yy1268; - yy1338: + goto yy443; + goto yy376; + yy446: ++p; yych = *p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1337; - goto yy1268; - yy1339: + goto yy445; + goto yy376; + yy447: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1337; - goto yy1268; - yy1340: + goto yy445; + goto yy376; + yy448: ++p; yych = *p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1339; - goto yy1268; - yy1341: + goto yy447; + goto yy376; + yy449: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1339; - goto yy1268; - yy1342: + goto yy447; + goto yy376; + yy450: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1339; - goto yy1268; - yy1343: + goto yy447; + goto yy376; + yy451: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1337; - goto yy1268; - yy1344: + goto yy445; + goto yy376; + yy452: ++p; yych = *p; if (yybm[0 + yych] & 4) { - goto yy1335; + goto yy443; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych >= '^') - goto yy1268; + goto yy376; } else { if (yych <= 0xDF) - goto yy1346; + goto yy454; if (yych <= 0xE0) - goto yy1347; - goto yy1348; + goto yy455; + goto yy456; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1352; + goto yy460; if (yych <= 0xEF) - goto yy1348; - goto yy1349; + goto yy456; + goto yy457; } else { if (yych <= 0xF3) - goto yy1350; + goto yy458; if (yych <= 0xF4) - goto yy1351; - goto yy1268; + goto yy459; + goto yy376; } } ++p; @@ -15789,812 +9446,812 @@ bufsize_t _scan_html_tag(const unsigned char *p) { if (yych <= 0xE0) { if (yych <= '>') { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= '=') - goto yy1335; - goto yy1285; + goto yy443; + goto yy393; } else { if (yych <= 0x7F) - goto yy1335; + goto yy443; if (yych <= 0xC1) - goto yy1268; + goto yy376; if (yych <= 0xDF) - goto yy1353; - goto yy1354; + goto yy461; + goto yy462; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1359; - goto yy1355; + goto yy467; + goto yy463; } else { if (yych <= 0xF0) - goto yy1356; + goto yy464; if (yych <= 0xF3) - goto yy1357; + goto yy465; if (yych <= 0xF4) - goto yy1358; - goto yy1268; + goto yy466; + goto yy376; } } - yy1346: + yy454: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1335; - goto yy1268; - yy1347: + goto yy443; + goto yy376; + yy455: ++p; yych = *p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1346; - goto yy1268; - yy1348: + goto yy454; + goto yy376; + yy456: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1346; - goto yy1268; - yy1349: + goto yy454; + goto yy376; + yy457: ++p; yych = *p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1348; - goto yy1268; - yy1350: + goto yy456; + goto yy376; + yy458: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1348; - goto yy1268; - yy1351: + goto yy456; + goto yy376; + yy459: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1348; - goto yy1268; - yy1352: + goto yy456; + goto yy376; + yy460: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1346; - goto yy1268; - yy1353: + goto yy454; + goto yy376; + yy461: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1335; - goto yy1268; - yy1354: + goto yy443; + goto yy376; + yy462: ++p; yych = *p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1353; - goto yy1268; - yy1355: + goto yy461; + goto yy376; + yy463: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1353; - goto yy1268; - yy1356: + goto yy461; + goto yy376; + yy464: ++p; yych = *p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1355; - goto yy1268; - yy1357: + goto yy463; + goto yy376; + yy465: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1355; - goto yy1268; - yy1358: + goto yy463; + goto yy376; + yy466: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1355; - goto yy1268; - yy1359: + goto yy463; + goto yy376; + yy467: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1353; - goto yy1268; - yy1360: + goto yy461; + goto yy376; + yy468: ++p; yych = *p; if (yybm[0 + yych] & 8) { - goto yy1360; + goto yy468; } if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1268; + goto yy376; if (yych >= 0x0E) - goto yy1268; + goto yy376; } else { if (yych <= ' ') - goto yy1362; + goto yy470; if (yych == '>') - goto yy1285; - goto yy1268; + goto yy393; + goto yy376; } - yy1362: + yy470: ++p; yych = *p; if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1268; + goto yy376; if (yych <= '\r') - goto yy1362; - goto yy1268; + goto yy470; + goto yy376; } else { if (yych <= ' ') - goto yy1362; + goto yy470; if (yych == '>') - goto yy1285; - goto yy1268; + goto yy393; + goto yy376; } - yy1364: + yy472: ++p; yych = *p; if (yych <= '/') { if (yych <= ' ') { if (yych <= 0x08) - goto yy1268; + goto yy376; if (yych <= '\r') - goto yy1366; + goto yy474; if (yych <= 0x1F) - goto yy1268; + goto yy376; } else { if (yych == '-') - goto yy1364; + goto yy472; if (yych <= '.') - goto yy1268; - goto yy1368; + goto yy376; + goto yy476; } } else { if (yych <= '@') { if (yych <= '9') - goto yy1364; + goto yy472; if (yych == '>') - goto yy1285; - goto yy1268; + goto yy393; + goto yy376; } else { if (yych <= 'Z') - goto yy1364; + goto yy472; if (yych <= '`') - goto yy1268; + goto yy376; if (yych <= 'z') - goto yy1364; - goto yy1268; + goto yy472; + goto yy376; } } - yy1366: + yy474: ++p; yych = *p; if (yych <= ':') { if (yych <= ' ') { if (yych <= 0x08) - goto yy1268; + goto yy376; if (yych <= '\r') - goto yy1366; + goto yy474; if (yych <= 0x1F) - goto yy1268; - goto yy1366; + goto yy376; + goto yy474; } else { if (yych == '/') - goto yy1368; + goto yy476; if (yych <= '9') - goto yy1268; - goto yy1369; + goto yy376; + goto yy477; } } else { if (yych <= 'Z') { if (yych == '>') - goto yy1285; + goto yy393; if (yych <= '@') - goto yy1268; - goto yy1369; + goto yy376; + goto yy477; } else { if (yych <= '_') { if (yych <= '^') - goto yy1268; - goto yy1369; + goto yy376; + goto yy477; } else { if (yych <= '`') - goto yy1268; + goto yy376; if (yych <= 'z') - goto yy1369; - goto yy1268; + goto yy477; + goto yy376; } } } - yy1368: + yy476: yych = *++p; if (yych == '>') - goto yy1285; - goto yy1268; - yy1369: + goto yy393; + goto yy376; + yy477: ++p; yych = *p; if (yybm[0 + yych] & 16) { - goto yy1369; + goto yy477; } if (yych <= ',') { if (yych <= '\r') { if (yych <= 0x08) - goto yy1268; + goto yy376; } else { if (yych != ' ') - goto yy1268; + goto yy376; } } else { if (yych <= '<') { if (yych <= '/') - goto yy1368; - goto yy1268; + goto yy476; + goto yy376; } else { if (yych <= '=') - goto yy1373; + goto yy481; if (yych <= '>') - goto yy1285; - goto yy1268; + goto yy393; + goto yy376; } } - yy1371: + yy479: ++p; yych = *p; if (yych <= '<') { if (yych <= ' ') { if (yych <= 0x08) - goto yy1268; + goto yy376; if (yych <= '\r') - goto yy1371; + goto yy479; if (yych <= 0x1F) - goto yy1268; - goto yy1371; + goto yy376; + goto yy479; } else { if (yych <= '/') { if (yych <= '.') - goto yy1268; - goto yy1368; + goto yy376; + goto yy476; } else { if (yych == ':') - goto yy1369; - goto yy1268; + goto yy477; + goto yy376; } } } else { if (yych <= 'Z') { if (yych <= '=') - goto yy1373; + goto yy481; if (yych <= '>') - goto yy1285; + goto yy393; if (yych <= '@') - goto yy1268; - goto yy1369; + goto yy376; + goto yy477; } else { if (yych <= '_') { if (yych <= '^') - goto yy1268; - goto yy1369; + goto yy376; + goto yy477; } else { if (yych <= '`') - goto yy1268; + goto yy376; if (yych <= 'z') - goto yy1369; - goto yy1268; + goto yy477; + goto yy376; } } } - yy1373: + yy481: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1375; + goto yy483; } if (yych <= 0xE0) { if (yych <= '"') { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych >= '!') - goto yy1386; + goto yy494; } else { if (yych <= '\'') - goto yy1384; + goto yy492; if (yych <= 0xC1) - goto yy1268; + goto yy376; if (yych <= 0xDF) - goto yy1377; - goto yy1378; + goto yy485; + goto yy486; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1383; - goto yy1379; + goto yy491; + goto yy487; } else { if (yych <= 0xF0) - goto yy1380; + goto yy488; if (yych <= 0xF3) - goto yy1381; + goto yy489; if (yych <= 0xF4) - goto yy1382; - goto yy1268; + goto yy490; + goto yy376; } } ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1375; + goto yy483; } if (yych <= 0xDF) { if (yych <= '\'') { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= ' ') - goto yy1409; + goto yy517; if (yych <= '"') - goto yy1386; - goto yy1384; + goto yy494; + goto yy492; } else { if (yych == '>') - goto yy1285; + goto yy393; if (yych <= 0xC1) - goto yy1268; - goto yy1377; + goto yy376; + goto yy485; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1378; + goto yy486; if (yych == 0xED) - goto yy1383; - goto yy1379; + goto yy491; + goto yy487; } else { if (yych <= 0xF0) - goto yy1380; + goto yy488; if (yych <= 0xF3) - goto yy1381; + goto yy489; if (yych <= 0xF4) - goto yy1382; - goto yy1268; + goto yy490; + goto yy376; } } - yy1375: + yy483: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1375; + goto yy483; } if (yych <= 0xE0) { if (yych <= '=') { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= ' ') - goto yy1403; - goto yy1268; + goto yy511; + goto yy376; } else { if (yych <= '>') - goto yy1285; + goto yy393; if (yych <= 0xC1) - goto yy1268; + goto yy376; if (yych >= 0xE0) - goto yy1378; + goto yy486; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1383; - goto yy1379; + goto yy491; + goto yy487; } else { if (yych <= 0xF0) - goto yy1380; + goto yy488; if (yych <= 0xF3) - goto yy1381; + goto yy489; if (yych <= 0xF4) - goto yy1382; - goto yy1268; + goto yy490; + goto yy376; } } - yy1377: + yy485: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1375; - goto yy1268; - yy1378: + goto yy483; + goto yy376; + yy486: ++p; yych = *p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1377; - goto yy1268; - yy1379: + goto yy485; + goto yy376; + yy487: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1377; - goto yy1268; - yy1380: + goto yy485; + goto yy376; + yy488: ++p; yych = *p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1379; - goto yy1268; - yy1381: + goto yy487; + goto yy376; + yy489: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1379; - goto yy1268; - yy1382: + goto yy487; + goto yy376; + yy490: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1379; - goto yy1268; - yy1383: + goto yy487; + goto yy376; + yy491: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1377; - goto yy1268; - yy1384: + goto yy485; + goto yy376; + yy492: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1384; + goto yy492; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= '\'') - goto yy1395; - goto yy1268; + goto yy503; + goto yy376; } else { if (yych <= 0xDF) - goto yy1396; + goto yy504; if (yych <= 0xE0) - goto yy1397; - goto yy1398; + goto yy505; + goto yy506; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1402; + goto yy510; if (yych <= 0xEF) - goto yy1398; - goto yy1399; + goto yy506; + goto yy507; } else { if (yych <= 0xF3) - goto yy1400; + goto yy508; if (yych <= 0xF4) - goto yy1401; - goto yy1268; + goto yy509; + goto yy376; } } - yy1386: + yy494: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1386; + goto yy494; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= '"') - goto yy1395; - goto yy1268; + goto yy503; + goto yy376; } else { if (yych <= 0xDF) - goto yy1388; + goto yy496; if (yych <= 0xE0) - goto yy1389; - goto yy1390; + goto yy497; + goto yy498; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1394; + goto yy502; if (yych <= 0xEF) - goto yy1390; - goto yy1391; + goto yy498; + goto yy499; } else { if (yych <= 0xF3) - goto yy1392; + goto yy500; if (yych <= 0xF4) - goto yy1393; - goto yy1268; + goto yy501; + goto yy376; } } - yy1388: + yy496: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1386; - goto yy1268; - yy1389: + goto yy494; + goto yy376; + yy497: ++p; yych = *p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1388; - goto yy1268; - yy1390: + goto yy496; + goto yy376; + yy498: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1388; - goto yy1268; - yy1391: + goto yy496; + goto yy376; + yy499: ++p; yych = *p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1390; - goto yy1268; - yy1392: + goto yy498; + goto yy376; + yy500: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1390; - goto yy1268; - yy1393: + goto yy498; + goto yy376; + yy501: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1390; - goto yy1268; - yy1394: + goto yy498; + goto yy376; + yy502: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1388; - goto yy1268; - yy1395: + goto yy496; + goto yy376; + yy503: ++p; yych = *p; if (yych <= ' ') { if (yych <= 0x08) - goto yy1268; + goto yy376; if (yych <= '\r') - goto yy1366; + goto yy474; if (yych <= 0x1F) - goto yy1268; - goto yy1366; + goto yy376; + goto yy474; } else { if (yych <= '/') { if (yych <= '.') - goto yy1268; - goto yy1368; + goto yy376; + goto yy476; } else { if (yych == '>') - goto yy1285; - goto yy1268; + goto yy393; + goto yy376; } } - yy1396: + yy504: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1384; - goto yy1268; - yy1397: + goto yy492; + goto yy376; + yy505: ++p; yych = *p; if (yych <= 0x9F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1396; - goto yy1268; - yy1398: + goto yy504; + goto yy376; + yy506: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1396; - goto yy1268; - yy1399: + goto yy504; + goto yy376; + yy507: ++p; yych = *p; if (yych <= 0x8F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1398; - goto yy1268; - yy1400: + goto yy506; + goto yy376; + yy508: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0xBF) - goto yy1398; - goto yy1268; - yy1401: + goto yy506; + goto yy376; + yy509: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x8F) - goto yy1398; - goto yy1268; - yy1402: + goto yy506; + goto yy376; + yy510: ++p; yych = *p; if (yych <= 0x7F) - goto yy1268; + goto yy376; if (yych <= 0x9F) - goto yy1396; - goto yy1268; - yy1403: + goto yy504; + goto yy376; + yy511: ++p; yych = *p; if (yych <= '@') { if (yych <= '"') { if (yych <= '\r') { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= 0x08) - goto yy1375; - goto yy1403; + goto yy483; + goto yy511; } else { if (yych == ' ') - goto yy1403; + goto yy511; if (yych <= '!') - goto yy1375; - goto yy1268; + goto yy483; + goto yy376; } } else { if (yych <= ':') { if (yych == '\'') - goto yy1268; + goto yy376; if (yych <= '9') - goto yy1375; + goto yy483; } else { if (yych <= ';') - goto yy1375; + goto yy483; if (yych <= '=') - goto yy1268; + goto yy376; if (yych <= '>') - goto yy1285; - goto yy1375; + goto yy393; + goto yy483; } } } else { if (yych <= 0xDF) { if (yych <= '`') { if (yych <= 'Z') - goto yy1405; + goto yy513; if (yych <= '^') - goto yy1375; + goto yy483; if (yych >= '`') - goto yy1268; + goto yy376; } else { if (yych <= 'z') - goto yy1405; + goto yy513; if (yych <= 0x7F) - goto yy1375; + goto yy483; if (yych <= 0xC1) - goto yy1268; - goto yy1377; + goto yy376; + goto yy485; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1378; + goto yy486; if (yych == 0xED) - goto yy1383; - goto yy1379; + goto yy491; + goto yy487; } else { if (yych <= 0xF0) - goto yy1380; + goto yy488; if (yych <= 0xF3) - goto yy1381; + goto yy489; if (yych <= 0xF4) - goto yy1382; - goto yy1268; + goto yy490; + goto yy376; } } } - yy1405: + yy513: ++p; yych = *p; if (yych <= '>') { if (yych <= '&') { if (yych <= 0x1F) { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= 0x08) - goto yy1375; + goto yy483; if (yych >= 0x0E) - goto yy1375; + goto yy483; } else { if (yych <= ' ') - goto yy1407; + goto yy515; if (yych == '"') - goto yy1268; - goto yy1375; + goto yy376; + goto yy483; } } else { if (yych <= '/') { if (yych <= '\'') - goto yy1268; + goto yy376; if (yych <= ',') - goto yy1375; + goto yy483; if (yych <= '.') - goto yy1405; - goto yy1375; + goto yy513; + goto yy483; } else { if (yych <= ';') { if (yych <= ':') - goto yy1405; - goto yy1375; + goto yy513; + goto yy483; } else { if (yych <= '<') - goto yy1268; + goto yy376; if (yych <= '=') - goto yy1373; - goto yy1285; + goto yy481; + goto yy393; } } } @@ -16602,188 +10259,188 @@ bufsize_t _scan_html_tag(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '_') { if (yych <= '@') - goto yy1375; + goto yy483; if (yych <= 'Z') - goto yy1405; + goto yy513; if (yych <= '^') - goto yy1375; - goto yy1405; + goto yy483; + goto yy513; } else { if (yych <= '`') - goto yy1268; + goto yy376; if (yych <= 'z') - goto yy1405; + goto yy513; if (yych <= 0x7F) - goto yy1375; - goto yy1268; + goto yy483; + goto yy376; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1377; + goto yy485; if (yych <= 0xE0) - goto yy1378; + goto yy486; if (yych <= 0xEC) - goto yy1379; - goto yy1383; + goto yy487; + goto yy491; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1379; - goto yy1380; + goto yy487; + goto yy488; } else { if (yych <= 0xF3) - goto yy1381; + goto yy489; if (yych <= 0xF4) - goto yy1382; - goto yy1268; + goto yy490; + goto yy376; } } } } - yy1407: + yy515: ++p; yych = *p; if (yych <= '@') { if (yych <= '&') { if (yych <= 0x1F) { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= 0x08) - goto yy1375; + goto yy483; if (yych <= '\r') - goto yy1407; - goto yy1375; + goto yy515; + goto yy483; } else { if (yych <= ' ') - goto yy1407; + goto yy515; if (yych == '"') - goto yy1268; - goto yy1375; + goto yy376; + goto yy483; } } else { if (yych <= ';') { if (yych <= '\'') - goto yy1268; + goto yy376; if (yych == ':') - goto yy1405; - goto yy1375; + goto yy513; + goto yy483; } else { if (yych <= '<') - goto yy1268; + goto yy376; if (yych <= '=') - goto yy1373; + goto yy481; if (yych <= '>') - goto yy1285; - goto yy1375; + goto yy393; + goto yy483; } } } else { if (yych <= 0xDF) { if (yych <= '`') { if (yych <= 'Z') - goto yy1405; + goto yy513; if (yych <= '^') - goto yy1375; + goto yy483; if (yych <= '_') - goto yy1405; - goto yy1268; + goto yy513; + goto yy376; } else { if (yych <= 'z') - goto yy1405; + goto yy513; if (yych <= 0x7F) - goto yy1375; + goto yy483; if (yych <= 0xC1) - goto yy1268; - goto yy1377; + goto yy376; + goto yy485; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1378; + goto yy486; if (yych == 0xED) - goto yy1383; - goto yy1379; + goto yy491; + goto yy487; } else { if (yych <= 0xF0) - goto yy1380; + goto yy488; if (yych <= 0xF3) - goto yy1381; + goto yy489; if (yych <= 0xF4) - goto yy1382; - goto yy1268; + goto yy490; + goto yy376; } } } - yy1409: + yy517: ++p; yych = *p; if (yych <= '@') { if (yych <= '"') { if (yych <= '\r') { if (yych <= 0x00) - goto yy1268; + goto yy376; if (yych <= 0x08) - goto yy1375; - goto yy1409; + goto yy483; + goto yy517; } else { if (yych == ' ') - goto yy1409; + goto yy517; if (yych <= '!') - goto yy1375; - goto yy1386; + goto yy483; + goto yy494; } } else { if (yych <= ':') { if (yych == '\'') - goto yy1384; + goto yy492; if (yych <= '9') - goto yy1375; - goto yy1405; + goto yy483; + goto yy513; } else { if (yych <= ';') - goto yy1375; + goto yy483; if (yych <= '=') - goto yy1268; + goto yy376; if (yych <= '>') - goto yy1285; - goto yy1375; + goto yy393; + goto yy483; } } } else { if (yych <= 0xDF) { if (yych <= '`') { if (yych <= 'Z') - goto yy1405; + goto yy513; if (yych <= '^') - goto yy1375; + goto yy483; if (yych <= '_') - goto yy1405; - goto yy1268; + goto yy513; + goto yy376; } else { if (yych <= 'z') - goto yy1405; + goto yy513; if (yych <= 0x7F) - goto yy1375; + goto yy483; if (yych <= 0xC1) - goto yy1268; - goto yy1377; + goto yy376; + goto yy485; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1378; + goto yy486; if (yych == 0xED) - goto yy1383; - goto yy1379; + goto yy491; + goto yy487; } else { if (yych <= 0xF0) - goto yy1380; + goto yy488; if (yych <= 0xF3) - goto yy1381; + goto yy489; if (yych <= 0xF4) - goto yy1382; - goto yy1268; + goto yy490; + goto yy376; } } } @@ -16802,313 +10459,313 @@ bufsize_t _scan_html_block_start(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= ';') { if (yych != '\n') - goto yy1415; + goto yy523; } else { if (yych <= '<') - goto yy1414; + goto yy522; if (yych <= 0x7F) - goto yy1415; + goto yy523; if (yych >= 0xC2) - goto yy1416; + goto yy524; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1418; + goto yy526; if (yych == 0xED) - goto yy1423; - goto yy1419; + goto yy531; + goto yy527; } else { if (yych <= 0xF0) - goto yy1420; + goto yy528; if (yych <= 0xF3) - goto yy1421; + goto yy529; if (yych <= 0xF4) - goto yy1422; + goto yy530; } } - yy1413 : { return 0; } - yy1414: + yy521 : { return 0; } + yy522: yych = *(marker = ++p); switch (yych) { case '!': - goto yy1440; + goto yy548; case '/': - goto yy1424; + goto yy532; case '?': - goto yy1441; + goto yy549; case 'A': case 'a': - goto yy1426; + goto yy534; case 'B': case 'b': - goto yy1427; + goto yy535; case 'C': case 'c': - goto yy1428; + goto yy536; case 'D': case 'd': - goto yy1429; + goto yy537; case 'F': case 'f': - goto yy1430; + goto yy538; case 'H': case 'h': - goto yy1431; + goto yy539; case 'I': case 'i': - goto yy1432; + goto yy540; case 'L': case 'l': - goto yy1433; + goto yy541; case 'M': case 'm': - goto yy1434; + goto yy542; case 'N': case 'n': - goto yy1435; + goto yy543; case 'O': case 'o': - goto yy1436; + goto yy544; case 'P': case 'p': - goto yy1425; + goto yy533; case 'S': case 's': - goto yy1437; + goto yy545; case 'T': case 't': - goto yy1438; + goto yy546; case 'U': case 'u': - goto yy1439; + goto yy547; default: - goto yy1413; + goto yy521; } - yy1415: + yy523: yych = *++p; - goto yy1413; - yy1416: + goto yy521; + yy524: yych = *++p; if (yych <= 0x7F) - goto yy1417; + goto yy525; if (yych <= 0xBF) - goto yy1415; - yy1417: + goto yy523; + yy525: p = marker; - goto yy1413; - yy1418: + goto yy521; + yy526: yych = *++p; if (yych <= 0x9F) - goto yy1417; + goto yy525; if (yych <= 0xBF) - goto yy1416; - goto yy1417; - yy1419: + goto yy524; + goto yy525; + yy527: yych = *++p; if (yych <= 0x7F) - goto yy1417; + goto yy525; if (yych <= 0xBF) - goto yy1416; - goto yy1417; - yy1420: + goto yy524; + goto yy525; + yy528: yych = *++p; if (yych <= 0x8F) - goto yy1417; + goto yy525; if (yych <= 0xBF) - goto yy1419; - goto yy1417; - yy1421: + goto yy527; + goto yy525; + yy529: yych = *++p; if (yych <= 0x7F) - goto yy1417; + goto yy525; if (yych <= 0xBF) - goto yy1419; - goto yy1417; - yy1422: + goto yy527; + goto yy525; + yy530: yych = *++p; if (yych <= 0x7F) - goto yy1417; + goto yy525; if (yych <= 0x8F) - goto yy1419; - goto yy1417; - yy1423: + goto yy527; + goto yy525; + yy531: yych = *++p; if (yych <= 0x7F) - goto yy1417; + goto yy525; if (yych <= 0x9F) - goto yy1416; - goto yy1417; - yy1424: + goto yy524; + goto yy525; + yy532: yych = *++p; switch (yych) { case 'A': case 'a': - goto yy1426; + goto yy534; case 'B': case 'b': - goto yy1427; + goto yy535; case 'C': case 'c': - goto yy1428; + goto yy536; case 'D': case 'd': - goto yy1429; + goto yy537; case 'F': case 'f': - goto yy1430; + goto yy538; case 'H': case 'h': - goto yy1431; + goto yy539; case 'I': case 'i': - goto yy1432; + goto yy540; case 'L': case 'l': - goto yy1433; + goto yy541; case 'M': case 'm': - goto yy1434; + goto yy542; case 'N': case 'n': - goto yy1435; + goto yy543; case 'O': case 'o': - goto yy1436; + goto yy544; case 'P': case 'p': - goto yy1625; + goto yy733; case 'S': case 's': - goto yy1626; + goto yy734; case 'T': case 't': - goto yy1438; + goto yy546; case 'U': case 'u': - goto yy1439; + goto yy547; default: - goto yy1417; + goto yy525; } - yy1425: + yy533: yych = *++p; if (yych <= '>') { if (yych <= ' ') { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; + goto yy565; if (yych <= 0x1F) - goto yy1417; - goto yy1457; + goto yy525; + goto yy565; } else { if (yych == '/') - goto yy1459; + goto yy567; if (yych <= '=') - goto yy1417; - goto yy1457; + goto yy525; + goto yy565; } } else { if (yych <= 'R') { if (yych == 'A') - goto yy1622; + goto yy730; if (yych <= 'Q') - goto yy1417; - goto yy1621; + goto yy525; + goto yy729; } else { if (yych <= 'a') { if (yych <= '`') - goto yy1417; - goto yy1622; + goto yy525; + goto yy730; } else { if (yych == 'r') - goto yy1621; - goto yy1417; + goto yy729; + goto yy525; } } } - yy1426: + yy534: yych = *++p; if (yych <= 'S') { if (yych <= 'D') { if (yych <= 'C') - goto yy1417; - goto yy1610; + goto yy525; + goto yy718; } else { if (yych <= 'Q') - goto yy1417; + goto yy525; if (yych <= 'R') - goto yy1609; - goto yy1608; + goto yy717; + goto yy716; } } else { if (yych <= 'q') { if (yych == 'd') - goto yy1610; - goto yy1417; + goto yy718; + goto yy525; } else { if (yych <= 'r') - goto yy1609; + goto yy717; if (yych <= 's') - goto yy1608; - goto yy1417; + goto yy716; + goto yy525; } } - yy1427: + yy535: yych = *++p; if (yych <= 'O') { if (yych <= 'K') { if (yych == 'A') - goto yy1594; - goto yy1417; + goto yy702; + goto yy525; } else { if (yych <= 'L') - goto yy1593; + goto yy701; if (yych <= 'N') - goto yy1417; - goto yy1592; + goto yy525; + goto yy700; } } else { if (yych <= 'k') { if (yych == 'a') - goto yy1594; - goto yy1417; + goto yy702; + goto yy525; } else { if (yych <= 'l') - goto yy1593; + goto yy701; if (yych == 'o') - goto yy1592; - goto yy1417; + goto yy700; + goto yy525; } } - yy1428: + yy536: yych = *++p; if (yych <= 'O') { if (yych <= 'D') { if (yych == 'A') - goto yy1579; - goto yy1417; + goto yy687; + goto yy525; } else { if (yych <= 'E') - goto yy1578; + goto yy686; if (yych <= 'N') - goto yy1417; - goto yy1577; + goto yy525; + goto yy685; } } else { if (yych <= 'd') { if (yych == 'a') - goto yy1579; - goto yy1417; + goto yy687; + goto yy525; } else { if (yych <= 'e') - goto yy1578; + goto yy686; if (yych == 'o') - goto yy1577; - goto yy1417; + goto yy685; + goto yy525; } } - yy1429: + yy537: yych = *++p; switch (yych) { case 'D': @@ -17117,1662 +10774,1688 @@ bufsize_t _scan_html_block_start(const unsigned char *p) { case 'd': case 'l': case 't': - goto yy1456; + goto yy564; case 'E': case 'e': - goto yy1569; + goto yy677; case 'I': case 'i': - goto yy1568; + goto yy676; default: - goto yy1417; + goto yy525; } - yy1430: + yy538: yych = *++p; if (yych <= 'R') { if (yych <= 'N') { if (yych == 'I') - goto yy1544; - goto yy1417; + goto yy652; + goto yy525; } else { if (yych <= 'O') - goto yy1543; + goto yy651; if (yych <= 'Q') - goto yy1417; - goto yy1542; + goto yy525; + goto yy650; } } else { if (yych <= 'n') { if (yych == 'i') - goto yy1544; - goto yy1417; + goto yy652; + goto yy525; } else { if (yych <= 'o') - goto yy1543; + goto yy651; if (yych == 'r') - goto yy1542; - goto yy1417; + goto yy650; + goto yy525; } } - yy1431: + yy539: yych = *++p; if (yych <= 'S') { if (yych <= 'D') { if (yych == '1') - goto yy1456; - goto yy1417; + goto yy564; + goto yy525; } else { if (yych <= 'E') - goto yy1537; + goto yy645; if (yych == 'R') - goto yy1456; - goto yy1417; + goto yy564; + goto yy525; } } else { if (yych <= 'q') { if (yych <= 'T') - goto yy1536; + goto yy644; if (yych == 'e') - goto yy1537; - goto yy1417; + goto yy645; + goto yy525; } else { if (yych <= 'r') - goto yy1456; + goto yy564; if (yych == 't') - goto yy1536; - goto yy1417; + goto yy644; + goto yy525; } } - yy1432: + yy540: yych = *++p; if (yych == 'F') - goto yy1532; + goto yy640; if (yych == 'f') - goto yy1532; - goto yy1417; - yy1433: + goto yy640; + goto yy525; + yy541: yych = *++p; if (yych <= 'I') { if (yych == 'E') - goto yy1527; + goto yy635; if (yych <= 'H') - goto yy1417; - goto yy1526; + goto yy525; + goto yy634; } else { if (yych <= 'e') { if (yych <= 'd') - goto yy1417; - goto yy1527; + goto yy525; + goto yy635; } else { if (yych == 'i') - goto yy1526; - goto yy1417; + goto yy634; + goto yy525; } } - yy1434: + yy542: yych = *++p; if (yych <= 'E') { if (yych == 'A') - goto yy1518; + goto yy626; if (yych <= 'D') - goto yy1417; - goto yy1517; + goto yy525; + goto yy625; } else { if (yych <= 'a') { if (yych <= '`') - goto yy1417; - goto yy1518; + goto yy525; + goto yy626; } else { if (yych == 'e') - goto yy1517; - goto yy1417; + goto yy625; + goto yy525; } } - yy1435: + yy543: yych = *++p; if (yych <= 'O') { if (yych == 'A') - goto yy1511; + goto yy619; if (yych <= 'N') - goto yy1417; - goto yy1510; + goto yy525; + goto yy618; } else { if (yych <= 'a') { if (yych <= '`') - goto yy1417; - goto yy1511; + goto yy525; + goto yy619; } else { if (yych == 'o') - goto yy1510; - goto yy1417; + goto yy618; + goto yy525; } } - yy1436: + yy544: yych = *++p; if (yych <= 'P') { if (yych == 'L') - goto yy1456; + goto yy564; if (yych <= 'O') - goto yy1417; - goto yy1502; + goto yy525; + goto yy610; } else { if (yych <= 'l') { if (yych <= 'k') - goto yy1417; - goto yy1456; + goto yy525; + goto yy564; } else { if (yych == 'p') - goto yy1502; - goto yy1417; + goto yy610; + goto yy525; } } - yy1437: + yy545: yych = *++p; - switch (yych) { - case 'C': - case 'c': - goto yy1479; - case 'E': - case 'e': - goto yy1482; - case 'O': - case 'o': - goto yy1481; - case 'T': - case 't': - goto yy1478; - case 'U': - case 'u': - goto yy1480; - default: - goto yy1417; + if (yych <= 'U') { + if (yych <= 'E') { + if (yych == 'C') + goto yy587; + if (yych <= 'D') + goto yy525; + goto yy590; + } else { + if (yych <= 'O') { + if (yych <= 'N') + goto yy525; + goto yy589; + } else { + if (yych <= 'S') + goto yy525; + if (yych <= 'T') + goto yy586; + goto yy588; + } + } + } else { + if (yych <= 'n') { + if (yych <= 'c') { + if (yych <= 'b') + goto yy525; + goto yy587; + } else { + if (yych == 'e') + goto yy590; + goto yy525; + } + } else { + if (yych <= 's') { + if (yych <= 'o') + goto yy589; + goto yy525; + } else { + if (yych <= 't') + goto yy586; + if (yych <= 'u') + goto yy588; + goto yy525; + } + } } - yy1438: + yy546: yych = *++p; switch (yych) { case 'A': case 'a': - goto yy1465; + goto yy573; case 'B': case 'b': - goto yy1464; + goto yy572; case 'D': case 'd': - goto yy1456; + goto yy564; case 'F': case 'f': - goto yy1463; + goto yy571; case 'H': case 'h': - goto yy1462; + goto yy570; case 'I': case 'i': - goto yy1461; + goto yy569; case 'R': case 'r': - goto yy1460; + goto yy568; default: - goto yy1417; + goto yy525; } - yy1439: + yy547: yych = *++p; if (yych == 'L') - goto yy1456; + goto yy564; if (yych == 'l') - goto yy1456; - goto yy1417; - yy1440: + goto yy564; + goto yy525; + yy548: yych = *++p; if (yych <= '@') { if (yych == '-') - goto yy1443; - goto yy1417; + goto yy551; + goto yy525; } else { if (yych <= 'Z') - goto yy1444; + goto yy552; if (yych <= '[') - goto yy1446; - goto yy1417; + goto yy554; + goto yy525; } - yy1441: + yy549: ++p; { return 3; } - yy1443: + yy551: yych = *++p; if (yych == '-') - goto yy1454; - goto yy1417; - yy1444: + goto yy562; + goto yy525; + yy552: ++p; { return 4; } - yy1446: + yy554: yych = *++p; if (yych == 'C') - goto yy1447; + goto yy555; if (yych != 'c') - goto yy1417; - yy1447: + goto yy525; + yy555: yych = *++p; if (yych == 'D') - goto yy1448; + goto yy556; if (yych != 'd') - goto yy1417; - yy1448: + goto yy525; + yy556: yych = *++p; if (yych == 'A') - goto yy1449; + goto yy557; if (yych != 'a') - goto yy1417; - yy1449: + goto yy525; + yy557: yych = *++p; if (yych == 'T') - goto yy1450; + goto yy558; if (yych != 't') - goto yy1417; - yy1450: + goto yy525; + yy558: yych = *++p; if (yych == 'A') - goto yy1451; + goto yy559; if (yych != 'a') - goto yy1417; - yy1451: + goto yy525; + yy559: yych = *++p; if (yych != '[') - goto yy1417; + goto yy525; ++p; { return 5; } - yy1454: + yy562: ++p; { return 2; } - yy1456: + yy564: yych = *++p; if (yych <= ' ') { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; + goto yy565; if (yych <= 0x1F) - goto yy1417; + goto yy525; } else { if (yych <= '/') { if (yych <= '.') - goto yy1417; - goto yy1459; + goto yy525; + goto yy567; } else { if (yych != '>') - goto yy1417; + goto yy525; } } - yy1457: + yy565: ++p; { return 6; } - yy1459: + yy567: yych = *++p; if (yych == '>') - goto yy1457; - goto yy1417; - yy1460: + goto yy565; + goto yy525; + yy568: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= ' ') - goto yy1457; + goto yy565; if (yych <= '.') - goto yy1417; - goto yy1459; + goto yy525; + goto yy567; } } else { if (yych <= '@') { if (yych == '>') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= 'A') - goto yy1476; + goto yy584; if (yych == 'a') - goto yy1476; - goto yy1417; + goto yy584; + goto yy525; } } - yy1461: + yy569: yych = *++p; if (yych == 'T') - goto yy1474; + goto yy582; if (yych == 't') - goto yy1474; - goto yy1417; - yy1462: + goto yy582; + goto yy525; + yy570: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= ' ') - goto yy1457; + goto yy565; if (yych <= '.') - goto yy1417; - goto yy1459; + goto yy525; + goto yy567; } } else { if (yych <= 'D') { if (yych == '>') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= 'E') - goto yy1472; + goto yy580; if (yych == 'e') - goto yy1472; - goto yy1417; + goto yy580; + goto yy525; } } - yy1463: + yy571: yych = *++p; if (yych == 'O') - goto yy1470; + goto yy578; if (yych == 'o') - goto yy1470; - goto yy1417; - yy1464: + goto yy578; + goto yy525; + yy572: yych = *++p; if (yych == 'O') - goto yy1468; + goto yy576; if (yych == 'o') - goto yy1468; - goto yy1417; - yy1465: + goto yy576; + goto yy525; + yy573: yych = *++p; if (yych == 'B') - goto yy1466; + goto yy574; if (yych != 'b') - goto yy1417; - yy1466: + goto yy525; + yy574: yych = *++p; if (yych == 'L') - goto yy1467; + goto yy575; if (yych != 'l') - goto yy1417; - yy1467: + goto yy525; + yy575: yych = *++p; if (yych == 'E') - goto yy1456; + goto yy564; if (yych == 'e') - goto yy1456; - goto yy1417; - yy1468: + goto yy564; + goto yy525; + yy576: yych = *++p; if (yych == 'D') - goto yy1469; + goto yy577; if (yych != 'd') - goto yy1417; - yy1469: + goto yy525; + yy577: yych = *++p; if (yych == 'Y') - goto yy1456; + goto yy564; if (yych == 'y') - goto yy1456; - goto yy1417; - yy1470: + goto yy564; + goto yy525; + yy578: yych = *++p; if (yych == 'O') - goto yy1471; + goto yy579; if (yych != 'o') - goto yy1417; - yy1471: + goto yy525; + yy579: yych = *++p; if (yych == 'T') - goto yy1456; + goto yy564; if (yych == 't') - goto yy1456; - goto yy1417; - yy1472: + goto yy564; + goto yy525; + yy580: yych = *++p; if (yych == 'A') - goto yy1473; + goto yy581; if (yych != 'a') - goto yy1417; - yy1473: + goto yy525; + yy581: yych = *++p; if (yych == 'D') - goto yy1456; + goto yy564; if (yych == 'd') - goto yy1456; - goto yy1417; - yy1474: + goto yy564; + goto yy525; + yy582: yych = *++p; if (yych == 'L') - goto yy1475; + goto yy583; if (yych != 'l') - goto yy1417; - yy1475: + goto yy525; + yy583: yych = *++p; if (yych == 'E') - goto yy1456; + goto yy564; if (yych == 'e') - goto yy1456; - goto yy1417; - yy1476: + goto yy564; + goto yy525; + yy584: yych = *++p; if (yych == 'C') - goto yy1477; + goto yy585; if (yych != 'c') - goto yy1417; - yy1477: + goto yy525; + yy585: yych = *++p; if (yych == 'K') - goto yy1456; + goto yy564; if (yych == 'k') - goto yy1456; - goto yy1417; - yy1478: + goto yy564; + goto yy525; + yy586: yych = *++p; if (yych == 'Y') - goto yy1500; + goto yy608; if (yych == 'y') - goto yy1500; - goto yy1417; - yy1479: + goto yy608; + goto yy525; + yy587: yych = *++p; if (yych == 'R') - goto yy1494; + goto yy602; if (yych == 'r') - goto yy1494; - goto yy1417; - yy1480: + goto yy602; + goto yy525; + yy588: yych = *++p; if (yych == 'M') - goto yy1490; + goto yy598; if (yych == 'm') - goto yy1490; - goto yy1417; - yy1481: + goto yy598; + goto yy525; + yy589: yych = *++p; if (yych == 'U') - goto yy1487; + goto yy595; if (yych == 'u') - goto yy1487; - goto yy1417; - yy1482: + goto yy595; + goto yy525; + yy590: yych = *++p; if (yych == 'C') - goto yy1483; + goto yy591; if (yych != 'c') - goto yy1417; - yy1483: + goto yy525; + yy591: yych = *++p; if (yych == 'T') - goto yy1484; + goto yy592; if (yych != 't') - goto yy1417; - yy1484: + goto yy525; + yy592: yych = *++p; if (yych == 'I') - goto yy1485; + goto yy593; if (yych != 'i') - goto yy1417; - yy1485: + goto yy525; + yy593: yych = *++p; if (yych == 'O') - goto yy1486; + goto yy594; if (yych != 'o') - goto yy1417; - yy1486: + goto yy525; + yy594: yych = *++p; if (yych == 'N') - goto yy1456; + goto yy564; if (yych == 'n') - goto yy1456; - goto yy1417; - yy1487: + goto yy564; + goto yy525; + yy595: yych = *++p; if (yych == 'R') - goto yy1488; + goto yy596; if (yych != 'r') - goto yy1417; - yy1488: + goto yy525; + yy596: yych = *++p; if (yych == 'C') - goto yy1489; + goto yy597; if (yych != 'c') - goto yy1417; - yy1489: + goto yy525; + yy597: yych = *++p; if (yych == 'E') - goto yy1456; + goto yy564; if (yych == 'e') - goto yy1456; - goto yy1417; - yy1490: + goto yy564; + goto yy525; + yy598: yych = *++p; if (yych == 'M') - goto yy1491; + goto yy599; if (yych != 'm') - goto yy1417; - yy1491: + goto yy525; + yy599: yych = *++p; if (yych == 'A') - goto yy1492; + goto yy600; if (yych != 'a') - goto yy1417; - yy1492: + goto yy525; + yy600: yych = *++p; if (yych == 'R') - goto yy1493; + goto yy601; if (yych != 'r') - goto yy1417; - yy1493: + goto yy525; + yy601: yych = *++p; if (yych == 'Y') - goto yy1456; + goto yy564; if (yych == 'y') - goto yy1456; - goto yy1417; - yy1494: + goto yy564; + goto yy525; + yy602: yych = *++p; if (yych == 'I') - goto yy1495; + goto yy603; if (yych != 'i') - goto yy1417; - yy1495: + goto yy525; + yy603: yych = *++p; if (yych == 'P') - goto yy1496; + goto yy604; if (yych != 'p') - goto yy1417; - yy1496: + goto yy525; + yy604: yych = *++p; if (yych == 'T') - goto yy1497; + goto yy605; if (yych != 't') - goto yy1417; - yy1497: + goto yy525; + yy605: yych = *++p; if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych >= 0x0E) - goto yy1417; + goto yy525; } else { if (yych <= ' ') - goto yy1498; + goto yy606; if (yych != '>') - goto yy1417; + goto yy525; } - yy1498: + yy606: ++p; { return 1; } - yy1500: + yy608: yych = *++p; if (yych == 'L') - goto yy1501; + goto yy609; if (yych != 'l') - goto yy1417; - yy1501: + goto yy525; + yy609: yych = *++p; if (yych == 'E') - goto yy1497; + goto yy605; if (yych == 'e') - goto yy1497; - goto yy1417; - yy1502: + goto yy605; + goto yy525; + yy610: yych = *++p; if (yych == 'T') - goto yy1503; + goto yy611; if (yych != 't') - goto yy1417; - yy1503: + goto yy525; + yy611: yych = *++p; if (yych <= 'I') { if (yych == 'G') - goto yy1505; + goto yy613; if (yych <= 'H') - goto yy1417; + goto yy525; } else { if (yych <= 'g') { if (yych <= 'f') - goto yy1417; - goto yy1505; + goto yy525; + goto yy613; } else { if (yych != 'i') - goto yy1417; + goto yy525; } } yych = *++p; if (yych == 'O') - goto yy1509; + goto yy617; if (yych == 'o') - goto yy1509; - goto yy1417; - yy1505: + goto yy617; + goto yy525; + yy613: yych = *++p; if (yych == 'R') - goto yy1506; + goto yy614; if (yych != 'r') - goto yy1417; - yy1506: + goto yy525; + yy614: yych = *++p; if (yych == 'O') - goto yy1507; + goto yy615; if (yych != 'o') - goto yy1417; - yy1507: + goto yy525; + yy615: yych = *++p; if (yych == 'U') - goto yy1508; + goto yy616; if (yych != 'u') - goto yy1417; - yy1508: + goto yy525; + yy616: yych = *++p; if (yych == 'P') - goto yy1456; + goto yy564; if (yych == 'p') - goto yy1456; - goto yy1417; - yy1509: + goto yy564; + goto yy525; + yy617: yych = *++p; if (yych == 'N') - goto yy1456; + goto yy564; if (yych == 'n') - goto yy1456; - goto yy1417; - yy1510: + goto yy564; + goto yy525; + yy618: yych = *++p; if (yych == 'F') - goto yy1512; + goto yy620; if (yych == 'f') - goto yy1512; - goto yy1417; - yy1511: + goto yy620; + goto yy525; + yy619: yych = *++p; if (yych == 'V') - goto yy1456; + goto yy564; if (yych == 'v') - goto yy1456; - goto yy1417; - yy1512: + goto yy564; + goto yy525; + yy620: yych = *++p; if (yych == 'R') - goto yy1513; + goto yy621; if (yych != 'r') - goto yy1417; - yy1513: + goto yy525; + yy621: yych = *++p; if (yych == 'A') - goto yy1514; + goto yy622; if (yych != 'a') - goto yy1417; - yy1514: + goto yy525; + yy622: yych = *++p; if (yych == 'M') - goto yy1515; + goto yy623; if (yych != 'm') - goto yy1417; - yy1515: + goto yy525; + yy623: yych = *++p; if (yych == 'E') - goto yy1516; + goto yy624; if (yych != 'e') - goto yy1417; - yy1516: + goto yy525; + yy624: yych = *++p; if (yych == 'S') - goto yy1456; + goto yy564; if (yych == 's') - goto yy1456; - goto yy1417; - yy1517: + goto yy564; + goto yy525; + yy625: yych = *++p; if (yych <= 'T') { if (yych == 'N') - goto yy1520; + goto yy628; if (yych <= 'S') - goto yy1417; - goto yy1521; + goto yy525; + goto yy629; } else { if (yych <= 'n') { if (yych <= 'm') - goto yy1417; - goto yy1520; + goto yy525; + goto yy628; } else { if (yych == 't') - goto yy1521; - goto yy1417; + goto yy629; + goto yy525; } } - yy1518: + yy626: yych = *++p; if (yych == 'I') - goto yy1519; + goto yy627; if (yych != 'i') - goto yy1417; - yy1519: + goto yy525; + yy627: yych = *++p; if (yych == 'N') - goto yy1456; + goto yy564; if (yych == 'n') - goto yy1456; - goto yy1417; - yy1520: + goto yy564; + goto yy525; + yy628: yych = *++p; if (yych == 'U') - goto yy1522; + goto yy630; if (yych == 'u') - goto yy1522; - goto yy1417; - yy1521: + goto yy630; + goto yy525; + yy629: yych = *++p; if (yych == 'A') - goto yy1456; + goto yy564; if (yych == 'a') - goto yy1456; - goto yy1417; - yy1522: + goto yy564; + goto yy525; + yy630: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= ' ') - goto yy1457; + goto yy565; if (yych <= '.') - goto yy1417; - goto yy1459; + goto yy525; + goto yy567; } } else { if (yych <= 'H') { if (yych == '>') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= 'I') - goto yy1523; + goto yy631; if (yych != 'i') - goto yy1417; + goto yy525; } } - yy1523: + yy631: yych = *++p; if (yych == 'T') - goto yy1524; + goto yy632; if (yych != 't') - goto yy1417; - yy1524: + goto yy525; + yy632: yych = *++p; if (yych == 'E') - goto yy1525; + goto yy633; if (yych != 'e') - goto yy1417; - yy1525: + goto yy525; + yy633: yych = *++p; if (yych == 'M') - goto yy1456; + goto yy564; if (yych == 'm') - goto yy1456; - goto yy1417; - yy1526: + goto yy564; + goto yy525; + yy634: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= ' ') - goto yy1457; + goto yy565; if (yych <= '.') - goto yy1417; - goto yy1459; + goto yy525; + goto yy567; } } else { if (yych <= 'M') { if (yych == '>') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= 'N') - goto yy1531; + goto yy639; if (yych == 'n') - goto yy1531; - goto yy1417; + goto yy639; + goto yy525; } } - yy1527: + yy635: yych = *++p; if (yych == 'G') - goto yy1528; + goto yy636; if (yych != 'g') - goto yy1417; - yy1528: + goto yy525; + yy636: yych = *++p; if (yych == 'E') - goto yy1529; + goto yy637; if (yych != 'e') - goto yy1417; - yy1529: + goto yy525; + yy637: yych = *++p; if (yych == 'N') - goto yy1530; + goto yy638; if (yych != 'n') - goto yy1417; - yy1530: + goto yy525; + yy638: yych = *++p; if (yych == 'D') - goto yy1456; + goto yy564; if (yych == 'd') - goto yy1456; - goto yy1417; - yy1531: + goto yy564; + goto yy525; + yy639: yych = *++p; if (yych == 'K') - goto yy1456; + goto yy564; if (yych == 'k') - goto yy1456; - goto yy1417; - yy1532: + goto yy564; + goto yy525; + yy640: yych = *++p; if (yych == 'R') - goto yy1533; + goto yy641; if (yych != 'r') - goto yy1417; - yy1533: + goto yy525; + yy641: yych = *++p; if (yych == 'A') - goto yy1534; + goto yy642; if (yych != 'a') - goto yy1417; - yy1534: + goto yy525; + yy642: yych = *++p; if (yych == 'M') - goto yy1535; + goto yy643; if (yych != 'm') - goto yy1417; - yy1535: + goto yy525; + yy643: yych = *++p; if (yych == 'E') - goto yy1456; + goto yy564; if (yych == 'e') - goto yy1456; - goto yy1417; - yy1536: + goto yy564; + goto yy525; + yy644: yych = *++p; if (yych == 'M') - goto yy1541; + goto yy649; if (yych == 'm') - goto yy1541; - goto yy1417; - yy1537: + goto yy649; + goto yy525; + yy645: yych = *++p; if (yych == 'A') - goto yy1538; + goto yy646; if (yych != 'a') - goto yy1417; - yy1538: + goto yy525; + yy646: yych = *++p; if (yych == 'D') - goto yy1539; + goto yy647; if (yych != 'd') - goto yy1417; - yy1539: + goto yy525; + yy647: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= ' ') - goto yy1457; + goto yy565; if (yych <= '.') - goto yy1417; - goto yy1459; + goto yy525; + goto yy567; } } else { if (yych <= 'D') { if (yych == '>') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= 'E') - goto yy1540; + goto yy648; if (yych != 'e') - goto yy1417; + goto yy525; } } - yy1540: + yy648: yych = *++p; if (yych == 'R') - goto yy1456; + goto yy564; if (yych == 'r') - goto yy1456; - goto yy1417; - yy1541: + goto yy564; + goto yy525; + yy649: yych = *++p; if (yych == 'L') - goto yy1456; + goto yy564; if (yych == 'l') - goto yy1456; - goto yy1417; - yy1542: + goto yy564; + goto yy525; + yy650: yych = *++p; if (yych == 'A') - goto yy1563; + goto yy671; if (yych == 'a') - goto yy1563; - goto yy1417; - yy1543: + goto yy671; + goto yy525; + yy651: yych = *++p; if (yych <= 'R') { if (yych == 'O') - goto yy1559; + goto yy667; if (yych <= 'Q') - goto yy1417; - goto yy1560; + goto yy525; + goto yy668; } else { if (yych <= 'o') { if (yych <= 'n') - goto yy1417; - goto yy1559; + goto yy525; + goto yy667; } else { if (yych == 'r') - goto yy1560; - goto yy1417; + goto yy668; + goto yy525; } } - yy1544: + yy652: yych = *++p; if (yych <= 'G') { if (yych == 'E') - goto yy1545; + goto yy653; if (yych <= 'F') - goto yy1417; - goto yy1546; + goto yy525; + goto yy654; } else { if (yych <= 'e') { if (yych <= 'd') - goto yy1417; + goto yy525; } else { if (yych == 'g') - goto yy1546; - goto yy1417; + goto yy654; + goto yy525; } } - yy1545: + yy653: yych = *++p; if (yych == 'L') - goto yy1555; + goto yy663; if (yych == 'l') - goto yy1555; - goto yy1417; - yy1546: + goto yy663; + goto yy525; + yy654: yych = *++p; if (yych <= 'U') { if (yych == 'C') - goto yy1548; + goto yy656; if (yych <= 'T') - goto yy1417; + goto yy525; } else { if (yych <= 'c') { if (yych <= 'b') - goto yy1417; - goto yy1548; + goto yy525; + goto yy656; } else { if (yych != 'u') - goto yy1417; + goto yy525; } } yych = *++p; if (yych == 'R') - goto yy1554; + goto yy662; if (yych == 'r') - goto yy1554; - goto yy1417; - yy1548: + goto yy662; + goto yy525; + yy656: yych = *++p; if (yych == 'A') - goto yy1549; + goto yy657; if (yych != 'a') - goto yy1417; - yy1549: + goto yy525; + yy657: yych = *++p; if (yych == 'P') - goto yy1550; + goto yy658; if (yych != 'p') - goto yy1417; - yy1550: + goto yy525; + yy658: yych = *++p; if (yych == 'T') - goto yy1551; + goto yy659; if (yych != 't') - goto yy1417; - yy1551: + goto yy525; + yy659: yych = *++p; if (yych == 'I') - goto yy1552; + goto yy660; if (yych != 'i') - goto yy1417; - yy1552: + goto yy525; + yy660: yych = *++p; if (yych == 'O') - goto yy1553; + goto yy661; if (yych != 'o') - goto yy1417; - yy1553: + goto yy525; + yy661: yych = *++p; if (yych == 'N') - goto yy1456; + goto yy564; if (yych == 'n') - goto yy1456; - goto yy1417; - yy1554: + goto yy564; + goto yy525; + yy662: yych = *++p; if (yych == 'E') - goto yy1456; + goto yy564; if (yych == 'e') - goto yy1456; - goto yy1417; - yy1555: + goto yy564; + goto yy525; + yy663: yych = *++p; if (yych == 'D') - goto yy1556; + goto yy664; if (yych != 'd') - goto yy1417; - yy1556: + goto yy525; + yy664: yych = *++p; if (yych == 'S') - goto yy1557; + goto yy665; if (yych != 's') - goto yy1417; - yy1557: + goto yy525; + yy665: yych = *++p; if (yych == 'E') - goto yy1558; + goto yy666; if (yych != 'e') - goto yy1417; - yy1558: + goto yy525; + yy666: yych = *++p; if (yych == 'T') - goto yy1456; + goto yy564; if (yych == 't') - goto yy1456; - goto yy1417; - yy1559: + goto yy564; + goto yy525; + yy667: yych = *++p; if (yych == 'T') - goto yy1561; + goto yy669; if (yych == 't') - goto yy1561; - goto yy1417; - yy1560: + goto yy669; + goto yy525; + yy668: yych = *++p; if (yych == 'M') - goto yy1456; + goto yy564; if (yych == 'm') - goto yy1456; - goto yy1417; - yy1561: + goto yy564; + goto yy525; + yy669: yych = *++p; if (yych == 'E') - goto yy1562; + goto yy670; if (yych != 'e') - goto yy1417; - yy1562: + goto yy525; + yy670: yych = *++p; if (yych == 'R') - goto yy1456; + goto yy564; if (yych == 'r') - goto yy1456; - goto yy1417; - yy1563: + goto yy564; + goto yy525; + yy671: yych = *++p; if (yych == 'M') - goto yy1564; + goto yy672; if (yych != 'm') - goto yy1417; - yy1564: + goto yy525; + yy672: yych = *++p; if (yych == 'E') - goto yy1565; + goto yy673; if (yych != 'e') - goto yy1417; - yy1565: + goto yy525; + yy673: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= ' ') - goto yy1457; + goto yy565; if (yych <= '.') - goto yy1417; - goto yy1459; + goto yy525; + goto yy567; } } else { if (yych <= 'R') { if (yych == '>') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= 'S') - goto yy1566; + goto yy674; if (yych != 's') - goto yy1417; + goto yy525; } } - yy1566: + yy674: yych = *++p; if (yych == 'E') - goto yy1567; + goto yy675; if (yych != 'e') - goto yy1417; - yy1567: + goto yy525; + yy675: yych = *++p; if (yych == 'T') - goto yy1456; + goto yy564; if (yych == 't') - goto yy1456; - goto yy1417; - yy1568: + goto yy564; + goto yy525; + yy676: yych = *++p; if (yych <= 'V') { if (yych <= 'Q') { if (yych == 'A') - goto yy1574; - goto yy1417; + goto yy682; + goto yy525; } else { if (yych <= 'R') - goto yy1456; + goto yy564; if (yych <= 'U') - goto yy1417; - goto yy1456; + goto yy525; + goto yy564; } } else { if (yych <= 'q') { if (yych == 'a') - goto yy1574; - goto yy1417; + goto yy682; + goto yy525; } else { if (yych <= 'r') - goto yy1456; + goto yy564; if (yych == 'v') - goto yy1456; - goto yy1417; + goto yy564; + goto yy525; } } - yy1569: + yy677: yych = *++p; if (yych == 'T') - goto yy1570; + goto yy678; if (yych != 't') - goto yy1417; - yy1570: + goto yy525; + yy678: yych = *++p; if (yych == 'A') - goto yy1571; + goto yy679; if (yych != 'a') - goto yy1417; - yy1571: + goto yy525; + yy679: yych = *++p; if (yych == 'I') - goto yy1572; + goto yy680; if (yych != 'i') - goto yy1417; - yy1572: + goto yy525; + yy680: yych = *++p; if (yych == 'L') - goto yy1573; + goto yy681; if (yych != 'l') - goto yy1417; - yy1573: + goto yy525; + yy681: yych = *++p; if (yych == 'S') - goto yy1456; + goto yy564; if (yych == 's') - goto yy1456; - goto yy1417; - yy1574: + goto yy564; + goto yy525; + yy682: yych = *++p; if (yych == 'L') - goto yy1575; + goto yy683; if (yych != 'l') - goto yy1417; - yy1575: + goto yy525; + yy683: yych = *++p; if (yych == 'O') - goto yy1576; + goto yy684; if (yych != 'o') - goto yy1417; - yy1576: + goto yy525; + yy684: yych = *++p; if (yych == 'G') - goto yy1456; + goto yy564; if (yych == 'g') - goto yy1456; - goto yy1417; - yy1577: + goto yy564; + goto yy525; + yy685: yych = *++p; if (yych == 'L') - goto yy1587; + goto yy695; if (yych == 'l') - goto yy1587; - goto yy1417; - yy1578: + goto yy695; + goto yy525; + yy686: yych = *++p; if (yych == 'N') - goto yy1584; + goto yy692; if (yych == 'n') - goto yy1584; - goto yy1417; - yy1579: + goto yy692; + goto yy525; + yy687: yych = *++p; if (yych == 'P') - goto yy1580; + goto yy688; if (yych != 'p') - goto yy1417; - yy1580: + goto yy525; + yy688: yych = *++p; if (yych == 'T') - goto yy1581; + goto yy689; if (yych != 't') - goto yy1417; - yy1581: + goto yy525; + yy689: yych = *++p; if (yych == 'I') - goto yy1582; + goto yy690; if (yych != 'i') - goto yy1417; - yy1582: + goto yy525; + yy690: yych = *++p; if (yych == 'O') - goto yy1583; + goto yy691; if (yych != 'o') - goto yy1417; - yy1583: + goto yy525; + yy691: yych = *++p; if (yych == 'N') - goto yy1456; + goto yy564; if (yych == 'n') - goto yy1456; - goto yy1417; - yy1584: + goto yy564; + goto yy525; + yy692: yych = *++p; if (yych == 'T') - goto yy1585; + goto yy693; if (yych != 't') - goto yy1417; - yy1585: + goto yy525; + yy693: yych = *++p; if (yych == 'E') - goto yy1586; + goto yy694; if (yych != 'e') - goto yy1417; - yy1586: + goto yy525; + yy694: yych = *++p; if (yych == 'R') - goto yy1456; + goto yy564; if (yych == 'r') - goto yy1456; - goto yy1417; - yy1587: + goto yy564; + goto yy525; + yy695: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= ' ') - goto yy1457; + goto yy565; if (yych <= '.') - goto yy1417; - goto yy1459; + goto yy525; + goto yy567; } } else { if (yych <= 'F') { if (yych == '>') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= 'G') - goto yy1588; + goto yy696; if (yych != 'g') - goto yy1417; + goto yy525; } } - yy1588: + yy696: yych = *++p; if (yych == 'R') - goto yy1589; + goto yy697; if (yych != 'r') - goto yy1417; - yy1589: + goto yy525; + yy697: yych = *++p; if (yych == 'O') - goto yy1590; + goto yy698; if (yych != 'o') - goto yy1417; - yy1590: + goto yy525; + yy698: yych = *++p; if (yych == 'U') - goto yy1591; + goto yy699; if (yych != 'u') - goto yy1417; - yy1591: + goto yy525; + yy699: yych = *++p; if (yych == 'P') - goto yy1456; + goto yy564; if (yych == 'p') - goto yy1456; - goto yy1417; - yy1592: + goto yy564; + goto yy525; + yy700: yych = *++p; if (yych == 'D') - goto yy1607; + goto yy715; if (yych == 'd') - goto yy1607; - goto yy1417; - yy1593: + goto yy715; + goto yy525; + yy701: yych = *++p; if (yych == 'O') - goto yy1600; + goto yy708; if (yych == 'o') - goto yy1600; - goto yy1417; - yy1594: + goto yy708; + goto yy525; + yy702: yych = *++p; if (yych == 'S') - goto yy1595; + goto yy703; if (yych != 's') - goto yy1417; - yy1595: + goto yy525; + yy703: yych = *++p; if (yych == 'E') - goto yy1596; + goto yy704; if (yych != 'e') - goto yy1417; - yy1596: + goto yy525; + yy704: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= ' ') - goto yy1457; + goto yy565; if (yych <= '.') - goto yy1417; - goto yy1459; + goto yy525; + goto yy567; } } else { if (yych <= 'E') { if (yych == '>') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= 'F') - goto yy1597; + goto yy705; if (yych != 'f') - goto yy1417; + goto yy525; } } - yy1597: + yy705: yych = *++p; if (yych == 'O') - goto yy1598; + goto yy706; if (yych != 'o') - goto yy1417; - yy1598: + goto yy525; + yy706: yych = *++p; if (yych == 'N') - goto yy1599; + goto yy707; if (yych != 'n') - goto yy1417; - yy1599: + goto yy525; + yy707: yych = *++p; if (yych == 'T') - goto yy1456; + goto yy564; if (yych == 't') - goto yy1456; - goto yy1417; - yy1600: + goto yy564; + goto yy525; + yy708: yych = *++p; if (yych == 'C') - goto yy1601; + goto yy709; if (yych != 'c') - goto yy1417; - yy1601: + goto yy525; + yy709: yych = *++p; if (yych == 'K') - goto yy1602; + goto yy710; if (yych != 'k') - goto yy1417; - yy1602: + goto yy525; + yy710: yych = *++p; if (yych == 'Q') - goto yy1603; + goto yy711; if (yych != 'q') - goto yy1417; - yy1603: + goto yy525; + yy711: yych = *++p; if (yych == 'U') - goto yy1604; + goto yy712; if (yych != 'u') - goto yy1417; - yy1604: + goto yy525; + yy712: yych = *++p; if (yych == 'O') - goto yy1605; + goto yy713; if (yych != 'o') - goto yy1417; - yy1605: + goto yy525; + yy713: yych = *++p; if (yych == 'T') - goto yy1606; + goto yy714; if (yych != 't') - goto yy1417; - yy1606: + goto yy525; + yy714: yych = *++p; if (yych == 'E') - goto yy1456; + goto yy564; if (yych == 'e') - goto yy1456; - goto yy1417; - yy1607: + goto yy564; + goto yy525; + yy715: yych = *++p; if (yych == 'Y') - goto yy1456; + goto yy564; if (yych == 'y') - goto yy1456; - goto yy1417; - yy1608: + goto yy564; + goto yy525; + yy716: yych = *++p; if (yych == 'I') - goto yy1619; + goto yy727; if (yych == 'i') - goto yy1619; - goto yy1417; - yy1609: + goto yy727; + goto yy525; + yy717: yych = *++p; if (yych == 'T') - goto yy1615; + goto yy723; if (yych == 't') - goto yy1615; - goto yy1417; - yy1610: + goto yy723; + goto yy525; + yy718: yych = *++p; if (yych == 'D') - goto yy1611; + goto yy719; if (yych != 'd') - goto yy1417; - yy1611: + goto yy525; + yy719: yych = *++p; if (yych == 'R') - goto yy1612; + goto yy720; if (yych != 'r') - goto yy1417; - yy1612: + goto yy525; + yy720: yych = *++p; if (yych == 'E') - goto yy1613; + goto yy721; if (yych != 'e') - goto yy1417; - yy1613: + goto yy525; + yy721: yych = *++p; if (yych == 'S') - goto yy1614; + goto yy722; if (yych != 's') - goto yy1417; - yy1614: + goto yy525; + yy722: yych = *++p; if (yych == 'S') - goto yy1456; + goto yy564; if (yych == 's') - goto yy1456; - goto yy1417; - yy1615: + goto yy564; + goto yy525; + yy723: yych = *++p; if (yych == 'I') - goto yy1616; + goto yy724; if (yych != 'i') - goto yy1417; - yy1616: + goto yy525; + yy724: yych = *++p; if (yych == 'C') - goto yy1617; + goto yy725; if (yych != 'c') - goto yy1417; - yy1617: + goto yy525; + yy725: yych = *++p; if (yych == 'L') - goto yy1618; + goto yy726; if (yych != 'l') - goto yy1417; - yy1618: + goto yy525; + yy726: yych = *++p; if (yych == 'E') - goto yy1456; + goto yy564; if (yych == 'e') - goto yy1456; - goto yy1417; - yy1619: + goto yy564; + goto yy525; + yy727: yych = *++p; if (yych == 'D') - goto yy1620; + goto yy728; if (yych != 'd') - goto yy1417; - yy1620: + goto yy525; + yy728: yych = *++p; if (yych == 'E') - goto yy1456; + goto yy564; if (yych == 'e') - goto yy1456; - goto yy1417; - yy1621: + goto yy564; + goto yy525; + yy729: yych = *++p; if (yych == 'E') - goto yy1497; + goto yy605; if (yych == 'e') - goto yy1497; - goto yy1417; - yy1622: + goto yy605; + goto yy525; + yy730: yych = *++p; if (yych == 'R') - goto yy1623; + goto yy731; if (yych != 'r') - goto yy1417; - yy1623: + goto yy525; + yy731: yych = *++p; if (yych == 'A') - goto yy1624; + goto yy732; if (yych != 'a') - goto yy1417; - yy1624: + goto yy525; + yy732: yych = *++p; if (yych == 'M') - goto yy1456; + goto yy564; if (yych == 'm') - goto yy1456; - goto yy1417; - yy1625: + goto yy564; + goto yy525; + yy733: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy1417; + goto yy525; if (yych <= '\r') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= ' ') - goto yy1457; + goto yy565; if (yych <= '.') - goto yy1417; - goto yy1459; + goto yy525; + goto yy567; } } else { if (yych <= '@') { if (yych == '>') - goto yy1457; - goto yy1417; + goto yy565; + goto yy525; } else { if (yych <= 'A') - goto yy1622; + goto yy730; if (yych == 'a') - goto yy1622; - goto yy1417; + goto yy730; + goto yy525; } } - yy1626: + yy734: ++p; if ((yych = *p) <= 'U') { if (yych <= 'N') { if (yych == 'E') - goto yy1482; - goto yy1417; + goto yy590; + goto yy525; } else { if (yych <= 'O') - goto yy1481; + goto yy589; if (yych <= 'T') - goto yy1417; - goto yy1480; + goto yy525; + goto yy588; } } else { if (yych <= 'n') { if (yych == 'e') - goto yy1482; - goto yy1417; + goto yy590; + goto yy525; } else { if (yych <= 'o') - goto yy1481; + goto yy589; if (yych == 'u') - goto yy1480; - goto yy1417; + goto yy588; + goto yy525; } } } @@ -18811,813 +12494,813 @@ bufsize_t _scan_html_block_start_7(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= ';') { if (yych != '\n') - goto yy1631; + goto yy739; } else { if (yych <= '<') - goto yy1630; + goto yy738; if (yych <= 0x7F) - goto yy1631; + goto yy739; if (yych >= 0xC2) - goto yy1632; + goto yy740; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1634; + goto yy742; if (yych == 0xED) - goto yy1639; - goto yy1635; + goto yy747; + goto yy743; } else { if (yych <= 0xF0) - goto yy1636; + goto yy744; if (yych <= 0xF3) - goto yy1637; + goto yy745; if (yych <= 0xF4) - goto yy1638; + goto yy746; } } - yy1629 : { return 0; } - yy1630: + yy737 : { return 0; } + yy738: yyaccept = 0; yych = *(marker = ++p); if (yych <= '@') { if (yych == '/') - goto yy1642; - goto yy1629; + goto yy750; + goto yy737; } else { if (yych <= 'Z') - goto yy1640; + goto yy748; if (yych <= '`') - goto yy1629; + goto yy737; if (yych <= 'z') - goto yy1640; - goto yy1629; + goto yy748; + goto yy737; } - yy1631: + yy739: yych = *++p; - goto yy1629; - yy1632: + goto yy737; + yy740: yych = *++p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1631; - yy1633: + goto yy739; + yy741: p = marker; if (yyaccept == 0) { - goto yy1629; + goto yy737; } else { - goto yy1651; + goto yy759; } - yy1634: + yy742: yych = *++p; if (yych <= 0x9F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1632; - goto yy1633; - yy1635: + goto yy740; + goto yy741; + yy743: yych = *++p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1632; - goto yy1633; - yy1636: + goto yy740; + goto yy741; + yy744: yych = *++p; if (yych <= 0x8F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1635; - goto yy1633; - yy1637: + goto yy743; + goto yy741; + yy745: yych = *++p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1635; - goto yy1633; - yy1638: + goto yy743; + goto yy741; + yy746: yych = *++p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0x8F) - goto yy1635; - goto yy1633; - yy1639: + goto yy743; + goto yy741; + yy747: yych = *++p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0x9F) - goto yy1632; - goto yy1633; - yy1640: + goto yy740; + goto yy741; + yy748: ++p; yych = *p; if (yybm[0 + yych] & 1) { - goto yy1640; + goto yy748; } if (yych <= ' ') { if (yych <= 0x08) - goto yy1633; + goto yy741; if (yych <= '\r') - goto yy1653; + goto yy761; if (yych <= 0x1F) - goto yy1633; - goto yy1653; + goto yy741; + goto yy761; } else { if (yych <= '/') { if (yych <= '.') - goto yy1633; - goto yy1655; + goto yy741; + goto yy763; } else { if (yych == '>') - goto yy1647; - goto yy1633; + goto yy755; + goto yy741; } } - yy1642: + yy750: yych = *++p; if (yych <= '@') - goto yy1633; + goto yy741; if (yych <= 'Z') - goto yy1643; + goto yy751; if (yych <= '`') - goto yy1633; + goto yy741; if (yych >= '{') - goto yy1633; - yy1643: + goto yy741; + yy751: ++p; yych = *p; if (yybm[0 + yych] & 2) { - goto yy1645; + goto yy753; } if (yych <= '=') { if (yych <= '-') { if (yych <= ',') - goto yy1633; - goto yy1643; + goto yy741; + goto yy751; } else { if (yych <= '/') - goto yy1633; + goto yy741; if (yych <= '9') - goto yy1643; - goto yy1633; + goto yy751; + goto yy741; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy1647; + goto yy755; if (yych <= '@') - goto yy1633; - goto yy1643; + goto yy741; + goto yy751; } else { if (yych <= '`') - goto yy1633; + goto yy741; if (yych <= 'z') - goto yy1643; - goto yy1633; + goto yy751; + goto yy741; } } - yy1645: + yy753: ++p; yych = *p; if (yybm[0 + yych] & 2) { - goto yy1645; + goto yy753; } if (yych != '>') - goto yy1633; - yy1647: + goto yy741; + yy755: ++p; yych = *p; if (yybm[0 + yych] & 4) { - goto yy1647; + goto yy755; } if (yych <= 0x08) - goto yy1633; + goto yy741; if (yych <= '\n') - goto yy1649; + goto yy757; if (yych <= '\v') - goto yy1633; + goto yy741; if (yych <= '\r') - goto yy1652; - goto yy1633; - yy1649: + goto yy760; + goto yy741; + yy757: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0 + yych] & 4) { - goto yy1647; + goto yy755; } if (yych <= 0x08) - goto yy1651; + goto yy759; if (yych <= '\n') - goto yy1649; + goto yy757; if (yych <= '\v') - goto yy1651; + goto yy759; if (yych <= '\r') - goto yy1652; - yy1651 : { return 7; } - yy1652: + goto yy760; + yy759 : { return 7; } + yy760: yych = *++p; - goto yy1651; - yy1653: + goto yy759; + yy761: ++p; yych = *p; if (yych <= ':') { if (yych <= ' ') { if (yych <= 0x08) - goto yy1633; + goto yy741; if (yych <= '\r') - goto yy1653; + goto yy761; if (yych <= 0x1F) - goto yy1633; - goto yy1653; + goto yy741; + goto yy761; } else { if (yych == '/') - goto yy1655; + goto yy763; if (yych <= '9') - goto yy1633; - goto yy1656; + goto yy741; + goto yy764; } } else { if (yych <= 'Z') { if (yych == '>') - goto yy1647; + goto yy755; if (yych <= '@') - goto yy1633; - goto yy1656; + goto yy741; + goto yy764; } else { if (yych <= '_') { if (yych <= '^') - goto yy1633; - goto yy1656; + goto yy741; + goto yy764; } else { if (yych <= '`') - goto yy1633; + goto yy741; if (yych <= 'z') - goto yy1656; - goto yy1633; + goto yy764; + goto yy741; } } } - yy1655: + yy763: yych = *++p; if (yych == '>') - goto yy1647; - goto yy1633; - yy1656: + goto yy755; + goto yy741; + yy764: ++p; yych = *p; if (yybm[0 + yych] & 16) { - goto yy1656; + goto yy764; } if (yych <= ',') { if (yych <= '\r') { if (yych <= 0x08) - goto yy1633; + goto yy741; } else { if (yych != ' ') - goto yy1633; + goto yy741; } } else { if (yych <= '<') { if (yych <= '/') - goto yy1655; - goto yy1633; + goto yy763; + goto yy741; } else { if (yych <= '=') - goto yy1660; + goto yy768; if (yych <= '>') - goto yy1647; - goto yy1633; + goto yy755; + goto yy741; } } - yy1658: + yy766: ++p; yych = *p; if (yych <= '<') { if (yych <= ' ') { if (yych <= 0x08) - goto yy1633; + goto yy741; if (yych <= '\r') - goto yy1658; + goto yy766; if (yych <= 0x1F) - goto yy1633; - goto yy1658; + goto yy741; + goto yy766; } else { if (yych <= '/') { if (yych <= '.') - goto yy1633; - goto yy1655; + goto yy741; + goto yy763; } else { if (yych == ':') - goto yy1656; - goto yy1633; + goto yy764; + goto yy741; } } } else { if (yych <= 'Z') { if (yych <= '=') - goto yy1660; + goto yy768; if (yych <= '>') - goto yy1647; + goto yy755; if (yych <= '@') - goto yy1633; - goto yy1656; + goto yy741; + goto yy764; } else { if (yych <= '_') { if (yych <= '^') - goto yy1633; - goto yy1656; + goto yy741; + goto yy764; } else { if (yych <= '`') - goto yy1633; + goto yy741; if (yych <= 'z') - goto yy1656; - goto yy1633; + goto yy764; + goto yy741; } } } - yy1660: + yy768: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1662; + goto yy770; } if (yych <= 0xE0) { if (yych <= '"') { if (yych <= 0x00) - goto yy1633; + goto yy741; if (yych >= '!') - goto yy1673; + goto yy781; } else { if (yych <= '\'') - goto yy1671; + goto yy779; if (yych <= 0xC1) - goto yy1633; + goto yy741; if (yych <= 0xDF) - goto yy1664; - goto yy1665; + goto yy772; + goto yy773; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1670; - goto yy1666; + goto yy778; + goto yy774; } else { if (yych <= 0xF0) - goto yy1667; + goto yy775; if (yych <= 0xF3) - goto yy1668; + goto yy776; if (yych <= 0xF4) - goto yy1669; - goto yy1633; + goto yy777; + goto yy741; } } ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1662; + goto yy770; } if (yych <= 0xDF) { if (yych <= '\'') { if (yych <= 0x00) - goto yy1633; + goto yy741; if (yych <= ' ') - goto yy1696; + goto yy804; if (yych <= '"') - goto yy1673; - goto yy1671; + goto yy781; + goto yy779; } else { if (yych == '>') - goto yy1647; + goto yy755; if (yych <= 0xC1) - goto yy1633; - goto yy1664; + goto yy741; + goto yy772; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1665; + goto yy773; if (yych == 0xED) - goto yy1670; - goto yy1666; + goto yy778; + goto yy774; } else { if (yych <= 0xF0) - goto yy1667; + goto yy775; if (yych <= 0xF3) - goto yy1668; + goto yy776; if (yych <= 0xF4) - goto yy1669; - goto yy1633; + goto yy777; + goto yy741; } } - yy1662: + yy770: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1662; + goto yy770; } if (yych <= 0xE0) { if (yych <= '=') { if (yych <= 0x00) - goto yy1633; + goto yy741; if (yych <= ' ') - goto yy1690; - goto yy1633; + goto yy798; + goto yy741; } else { if (yych <= '>') - goto yy1647; + goto yy755; if (yych <= 0xC1) - goto yy1633; + goto yy741; if (yych >= 0xE0) - goto yy1665; + goto yy773; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1670; - goto yy1666; + goto yy778; + goto yy774; } else { if (yych <= 0xF0) - goto yy1667; + goto yy775; if (yych <= 0xF3) - goto yy1668; + goto yy776; if (yych <= 0xF4) - goto yy1669; - goto yy1633; + goto yy777; + goto yy741; } } - yy1664: + yy772: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1662; - goto yy1633; - yy1665: + goto yy770; + goto yy741; + yy773: ++p; yych = *p; if (yych <= 0x9F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1664; - goto yy1633; - yy1666: + goto yy772; + goto yy741; + yy774: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1664; - goto yy1633; - yy1667: + goto yy772; + goto yy741; + yy775: ++p; yych = *p; if (yych <= 0x8F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1666; - goto yy1633; - yy1668: + goto yy774; + goto yy741; + yy776: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1666; - goto yy1633; - yy1669: + goto yy774; + goto yy741; + yy777: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0x8F) - goto yy1666; - goto yy1633; - yy1670: + goto yy774; + goto yy741; + yy778: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0x9F) - goto yy1664; - goto yy1633; - yy1671: + goto yy772; + goto yy741; + yy779: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1671; + goto yy779; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1633; + goto yy741; if (yych <= '\'') - goto yy1682; - goto yy1633; + goto yy790; + goto yy741; } else { if (yych <= 0xDF) - goto yy1683; + goto yy791; if (yych <= 0xE0) - goto yy1684; - goto yy1685; + goto yy792; + goto yy793; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1689; + goto yy797; if (yych <= 0xEF) - goto yy1685; - goto yy1686; + goto yy793; + goto yy794; } else { if (yych <= 0xF3) - goto yy1687; + goto yy795; if (yych <= 0xF4) - goto yy1688; - goto yy1633; + goto yy796; + goto yy741; } } - yy1673: + yy781: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1673; + goto yy781; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1633; + goto yy741; if (yych <= '"') - goto yy1682; - goto yy1633; + goto yy790; + goto yy741; } else { if (yych <= 0xDF) - goto yy1675; + goto yy783; if (yych <= 0xE0) - goto yy1676; - goto yy1677; + goto yy784; + goto yy785; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1681; + goto yy789; if (yych <= 0xEF) - goto yy1677; - goto yy1678; + goto yy785; + goto yy786; } else { if (yych <= 0xF3) - goto yy1679; + goto yy787; if (yych <= 0xF4) - goto yy1680; - goto yy1633; + goto yy788; + goto yy741; } } - yy1675: + yy783: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1673; - goto yy1633; - yy1676: + goto yy781; + goto yy741; + yy784: ++p; yych = *p; if (yych <= 0x9F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1675; - goto yy1633; - yy1677: + goto yy783; + goto yy741; + yy785: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1675; - goto yy1633; - yy1678: + goto yy783; + goto yy741; + yy786: ++p; yych = *p; if (yych <= 0x8F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1677; - goto yy1633; - yy1679: + goto yy785; + goto yy741; + yy787: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1677; - goto yy1633; - yy1680: + goto yy785; + goto yy741; + yy788: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0x8F) - goto yy1677; - goto yy1633; - yy1681: + goto yy785; + goto yy741; + yy789: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0x9F) - goto yy1675; - goto yy1633; - yy1682: + goto yy783; + goto yy741; + yy790: ++p; yych = *p; if (yych <= ' ') { if (yych <= 0x08) - goto yy1633; + goto yy741; if (yych <= '\r') - goto yy1653; + goto yy761; if (yych <= 0x1F) - goto yy1633; - goto yy1653; + goto yy741; + goto yy761; } else { if (yych <= '/') { if (yych <= '.') - goto yy1633; - goto yy1655; + goto yy741; + goto yy763; } else { if (yych == '>') - goto yy1647; - goto yy1633; + goto yy755; + goto yy741; } } - yy1683: + yy791: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1671; - goto yy1633; - yy1684: + goto yy779; + goto yy741; + yy792: ++p; yych = *p; if (yych <= 0x9F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1683; - goto yy1633; - yy1685: + goto yy791; + goto yy741; + yy793: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1683; - goto yy1633; - yy1686: + goto yy791; + goto yy741; + yy794: ++p; yych = *p; if (yych <= 0x8F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1685; - goto yy1633; - yy1687: + goto yy793; + goto yy741; + yy795: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0xBF) - goto yy1685; - goto yy1633; - yy1688: + goto yy793; + goto yy741; + yy796: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0x8F) - goto yy1685; - goto yy1633; - yy1689: + goto yy793; + goto yy741; + yy797: ++p; yych = *p; if (yych <= 0x7F) - goto yy1633; + goto yy741; if (yych <= 0x9F) - goto yy1683; - goto yy1633; - yy1690: + goto yy791; + goto yy741; + yy798: ++p; yych = *p; if (yych <= '@') { if (yych <= '"') { if (yych <= '\r') { if (yych <= 0x00) - goto yy1633; + goto yy741; if (yych <= 0x08) - goto yy1662; - goto yy1690; + goto yy770; + goto yy798; } else { if (yych == ' ') - goto yy1690; + goto yy798; if (yych <= '!') - goto yy1662; - goto yy1633; + goto yy770; + goto yy741; } } else { if (yych <= ':') { if (yych == '\'') - goto yy1633; + goto yy741; if (yych <= '9') - goto yy1662; + goto yy770; } else { if (yych <= ';') - goto yy1662; + goto yy770; if (yych <= '=') - goto yy1633; + goto yy741; if (yych <= '>') - goto yy1647; - goto yy1662; + goto yy755; + goto yy770; } } } else { if (yych <= 0xDF) { if (yych <= '`') { if (yych <= 'Z') - goto yy1692; + goto yy800; if (yych <= '^') - goto yy1662; + goto yy770; if (yych >= '`') - goto yy1633; + goto yy741; } else { if (yych <= 'z') - goto yy1692; + goto yy800; if (yych <= 0x7F) - goto yy1662; + goto yy770; if (yych <= 0xC1) - goto yy1633; - goto yy1664; + goto yy741; + goto yy772; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1665; + goto yy773; if (yych == 0xED) - goto yy1670; - goto yy1666; + goto yy778; + goto yy774; } else { if (yych <= 0xF0) - goto yy1667; + goto yy775; if (yych <= 0xF3) - goto yy1668; + goto yy776; if (yych <= 0xF4) - goto yy1669; - goto yy1633; + goto yy777; + goto yy741; } } } - yy1692: + yy800: ++p; yych = *p; if (yych <= '>') { if (yych <= '&') { if (yych <= 0x1F) { if (yych <= 0x00) - goto yy1633; + goto yy741; if (yych <= 0x08) - goto yy1662; + goto yy770; if (yych >= 0x0E) - goto yy1662; + goto yy770; } else { if (yych <= ' ') - goto yy1694; + goto yy802; if (yych == '"') - goto yy1633; - goto yy1662; + goto yy741; + goto yy770; } } else { if (yych <= '/') { if (yych <= '\'') - goto yy1633; + goto yy741; if (yych <= ',') - goto yy1662; + goto yy770; if (yych <= '.') - goto yy1692; - goto yy1662; + goto yy800; + goto yy770; } else { if (yych <= ';') { if (yych <= ':') - goto yy1692; - goto yy1662; + goto yy800; + goto yy770; } else { if (yych <= '<') - goto yy1633; + goto yy741; if (yych <= '=') - goto yy1660; - goto yy1647; + goto yy768; + goto yy755; } } } @@ -19625,188 +13308,188 @@ bufsize_t _scan_html_block_start_7(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '_') { if (yych <= '@') - goto yy1662; + goto yy770; if (yych <= 'Z') - goto yy1692; + goto yy800; if (yych <= '^') - goto yy1662; - goto yy1692; + goto yy770; + goto yy800; } else { if (yych <= '`') - goto yy1633; + goto yy741; if (yych <= 'z') - goto yy1692; + goto yy800; if (yych <= 0x7F) - goto yy1662; - goto yy1633; + goto yy770; + goto yy741; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1664; + goto yy772; if (yych <= 0xE0) - goto yy1665; + goto yy773; if (yych <= 0xEC) - goto yy1666; - goto yy1670; + goto yy774; + goto yy778; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1666; - goto yy1667; + goto yy774; + goto yy775; } else { if (yych <= 0xF3) - goto yy1668; + goto yy776; if (yych <= 0xF4) - goto yy1669; - goto yy1633; + goto yy777; + goto yy741; } } } } - yy1694: + yy802: ++p; yych = *p; if (yych <= '@') { if (yych <= '&') { if (yych <= 0x1F) { if (yych <= 0x00) - goto yy1633; + goto yy741; if (yych <= 0x08) - goto yy1662; + goto yy770; if (yych <= '\r') - goto yy1694; - goto yy1662; + goto yy802; + goto yy770; } else { if (yych <= ' ') - goto yy1694; + goto yy802; if (yych == '"') - goto yy1633; - goto yy1662; + goto yy741; + goto yy770; } } else { if (yych <= ';') { if (yych <= '\'') - goto yy1633; + goto yy741; if (yych == ':') - goto yy1692; - goto yy1662; + goto yy800; + goto yy770; } else { if (yych <= '<') - goto yy1633; + goto yy741; if (yych <= '=') - goto yy1660; + goto yy768; if (yych <= '>') - goto yy1647; - goto yy1662; + goto yy755; + goto yy770; } } } else { if (yych <= 0xDF) { if (yych <= '`') { if (yych <= 'Z') - goto yy1692; + goto yy800; if (yych <= '^') - goto yy1662; + goto yy770; if (yych <= '_') - goto yy1692; - goto yy1633; + goto yy800; + goto yy741; } else { if (yych <= 'z') - goto yy1692; + goto yy800; if (yych <= 0x7F) - goto yy1662; + goto yy770; if (yych <= 0xC1) - goto yy1633; - goto yy1664; + goto yy741; + goto yy772; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1665; + goto yy773; if (yych == 0xED) - goto yy1670; - goto yy1666; + goto yy778; + goto yy774; } else { if (yych <= 0xF0) - goto yy1667; + goto yy775; if (yych <= 0xF3) - goto yy1668; + goto yy776; if (yych <= 0xF4) - goto yy1669; - goto yy1633; + goto yy777; + goto yy741; } } } - yy1696: + yy804: ++p; yych = *p; if (yych <= '@') { if (yych <= '"') { if (yych <= '\r') { if (yych <= 0x00) - goto yy1633; + goto yy741; if (yych <= 0x08) - goto yy1662; - goto yy1696; + goto yy770; + goto yy804; } else { if (yych == ' ') - goto yy1696; + goto yy804; if (yych <= '!') - goto yy1662; - goto yy1673; + goto yy770; + goto yy781; } } else { if (yych <= ':') { if (yych == '\'') - goto yy1671; + goto yy779; if (yych <= '9') - goto yy1662; - goto yy1692; + goto yy770; + goto yy800; } else { if (yych <= ';') - goto yy1662; + goto yy770; if (yych <= '=') - goto yy1633; + goto yy741; if (yych <= '>') - goto yy1647; - goto yy1662; + goto yy755; + goto yy770; } } } else { if (yych <= 0xDF) { if (yych <= '`') { if (yych <= 'Z') - goto yy1692; + goto yy800; if (yych <= '^') - goto yy1662; + goto yy770; if (yych <= '_') - goto yy1692; - goto yy1633; + goto yy800; + goto yy741; } else { if (yych <= 'z') - goto yy1692; + goto yy800; if (yych <= 0x7F) - goto yy1662; + goto yy770; if (yych <= 0xC1) - goto yy1633; - goto yy1664; + goto yy741; + goto yy772; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1665; + goto yy773; if (yych == 0xED) - goto yy1670; - goto yy1666; + goto yy778; + goto yy774; } else { if (yych <= 0xF0) - goto yy1667; + goto yy775; if (yych <= 0xF3) - goto yy1668; + goto yy776; if (yych <= 0xF4) - goto yy1669; - goto yy1633; + goto yy777; + goto yy741; } } } @@ -19846,813 +13529,813 @@ bufsize_t _scan_html_block_end_1(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= ';') { if (yych != '\n') - goto yy1701; + goto yy809; } else { if (yych <= '<') - goto yy1702; + goto yy810; if (yych <= 0x7F) - goto yy1701; + goto yy809; if (yych >= 0xC2) - goto yy1703; + goto yy811; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1705; + goto yy813; if (yych == 0xED) - goto yy1710; - goto yy1706; + goto yy818; + goto yy814; } else { if (yych <= 0xF0) - goto yy1707; + goto yy815; if (yych <= 0xF3) - goto yy1708; + goto yy816; if (yych <= 0xF4) - goto yy1709; + goto yy817; } } - yy1700 : { return 0; } - yy1701: + yy808 : { return 0; } + yy809: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x7F) { if (yych == '\n') - goto yy1700; - goto yy1715; + goto yy808; + goto yy823; } else { if (yych <= 0xC1) - goto yy1700; + goto yy808; if (yych <= 0xF4) - goto yy1715; - goto yy1700; + goto yy823; + goto yy808; } - yy1702: + yy810: yyaccept = 0; yych = *(marker = ++p); if (yych <= '/') { if (yych == '\n') - goto yy1700; + goto yy808; if (yych <= '.') - goto yy1715; - goto yy1711; + goto yy823; + goto yy819; } else { if (yych <= 0x7F) - goto yy1715; + goto yy823; if (yych <= 0xC1) - goto yy1700; + goto yy808; if (yych <= 0xF4) - goto yy1715; - goto yy1700; + goto yy823; + goto yy808; } - yy1703: + yy811: yych = *++p; if (yych <= 0x7F) - goto yy1704; + goto yy812; if (yych <= 0xBF) - goto yy1701; - yy1704: + goto yy809; + yy812: p = marker; if (yyaccept == 0) { - goto yy1700; + goto yy808; } else { - goto yy1732; + goto yy840; } - yy1705: + yy813: yych = *++p; if (yych <= 0x9F) - goto yy1704; + goto yy812; if (yych <= 0xBF) - goto yy1703; - goto yy1704; - yy1706: + goto yy811; + goto yy812; + yy814: yych = *++p; if (yych <= 0x7F) - goto yy1704; + goto yy812; if (yych <= 0xBF) - goto yy1703; - goto yy1704; - yy1707: + goto yy811; + goto yy812; + yy815: yych = *++p; if (yych <= 0x8F) - goto yy1704; + goto yy812; if (yych <= 0xBF) - goto yy1706; - goto yy1704; - yy1708: + goto yy814; + goto yy812; + yy816: yych = *++p; if (yych <= 0x7F) - goto yy1704; + goto yy812; if (yych <= 0xBF) - goto yy1706; - goto yy1704; - yy1709: + goto yy814; + goto yy812; + yy817: yych = *++p; if (yych <= 0x7F) - goto yy1704; + goto yy812; if (yych <= 0x8F) - goto yy1706; - goto yy1704; - yy1710: + goto yy814; + goto yy812; + yy818: yych = *++p; if (yych <= 0x7F) - goto yy1704; + goto yy812; if (yych <= 0x9F) - goto yy1703; - goto yy1704; - yy1711: + goto yy811; + goto yy812; + yy819: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 's') { if (yych <= 'R') { if (yych <= '\n') { if (yych <= '\t') - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } else { if (yych == 'P') - goto yy1723; - goto yy1714; + goto yy831; + goto yy822; } } else { if (yych <= 'o') { if (yych <= 'S') - goto yy1724; - goto yy1714; + goto yy832; + goto yy822; } else { if (yych <= 'p') - goto yy1723; + goto yy831; if (yych <= 'r') - goto yy1714; - goto yy1724; + goto yy822; + goto yy832; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } else { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; - goto yy1718; + goto yy825; + goto yy826; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1722; + goto yy830; if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } - yy1712: + yy820: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xDF) { if (yych <= '.') { if (yych == '\n') - goto yy1704; + goto yy812; } else { if (yych <= '/') - goto yy1711; + goto yy819; if (yych <= 0x7F) - goto yy1714; + goto yy822; if (yych <= 0xC1) - goto yy1704; - goto yy1716; + goto yy812; + goto yy824; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych == 0xED) - goto yy1722; - goto yy1718; + goto yy830; + goto yy826; } else { if (yych <= 0xF0) - goto yy1719; + goto yy827; if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } - yy1714: + yy822: ++p; yych = *p; - yy1715: + yy823: if (yybm[0 + yych] & 128) { - goto yy1714; + goto yy822; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1704; + goto yy812; if (yych <= '<') - goto yy1712; - goto yy1704; + goto yy820; + goto yy812; } else { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; - goto yy1718; + goto yy825; + goto yy826; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1722; + goto yy830; if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } - yy1716: + yy824: ++p; yych = *p; if (yych <= 0x7F) - goto yy1704; + goto yy812; if (yych <= 0xBF) - goto yy1714; - goto yy1704; - yy1717: + goto yy822; + goto yy812; + yy825: ++p; yych = *p; if (yych <= 0x9F) - goto yy1704; + goto yy812; if (yych <= 0xBF) - goto yy1716; - goto yy1704; - yy1718: + goto yy824; + goto yy812; + yy826: ++p; yych = *p; if (yych <= 0x7F) - goto yy1704; + goto yy812; if (yych <= 0xBF) - goto yy1716; - goto yy1704; - yy1719: + goto yy824; + goto yy812; + yy827: ++p; yych = *p; if (yych <= 0x8F) - goto yy1704; + goto yy812; if (yych <= 0xBF) - goto yy1718; - goto yy1704; - yy1720: + goto yy826; + goto yy812; + yy828: ++p; yych = *p; if (yych <= 0x7F) - goto yy1704; + goto yy812; if (yych <= 0xBF) - goto yy1718; - goto yy1704; - yy1721: + goto yy826; + goto yy812; + yy829: ++p; yych = *p; if (yych <= 0x7F) - goto yy1704; + goto yy812; if (yych <= 0x8F) - goto yy1718; - goto yy1704; - yy1722: + goto yy826; + goto yy812; + yy830: ++p; yych = *p; if (yych <= 0x7F) - goto yy1704; + goto yy812; if (yych <= 0x9F) - goto yy1716; - goto yy1704; - yy1723: + goto yy824; + goto yy812; + yy831: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xC1) { if (yych <= 'R') { if (yych == '\n') - goto yy1704; + goto yy812; if (yych <= 'Q') - goto yy1714; - goto yy1735; + goto yy822; + goto yy843; } else { if (yych == 'r') - goto yy1735; + goto yy843; if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych <= 0xEC) - goto yy1718; - goto yy1722; + goto yy826; + goto yy830; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } - yy1724: + yy832: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 't') { if (yych <= 'S') { if (yych <= '\n') { if (yych <= '\t') - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } else { if (yych == 'C') - goto yy1726; - goto yy1714; + goto yy834; + goto yy822; } } else { if (yych <= 'b') { if (yych >= 'U') - goto yy1714; + goto yy822; } else { if (yych <= 'c') - goto yy1726; + goto yy834; if (yych <= 's') - goto yy1714; + goto yy822; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } else { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; - goto yy1718; + goto yy825; + goto yy826; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1722; + goto yy830; if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xC1) { if (yych <= 'Y') { if (yych == '\n') - goto yy1704; + goto yy812; if (yych <= 'X') - goto yy1714; - goto yy1733; + goto yy822; + goto yy841; } else { if (yych == 'y') - goto yy1733; + goto yy841; if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych <= 0xEC) - goto yy1718; - goto yy1722; + goto yy826; + goto yy830; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } - yy1726: + yy834: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xC1) { if (yych <= 'R') { if (yych == '\n') - goto yy1704; + goto yy812; if (yych <= 'Q') - goto yy1714; + goto yy822; } else { if (yych == 'r') - goto yy1727; + goto yy835; if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych <= 0xEC) - goto yy1718; - goto yy1722; + goto yy826; + goto yy830; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } - yy1727: + yy835: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xC1) { if (yych <= 'I') { if (yych == '\n') - goto yy1704; + goto yy812; if (yych <= 'H') - goto yy1714; + goto yy822; } else { if (yych == 'i') - goto yy1728; + goto yy836; if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych <= 0xEC) - goto yy1718; - goto yy1722; + goto yy826; + goto yy830; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } - yy1728: + yy836: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xC1) { if (yych <= 'P') { if (yych == '\n') - goto yy1704; + goto yy812; if (yych <= 'O') - goto yy1714; + goto yy822; } else { if (yych == 'p') - goto yy1729; + goto yy837; if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych <= 0xEC) - goto yy1718; - goto yy1722; + goto yy826; + goto yy830; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } - yy1729: + yy837: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xC1) { if (yych <= 'T') { if (yych == '\n') - goto yy1704; + goto yy812; if (yych <= 'S') - goto yy1714; + goto yy822; } else { if (yych == 't') - goto yy1730; + goto yy838; if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych <= 0xEC) - goto yy1718; - goto yy1722; + goto yy826; + goto yy830; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } - yy1730: + yy838: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xDF) { if (yych <= '=') { if (yych == '\n') - goto yy1704; - goto yy1714; + goto yy812; + goto yy822; } else { if (yych <= '>') - goto yy1731; + goto yy839; if (yych <= 0x7F) - goto yy1714; + goto yy822; if (yych <= 0xC1) - goto yy1704; - goto yy1716; + goto yy812; + goto yy824; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych == 0xED) - goto yy1722; - goto yy1718; + goto yy830; + goto yy826; } else { if (yych <= 0xF0) - goto yy1719; + goto yy827; if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } - yy1731: + yy839: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1714; + goto yy822; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1732; + goto yy840; if (yych <= '<') - goto yy1712; + goto yy820; } else { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; - goto yy1718; + goto yy825; + goto yy826; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1722; + goto yy830; if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; + goto yy829; } } - yy1732 : { return (bufsize_t)(p - start); } - yy1733: + yy840 : { return (bufsize_t)(p - start); } + yy841: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xC1) { if (yych <= 'L') { if (yych == '\n') - goto yy1704; + goto yy812; if (yych <= 'K') - goto yy1714; + goto yy822; } else { if (yych == 'l') - goto yy1734; + goto yy842; if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych <= 0xEC) - goto yy1718; - goto yy1722; + goto yy826; + goto yy830; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } - yy1734: + yy842: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xC1) { if (yych <= 'E') { if (yych == '\n') - goto yy1704; + goto yy812; if (yych <= 'D') - goto yy1714; - goto yy1730; + goto yy822; + goto yy838; } else { if (yych == 'e') - goto yy1730; + goto yy838; if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych <= 0xEC) - goto yy1718; - goto yy1722; + goto yy826; + goto yy830; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } - yy1735: + yy843: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1712; + goto yy820; } if (yych <= 0xC1) { if (yych <= 'E') { if (yych == '\n') - goto yy1704; + goto yy812; if (yych <= 'D') - goto yy1714; - goto yy1730; + goto yy822; + goto yy838; } else { if (yych == 'e') - goto yy1730; + goto yy838; if (yych <= 0x7F) - goto yy1714; - goto yy1704; + goto yy822; + goto yy812; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1716; + goto yy824; if (yych <= 0xE0) - goto yy1717; + goto yy825; if (yych <= 0xEC) - goto yy1718; - goto yy1722; + goto yy826; + goto yy830; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1718; - goto yy1719; + goto yy826; + goto yy827; } else { if (yych <= 0xF3) - goto yy1720; + goto yy828; if (yych <= 0xF4) - goto yy1721; - goto yy1704; + goto yy829; + goto yy812; } } } @@ -20692,316 +14375,316 @@ bufsize_t _scan_html_block_end_2(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= ',') { if (yych != '\n') - goto yy1739; + goto yy847; } else { if (yych <= '-') - goto yy1740; + goto yy848; if (yych <= 0x7F) - goto yy1739; + goto yy847; if (yych >= 0xC2) - goto yy1741; + goto yy849; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1743; + goto yy851; if (yych == 0xED) - goto yy1748; - goto yy1744; + goto yy856; + goto yy852; } else { if (yych <= 0xF0) - goto yy1745; + goto yy853; if (yych <= 0xF3) - goto yy1746; + goto yy854; if (yych <= 0xF4) - goto yy1747; + goto yy855; } } - yy1738 : { return 0; } - yy1739: + yy846 : { return 0; } + yy847: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x7F) { if (yych == '\n') - goto yy1738; - goto yy1752; + goto yy846; + goto yy860; } else { if (yych <= 0xC1) - goto yy1738; + goto yy846; if (yych <= 0xF4) - goto yy1752; - goto yy1738; + goto yy860; + goto yy846; } - yy1740: + yy848: yyaccept = 0; yych = *(marker = ++p); if (yybm[0 + yych] & 64) { - goto yy1749; + goto yy857; } if (yych <= 0x7F) { if (yych == '\n') - goto yy1738; - goto yy1752; + goto yy846; + goto yy860; } else { if (yych <= 0xC1) - goto yy1738; + goto yy846; if (yych <= 0xF4) - goto yy1752; - goto yy1738; + goto yy860; + goto yy846; } - yy1741: + yy849: yych = *++p; if (yych <= 0x7F) - goto yy1742; + goto yy850; if (yych <= 0xBF) - goto yy1739; - yy1742: + goto yy847; + yy850: p = marker; if (yyaccept == 0) { - goto yy1738; + goto yy846; } else { - goto yy1762; + goto yy870; } - yy1743: + yy851: yych = *++p; if (yych <= 0x9F) - goto yy1742; + goto yy850; if (yych <= 0xBF) - goto yy1741; - goto yy1742; - yy1744: + goto yy849; + goto yy850; + yy852: yych = *++p; if (yych <= 0x7F) - goto yy1742; + goto yy850; if (yych <= 0xBF) - goto yy1741; - goto yy1742; - yy1745: + goto yy849; + goto yy850; + yy853: yych = *++p; if (yych <= 0x8F) - goto yy1742; + goto yy850; if (yych <= 0xBF) - goto yy1744; - goto yy1742; - yy1746: + goto yy852; + goto yy850; + yy854: yych = *++p; if (yych <= 0x7F) - goto yy1742; + goto yy850; if (yych <= 0xBF) - goto yy1744; - goto yy1742; - yy1747: + goto yy852; + goto yy850; + yy855: yych = *++p; if (yych <= 0x7F) - goto yy1742; + goto yy850; if (yych <= 0x8F) - goto yy1744; - goto yy1742; - yy1748: + goto yy852; + goto yy850; + yy856: yych = *++p; if (yych <= 0x7F) - goto yy1742; + goto yy850; if (yych <= 0x9F) - goto yy1741; - goto yy1742; - yy1749: + goto yy849; + goto yy850; + yy857: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1749; + goto yy857; } if (yych <= 0xDF) { if (yych <= '=') { if (yych == '\n') - goto yy1742; + goto yy850; } else { if (yych <= '>') - goto yy1761; + goto yy869; if (yych <= 0x7F) - goto yy1751; + goto yy859; if (yych <= 0xC1) - goto yy1742; - goto yy1753; + goto yy850; + goto yy861; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1754; + goto yy862; if (yych == 0xED) - goto yy1759; - goto yy1755; + goto yy867; + goto yy863; } else { if (yych <= 0xF0) - goto yy1756; + goto yy864; if (yych <= 0xF3) - goto yy1757; + goto yy865; if (yych <= 0xF4) - goto yy1758; - goto yy1742; + goto yy866; + goto yy850; } } - yy1751: + yy859: ++p; yych = *p; - yy1752: + yy860: if (yybm[0 + yych] & 128) { - goto yy1751; + goto yy859; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1742; + goto yy850; if (yych <= '-') - goto yy1760; - goto yy1742; + goto yy868; + goto yy850; } else { if (yych <= 0xDF) - goto yy1753; + goto yy861; if (yych <= 0xE0) - goto yy1754; - goto yy1755; + goto yy862; + goto yy863; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1759; + goto yy867; if (yych <= 0xEF) - goto yy1755; - goto yy1756; + goto yy863; + goto yy864; } else { if (yych <= 0xF3) - goto yy1757; + goto yy865; if (yych <= 0xF4) - goto yy1758; - goto yy1742; + goto yy866; + goto yy850; } } - yy1753: + yy861: ++p; yych = *p; if (yych <= 0x7F) - goto yy1742; + goto yy850; if (yych <= 0xBF) - goto yy1751; - goto yy1742; - yy1754: + goto yy859; + goto yy850; + yy862: ++p; yych = *p; if (yych <= 0x9F) - goto yy1742; + goto yy850; if (yych <= 0xBF) - goto yy1753; - goto yy1742; - yy1755: + goto yy861; + goto yy850; + yy863: ++p; yych = *p; if (yych <= 0x7F) - goto yy1742; + goto yy850; if (yych <= 0xBF) - goto yy1753; - goto yy1742; - yy1756: + goto yy861; + goto yy850; + yy864: ++p; yych = *p; if (yych <= 0x8F) - goto yy1742; + goto yy850; if (yych <= 0xBF) - goto yy1755; - goto yy1742; - yy1757: + goto yy863; + goto yy850; + yy865: ++p; yych = *p; if (yych <= 0x7F) - goto yy1742; + goto yy850; if (yych <= 0xBF) - goto yy1755; - goto yy1742; - yy1758: + goto yy863; + goto yy850; + yy866: ++p; yych = *p; if (yych <= 0x7F) - goto yy1742; + goto yy850; if (yych <= 0x8F) - goto yy1755; - goto yy1742; - yy1759: + goto yy863; + goto yy850; + yy867: ++p; yych = *p; if (yych <= 0x7F) - goto yy1742; + goto yy850; if (yych <= 0x9F) - goto yy1753; - goto yy1742; - yy1760: + goto yy861; + goto yy850; + yy868: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1751; + goto yy859; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1742; + goto yy850; if (yych <= '-') - goto yy1749; - goto yy1742; + goto yy857; + goto yy850; } else { if (yych <= 0xDF) - goto yy1753; + goto yy861; if (yych <= 0xE0) - goto yy1754; - goto yy1755; + goto yy862; + goto yy863; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1759; + goto yy867; if (yych <= 0xEF) - goto yy1755; - goto yy1756; + goto yy863; + goto yy864; } else { if (yych <= 0xF3) - goto yy1757; + goto yy865; if (yych <= 0xF4) - goto yy1758; - goto yy1742; + goto yy866; + goto yy850; } } - yy1761: + yy869: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1751; + goto yy859; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1762; + goto yy870; if (yych <= '-') - goto yy1760; + goto yy868; } else { if (yych <= 0xDF) - goto yy1753; + goto yy861; if (yych <= 0xE0) - goto yy1754; - goto yy1755; + goto yy862; + goto yy863; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1759; + goto yy867; if (yych <= 0xEF) - goto yy1755; - goto yy1756; + goto yy863; + goto yy864; } else { if (yych <= 0xF3) - goto yy1757; + goto yy865; if (yych <= 0xF4) - goto yy1758; + goto yy866; } } - yy1762 : { return (bufsize_t)(p - start); } + yy870 : { return (bufsize_t)(p - start); } } } @@ -21038,282 +14721,282 @@ bufsize_t _scan_html_block_end_3(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= '>') { if (yych != '\n') - goto yy1766; + goto yy874; } else { if (yych <= '?') - goto yy1767; + goto yy875; if (yych <= 0x7F) - goto yy1766; + goto yy874; if (yych >= 0xC2) - goto yy1768; + goto yy876; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1770; + goto yy878; if (yych == 0xED) - goto yy1775; - goto yy1771; + goto yy883; + goto yy879; } else { if (yych <= 0xF0) - goto yy1772; + goto yy880; if (yych <= 0xF3) - goto yy1773; + goto yy881; if (yych <= 0xF4) - goto yy1774; + goto yy882; } } - yy1765 : { return 0; } - yy1766: + yy873 : { return 0; } + yy874: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x7F) { if (yych == '\n') - goto yy1765; - goto yy1781; + goto yy873; + goto yy889; } else { if (yych <= 0xC1) - goto yy1765; + goto yy873; if (yych <= 0xF4) - goto yy1781; - goto yy1765; + goto yy889; + goto yy873; } - yy1767: + yy875: yyaccept = 0; yych = *(marker = ++p); if (yych <= '>') { if (yych == '\n') - goto yy1765; + goto yy873; if (yych <= '=') - goto yy1781; - goto yy1776; + goto yy889; + goto yy884; } else { if (yych <= 0x7F) - goto yy1781; + goto yy889; if (yych <= 0xC1) - goto yy1765; + goto yy873; if (yych <= 0xF4) - goto yy1781; - goto yy1765; + goto yy889; + goto yy873; } - yy1768: + yy876: yych = *++p; if (yych <= 0x7F) - goto yy1769; + goto yy877; if (yych <= 0xBF) - goto yy1766; - yy1769: + goto yy874; + yy877: p = marker; if (yyaccept == 0) { - goto yy1765; + goto yy873; } else { - goto yy1777; + goto yy885; } - yy1770: + yy878: yych = *++p; if (yych <= 0x9F) - goto yy1769; + goto yy877; if (yych <= 0xBF) - goto yy1768; - goto yy1769; - yy1771: + goto yy876; + goto yy877; + yy879: yych = *++p; if (yych <= 0x7F) - goto yy1769; + goto yy877; if (yych <= 0xBF) - goto yy1768; - goto yy1769; - yy1772: + goto yy876; + goto yy877; + yy880: yych = *++p; if (yych <= 0x8F) - goto yy1769; + goto yy877; if (yych <= 0xBF) - goto yy1771; - goto yy1769; - yy1773: + goto yy879; + goto yy877; + yy881: yych = *++p; if (yych <= 0x7F) - goto yy1769; + goto yy877; if (yych <= 0xBF) - goto yy1771; - goto yy1769; - yy1774: + goto yy879; + goto yy877; + yy882: yych = *++p; if (yych <= 0x7F) - goto yy1769; + goto yy877; if (yych <= 0x8F) - goto yy1771; - goto yy1769; - yy1775: + goto yy879; + goto yy877; + yy883: yych = *++p; if (yych <= 0x7F) - goto yy1769; + goto yy877; if (yych <= 0x9F) - goto yy1768; - goto yy1769; - yy1776: + goto yy876; + goto yy877; + yy884: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1780; + goto yy888; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1777; + goto yy885; if (yych <= '?') - goto yy1778; + goto yy886; } else { if (yych <= 0xDF) - goto yy1782; + goto yy890; if (yych <= 0xE0) - goto yy1783; - goto yy1784; + goto yy891; + goto yy892; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1788; + goto yy896; if (yych <= 0xEF) - goto yy1784; - goto yy1785; + goto yy892; + goto yy893; } else { if (yych <= 0xF3) - goto yy1786; + goto yy894; if (yych <= 0xF4) - goto yy1787; + goto yy895; } } - yy1777 : { return (bufsize_t)(p - start); } - yy1778: + yy885 : { return (bufsize_t)(p - start); } + yy886: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1778; + goto yy886; } if (yych <= 0xDF) { if (yych <= '=') { if (yych == '\n') - goto yy1769; + goto yy877; } else { if (yych <= '>') - goto yy1776; + goto yy884; if (yych <= 0x7F) - goto yy1780; + goto yy888; if (yych <= 0xC1) - goto yy1769; - goto yy1782; + goto yy877; + goto yy890; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1783; + goto yy891; if (yych == 0xED) - goto yy1788; - goto yy1784; + goto yy896; + goto yy892; } else { if (yych <= 0xF0) - goto yy1785; + goto yy893; if (yych <= 0xF3) - goto yy1786; + goto yy894; if (yych <= 0xF4) - goto yy1787; - goto yy1769; + goto yy895; + goto yy877; } } - yy1780: + yy888: ++p; yych = *p; - yy1781: + yy889: if (yybm[0 + yych] & 128) { - goto yy1780; + goto yy888; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1769; + goto yy877; if (yych <= '?') - goto yy1778; - goto yy1769; + goto yy886; + goto yy877; } else { if (yych <= 0xDF) - goto yy1782; + goto yy890; if (yych <= 0xE0) - goto yy1783; - goto yy1784; + goto yy891; + goto yy892; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1788; + goto yy896; if (yych <= 0xEF) - goto yy1784; - goto yy1785; + goto yy892; + goto yy893; } else { if (yych <= 0xF3) - goto yy1786; + goto yy894; if (yych <= 0xF4) - goto yy1787; - goto yy1769; + goto yy895; + goto yy877; } } - yy1782: + yy890: ++p; yych = *p; if (yych <= 0x7F) - goto yy1769; + goto yy877; if (yych <= 0xBF) - goto yy1780; - goto yy1769; - yy1783: + goto yy888; + goto yy877; + yy891: ++p; yych = *p; if (yych <= 0x9F) - goto yy1769; + goto yy877; if (yych <= 0xBF) - goto yy1782; - goto yy1769; - yy1784: + goto yy890; + goto yy877; + yy892: ++p; yych = *p; if (yych <= 0x7F) - goto yy1769; + goto yy877; if (yych <= 0xBF) - goto yy1782; - goto yy1769; - yy1785: + goto yy890; + goto yy877; + yy893: ++p; yych = *p; if (yych <= 0x8F) - goto yy1769; + goto yy877; if (yych <= 0xBF) - goto yy1784; - goto yy1769; - yy1786: + goto yy892; + goto yy877; + yy894: ++p; yych = *p; if (yych <= 0x7F) - goto yy1769; + goto yy877; if (yych <= 0xBF) - goto yy1784; - goto yy1769; - yy1787: + goto yy892; + goto yy877; + yy895: ++p; yych = *p; if (yych <= 0x7F) - goto yy1769; + goto yy877; if (yych <= 0x8F) - goto yy1784; - goto yy1769; - yy1788: + goto yy892; + goto yy877; + yy896: ++p; yych = *p; if (yych <= 0x7F) - goto yy1769; + goto yy877; if (yych <= 0x9F) - goto yy1782; - goto yy1769; + goto yy890; + goto yy877; } } @@ -21350,242 +15033,242 @@ bufsize_t _scan_html_block_end_4(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= '=') { if (yych != '\n') - goto yy1792; + goto yy900; } else { if (yych <= '>') - goto yy1793; + goto yy901; if (yych <= 0x7F) - goto yy1792; + goto yy900; if (yych >= 0xC2) - goto yy1795; + goto yy903; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1797; + goto yy905; if (yych == 0xED) - goto yy1802; - goto yy1798; + goto yy910; + goto yy906; } else { if (yych <= 0xF0) - goto yy1799; + goto yy907; if (yych <= 0xF3) - goto yy1800; + goto yy908; if (yych <= 0xF4) - goto yy1801; + goto yy909; } } - yy1791 : { return 0; } - yy1792: + yy899 : { return 0; } + yy900: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x7F) { if (yych == '\n') - goto yy1791; - goto yy1806; + goto yy899; + goto yy914; } else { if (yych <= 0xC1) - goto yy1791; + goto yy899; if (yych <= 0xF4) - goto yy1806; - goto yy1791; + goto yy914; + goto yy899; } - yy1793: + yy901: yyaccept = 1; yych = *(marker = ++p); if (yych <= 0x7F) { if (yych != '\n') - goto yy1806; + goto yy914; } else { if (yych <= 0xC1) - goto yy1794; + goto yy902; if (yych <= 0xF4) - goto yy1806; + goto yy914; } - yy1794 : { return (bufsize_t)(p - start); } - yy1795: + yy902 : { return (bufsize_t)(p - start); } + yy903: yych = *++p; if (yych <= 0x7F) - goto yy1796; + goto yy904; if (yych <= 0xBF) - goto yy1792; - yy1796: + goto yy900; + yy904: p = marker; if (yyaccept == 0) { - goto yy1791; + goto yy899; } else { - goto yy1794; + goto yy902; } - yy1797: + yy905: yych = *++p; if (yych <= 0x9F) - goto yy1796; + goto yy904; if (yych <= 0xBF) - goto yy1795; - goto yy1796; - yy1798: + goto yy903; + goto yy904; + yy906: yych = *++p; if (yych <= 0x7F) - goto yy1796; + goto yy904; if (yych <= 0xBF) - goto yy1795; - goto yy1796; - yy1799: + goto yy903; + goto yy904; + yy907: yych = *++p; if (yych <= 0x8F) - goto yy1796; + goto yy904; if (yych <= 0xBF) - goto yy1798; - goto yy1796; - yy1800: + goto yy906; + goto yy904; + yy908: yych = *++p; if (yych <= 0x7F) - goto yy1796; + goto yy904; if (yych <= 0xBF) - goto yy1798; - goto yy1796; - yy1801: + goto yy906; + goto yy904; + yy909: yych = *++p; if (yych <= 0x7F) - goto yy1796; + goto yy904; if (yych <= 0x8F) - goto yy1798; - goto yy1796; - yy1802: + goto yy906; + goto yy904; + yy910: yych = *++p; if (yych <= 0x7F) - goto yy1796; + goto yy904; if (yych <= 0x9F) - goto yy1795; - goto yy1796; - yy1803: + goto yy903; + goto yy904; + yy911: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1805; + goto yy913; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1794; + goto yy902; if (yych <= '>') - goto yy1803; - goto yy1794; + goto yy911; + goto yy902; } else { if (yych <= 0xDF) - goto yy1807; + goto yy915; if (yych <= 0xE0) - goto yy1808; - goto yy1809; + goto yy916; + goto yy917; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1813; + goto yy921; if (yych <= 0xEF) - goto yy1809; - goto yy1810; + goto yy917; + goto yy918; } else { if (yych <= 0xF3) - goto yy1811; + goto yy919; if (yych <= 0xF4) - goto yy1812; - goto yy1794; + goto yy920; + goto yy902; } } - yy1805: + yy913: ++p; yych = *p; - yy1806: + yy914: if (yybm[0 + yych] & 128) { - goto yy1805; + goto yy913; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1796; + goto yy904; if (yych <= '>') - goto yy1803; - goto yy1796; + goto yy911; + goto yy904; } else { if (yych <= 0xDF) - goto yy1807; + goto yy915; if (yych <= 0xE0) - goto yy1808; - goto yy1809; + goto yy916; + goto yy917; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1813; + goto yy921; if (yych <= 0xEF) - goto yy1809; - goto yy1810; + goto yy917; + goto yy918; } else { if (yych <= 0xF3) - goto yy1811; + goto yy919; if (yych <= 0xF4) - goto yy1812; - goto yy1796; + goto yy920; + goto yy904; } } - yy1807: + yy915: ++p; yych = *p; if (yych <= 0x7F) - goto yy1796; + goto yy904; if (yych <= 0xBF) - goto yy1805; - goto yy1796; - yy1808: + goto yy913; + goto yy904; + yy916: ++p; yych = *p; if (yych <= 0x9F) - goto yy1796; + goto yy904; if (yych <= 0xBF) - goto yy1807; - goto yy1796; - yy1809: + goto yy915; + goto yy904; + yy917: ++p; yych = *p; if (yych <= 0x7F) - goto yy1796; + goto yy904; if (yych <= 0xBF) - goto yy1807; - goto yy1796; - yy1810: + goto yy915; + goto yy904; + yy918: ++p; yych = *p; if (yych <= 0x8F) - goto yy1796; + goto yy904; if (yych <= 0xBF) - goto yy1809; - goto yy1796; - yy1811: + goto yy917; + goto yy904; + yy919: ++p; yych = *p; if (yych <= 0x7F) - goto yy1796; + goto yy904; if (yych <= 0xBF) - goto yy1809; - goto yy1796; - yy1812: + goto yy917; + goto yy904; + yy920: ++p; yych = *p; if (yych <= 0x7F) - goto yy1796; + goto yy904; if (yych <= 0x8F) - goto yy1809; - goto yy1796; - yy1813: + goto yy917; + goto yy904; + yy921: ++p; yych = *p; if (yych <= 0x7F) - goto yy1796; + goto yy904; if (yych <= 0x9F) - goto yy1807; - goto yy1796; + goto yy915; + goto yy904; } } @@ -21622,316 +15305,316 @@ bufsize_t _scan_html_block_end_5(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= '\\') { if (yych != '\n') - goto yy1817; + goto yy925; } else { if (yych <= ']') - goto yy1818; + goto yy926; if (yych <= 0x7F) - goto yy1817; + goto yy925; if (yych >= 0xC2) - goto yy1819; + goto yy927; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1821; + goto yy929; if (yych == 0xED) - goto yy1826; - goto yy1822; + goto yy934; + goto yy930; } else { if (yych <= 0xF0) - goto yy1823; + goto yy931; if (yych <= 0xF3) - goto yy1824; + goto yy932; if (yych <= 0xF4) - goto yy1825; + goto yy933; } } - yy1816 : { return 0; } - yy1817: + yy924 : { return 0; } + yy925: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x7F) { if (yych == '\n') - goto yy1816; - goto yy1830; + goto yy924; + goto yy938; } else { if (yych <= 0xC1) - goto yy1816; + goto yy924; if (yych <= 0xF4) - goto yy1830; - goto yy1816; + goto yy938; + goto yy924; } - yy1818: + yy926: yyaccept = 0; yych = *(marker = ++p); if (yybm[0 + yych] & 64) { - goto yy1827; + goto yy935; } if (yych <= 0x7F) { if (yych == '\n') - goto yy1816; - goto yy1830; + goto yy924; + goto yy938; } else { if (yych <= 0xC1) - goto yy1816; + goto yy924; if (yych <= 0xF4) - goto yy1830; - goto yy1816; + goto yy938; + goto yy924; } - yy1819: + yy927: yych = *++p; if (yych <= 0x7F) - goto yy1820; + goto yy928; if (yych <= 0xBF) - goto yy1817; - yy1820: + goto yy925; + yy928: p = marker; if (yyaccept == 0) { - goto yy1816; + goto yy924; } else { - goto yy1840; + goto yy948; } - yy1821: + yy929: yych = *++p; if (yych <= 0x9F) - goto yy1820; + goto yy928; if (yych <= 0xBF) - goto yy1819; - goto yy1820; - yy1822: + goto yy927; + goto yy928; + yy930: yych = *++p; if (yych <= 0x7F) - goto yy1820; + goto yy928; if (yych <= 0xBF) - goto yy1819; - goto yy1820; - yy1823: + goto yy927; + goto yy928; + yy931: yych = *++p; if (yych <= 0x8F) - goto yy1820; + goto yy928; if (yych <= 0xBF) - goto yy1822; - goto yy1820; - yy1824: + goto yy930; + goto yy928; + yy932: yych = *++p; if (yych <= 0x7F) - goto yy1820; + goto yy928; if (yych <= 0xBF) - goto yy1822; - goto yy1820; - yy1825: + goto yy930; + goto yy928; + yy933: yych = *++p; if (yych <= 0x7F) - goto yy1820; + goto yy928; if (yych <= 0x8F) - goto yy1822; - goto yy1820; - yy1826: + goto yy930; + goto yy928; + yy934: yych = *++p; if (yych <= 0x7F) - goto yy1820; + goto yy928; if (yych <= 0x9F) - goto yy1819; - goto yy1820; - yy1827: + goto yy927; + goto yy928; + yy935: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1827; + goto yy935; } if (yych <= 0xDF) { if (yych <= '=') { if (yych == '\n') - goto yy1820; + goto yy928; } else { if (yych <= '>') - goto yy1839; + goto yy947; if (yych <= 0x7F) - goto yy1829; + goto yy937; if (yych <= 0xC1) - goto yy1820; - goto yy1831; + goto yy928; + goto yy939; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1832; + goto yy940; if (yych == 0xED) - goto yy1837; - goto yy1833; + goto yy945; + goto yy941; } else { if (yych <= 0xF0) - goto yy1834; + goto yy942; if (yych <= 0xF3) - goto yy1835; + goto yy943; if (yych <= 0xF4) - goto yy1836; - goto yy1820; + goto yy944; + goto yy928; } } - yy1829: + yy937: ++p; yych = *p; - yy1830: + yy938: if (yybm[0 + yych] & 128) { - goto yy1829; + goto yy937; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1820; + goto yy928; if (yych <= ']') - goto yy1838; - goto yy1820; + goto yy946; + goto yy928; } else { if (yych <= 0xDF) - goto yy1831; + goto yy939; if (yych <= 0xE0) - goto yy1832; - goto yy1833; + goto yy940; + goto yy941; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1837; + goto yy945; if (yych <= 0xEF) - goto yy1833; - goto yy1834; + goto yy941; + goto yy942; } else { if (yych <= 0xF3) - goto yy1835; + goto yy943; if (yych <= 0xF4) - goto yy1836; - goto yy1820; + goto yy944; + goto yy928; } } - yy1831: + yy939: ++p; yych = *p; if (yych <= 0x7F) - goto yy1820; + goto yy928; if (yych <= 0xBF) - goto yy1829; - goto yy1820; - yy1832: + goto yy937; + goto yy928; + yy940: ++p; yych = *p; if (yych <= 0x9F) - goto yy1820; + goto yy928; if (yych <= 0xBF) - goto yy1831; - goto yy1820; - yy1833: + goto yy939; + goto yy928; + yy941: ++p; yych = *p; if (yych <= 0x7F) - goto yy1820; + goto yy928; if (yych <= 0xBF) - goto yy1831; - goto yy1820; - yy1834: + goto yy939; + goto yy928; + yy942: ++p; yych = *p; if (yych <= 0x8F) - goto yy1820; + goto yy928; if (yych <= 0xBF) - goto yy1833; - goto yy1820; - yy1835: + goto yy941; + goto yy928; + yy943: ++p; yych = *p; if (yych <= 0x7F) - goto yy1820; + goto yy928; if (yych <= 0xBF) - goto yy1833; - goto yy1820; - yy1836: + goto yy941; + goto yy928; + yy944: ++p; yych = *p; if (yych <= 0x7F) - goto yy1820; + goto yy928; if (yych <= 0x8F) - goto yy1833; - goto yy1820; - yy1837: + goto yy941; + goto yy928; + yy945: ++p; yych = *p; if (yych <= 0x7F) - goto yy1820; + goto yy928; if (yych <= 0x9F) - goto yy1831; - goto yy1820; - yy1838: + goto yy939; + goto yy928; + yy946: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1829; + goto yy937; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1820; + goto yy928; if (yych <= ']') - goto yy1827; - goto yy1820; + goto yy935; + goto yy928; } else { if (yych <= 0xDF) - goto yy1831; + goto yy939; if (yych <= 0xE0) - goto yy1832; - goto yy1833; + goto yy940; + goto yy941; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1837; + goto yy945; if (yych <= 0xEF) - goto yy1833; - goto yy1834; + goto yy941; + goto yy942; } else { if (yych <= 0xF3) - goto yy1835; + goto yy943; if (yych <= 0xF4) - goto yy1836; - goto yy1820; + goto yy944; + goto yy928; } } - yy1839: + yy947: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1829; + goto yy937; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy1840; + goto yy948; if (yych <= ']') - goto yy1838; + goto yy946; } else { if (yych <= 0xDF) - goto yy1831; + goto yy939; if (yych <= 0xE0) - goto yy1832; - goto yy1833; + goto yy940; + goto yy941; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1837; + goto yy945; if (yych <= 0xEF) - goto yy1833; - goto yy1834; + goto yy941; + goto yy942; } else { if (yych <= 0xF3) - goto yy1835; + goto yy943; if (yych <= 0xF4) - goto yy1836; + goto yy944; } } - yy1840 : { return (bufsize_t)(p - start); } + yy948 : { return (bufsize_t)(p - start); } } } @@ -21947,9 +15630,9 @@ bufsize_t _scan_link_url(const unsigned char *p) { unsigned char yych; unsigned int yyaccept = 0; static const unsigned char yybm[] = { - 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 8, 128, 128, 8, + 0, 128, 128, 128, 128, 128, 128, 128, 128, 0, 8, 128, 128, 8, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 136, 224, 224, 224, 224, 224, 224, 224, 128, 128, + 128, 128, 128, 128, 8, 224, 224, 224, 224, 224, 224, 224, 128, 128, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 32, 224, 32, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, @@ -21972,1605 +15655,2050 @@ bufsize_t _scan_link_url(const unsigned char *p) { if (yych <= ' ') { if (yych <= '\f') { if (yych == '\n') - goto yy1844; - goto yy1860; + goto yy952; + goto yy968; } else { if (yych <= '\r') - goto yy1846; + goto yy954; if (yych <= 0x1F) - goto yy1860; - goto yy1846; + goto yy968; + goto yy954; } } else { if (yych <= ')') { if (yych <= '\'') - goto yy1849; + goto yy956; if (yych <= '(') - goto yy1858; - goto yy1860; + goto yy966; + goto yy968; } else { if (yych == '<') - goto yy1847; - goto yy1849; + goto yy955; + goto yy956; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\\') - goto yy1848; + goto yy965; if (yych <= 0x7F) - goto yy1849; + goto yy956; } else { if (yych <= 0xDF) - goto yy1850; + goto yy957; if (yych <= 0xE0) - goto yy1852; - goto yy1853; + goto yy959; + goto yy960; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1857; + goto yy964; if (yych <= 0xEF) - goto yy1853; - goto yy1854; + goto yy960; + goto yy961; } else { if (yych <= 0xF3) - goto yy1855; + goto yy962; if (yych <= 0xF4) - goto yy1856; + goto yy963; } } } - yy1843 : { return (bufsize_t)(p - start); } - yy1844: + yy951 : { return (bufsize_t)(p - start); } + yy952: yyaccept = 0; marker = ++p; yych = *p; - yy1845: + yy953: if (yybm[0 + yych] & 8) { - goto yy1844; + goto yy952; } if (yych <= 0x7F) { if (yych <= ')') { if (yych <= 0x1F) - goto yy1843; + goto yy951; if (yych <= '\'') - goto yy1872; + goto yy980; if (yych <= '(') - goto yy1863; - goto yy1843; + goto yy971; + goto yy951; } else { if (yych <= '<') { if (yych <= ';') - goto yy1872; - goto yy1896; + goto yy980; + goto yy1016; } else { if (yych == '\\') - goto yy1874; - goto yy1872; + goto yy982; + goto yy980; } } } else { if (yych <= 0xED) { if (yych <= 0xDF) { if (yych <= 0xC1) - goto yy1843; - goto yy1876; + goto yy951; + goto yy983; } else { if (yych <= 0xE0) - goto yy1877; + goto yy984; if (yych <= 0xEC) - goto yy1878; - goto yy1882; + goto yy985; + goto yy989; } } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1878; - goto yy1879; + goto yy985; + goto yy986; } else { if (yych <= 0xF3) - goto yy1880; + goto yy987; if (yych <= 0xF4) - goto yy1881; - goto yy1843; + goto yy988; + goto yy951; } } } - yy1846: + yy954: yyaccept = 0; yych = *(marker = ++p); - goto yy1845; - yy1847: + goto yy953; + yy955: yyaccept = 0; yych = *(marker = ++p); if (yybm[0 + yych] & 64) { - goto yy1896; + goto yy1016; } if (yych <= '>') { if (yych <= '\r') { - if (yych <= '\t') { + if (yych <= 0x08) { if (yych <= 0x00) - goto yy1843; - goto yy1909; + goto yy951; + goto yy1029; } else { if (yych <= '\n') - goto yy1843; + goto yy951; if (yych <= '\f') - goto yy1909; - goto yy1843; + goto yy1029; + goto yy951; } } else { if (yych <= '(') { + if (yych <= 0x1F) + goto yy1029; if (yych <= ' ') - goto yy1909; - goto yy1907; + goto yy951; + goto yy1027; } else { if (yych <= ')') - goto yy1909; + goto yy1029; if (yych <= '<') - goto yy1872; - goto yy1898; + goto yy980; + goto yy1018; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\\') - goto yy1894; - goto yy1843; + goto yy1015; + goto yy951; } else { if (yych <= 0xDF) - goto yy1900; + goto yy1020; if (yych <= 0xE0) - goto yy1901; - goto yy1902; + goto yy1021; + goto yy1022; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1906; + goto yy1026; if (yych <= 0xEF) - goto yy1902; - goto yy1903; + goto yy1022; + goto yy1023; } else { if (yych <= 0xF3) - goto yy1904; + goto yy1024; if (yych <= 0xF4) - goto yy1905; - goto yy1843; + goto yy1025; + goto yy951; } } } - yy1848: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= '\'') - goto yy1873; - if (yych <= '(') - goto yy1883; - if (yych <= ')') - goto yy1872; - goto yy1873; - yy1849: + yy956: yyaccept = 0; yych = *(marker = ++p); - goto yy1873; - yy1850: + goto yy981; + yy957: yych = *++p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1849; - yy1851: + goto yy956; + yy958: p = marker; if (yyaccept <= 1) { if (yyaccept == 0) { - goto yy1843; + goto yy951; } else { - goto yy1859; + goto yy967; } } else { - goto yy1899; + goto yy1019; } - yy1852: + yy959: yych = *++p; if (yych <= 0x9F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1850; - goto yy1851; - yy1853: + goto yy957; + goto yy958; + yy960: yych = *++p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1850; - goto yy1851; - yy1854: + goto yy957; + goto yy958; + yy961: yych = *++p; if (yych <= 0x8F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1853; - goto yy1851; - yy1855: + goto yy960; + goto yy958; + yy962: yych = *++p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1853; - goto yy1851; - yy1856: + goto yy960; + goto yy958; + yy963: yych = *++p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x8F) - goto yy1853; - goto yy1851; - yy1857: + goto yy960; + goto yy958; + yy964: yych = *++p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x9F) - goto yy1850; - goto yy1851; - yy1858: + goto yy957; + goto yy958; + yy965: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0xDF) { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy980; + if (yych <= '\r') + goto yy951; + goto yy980; + } else { + if (yych <= ' ') + goto yy951; + if (yych <= 0x7F) + goto yy980; + if (yych <= 0xC1) + goto yy951; + goto yy990; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy991; + if (yych == 0xED) + goto yy996; + goto yy992; + } else { + if (yych <= 0xF0) + goto yy993; + if (yych <= 0xF3) + goto yy994; + if (yych <= 0xF4) + goto yy995; + goto yy951; + } + } + yy966: yyaccept = 1; yych = *(marker = ++p); if (yych <= '(') { if (yych <= ' ') - goto yy1859; + goto yy967; if (yych <= '\'') - goto yy1864; + goto yy972; } else { if (yych <= 0x7F) - goto yy1864; + goto yy972; if (yych <= 0xC1) - goto yy1859; + goto yy967; if (yych <= 0xF4) - goto yy1864; + goto yy972; } - yy1859 : { return 0; } - yy1860: + yy967 : { return 0; } + yy968: yych = *++p; - goto yy1859; - yy1861: + goto yy967; + yy969: ++p; yych = *p; if (yybm[0 + yych] & 16) { - goto yy1861; + goto yy969; } if (yych <= 0xE0) { if (yych <= ')') { if (yych <= ' ') - goto yy1851; + goto yy958; if (yych >= ')') - goto yy1883; + goto yy997; } else { if (yych <= 0x7F) - goto yy1863; + goto yy971; if (yych <= 0xC1) - goto yy1851; + goto yy958; if (yych <= 0xDF) - goto yy1865; - goto yy1866; + goto yy973; + goto yy974; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1871; - goto yy1867; + goto yy979; + goto yy975; } else { if (yych <= 0xF0) - goto yy1868; + goto yy976; if (yych <= 0xF3) - goto yy1869; + goto yy977; if (yych <= 0xF4) - goto yy1870; - goto yy1851; + goto yy978; + goto yy958; } } - yy1863: + yy971: ++p; yych = *p; - yy1864: + yy972: if (yybm[0 + yych] & 32) { - goto yy1863; + goto yy971; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= '(') + goto yy958; + if (yych <= ')') + goto yy980; + goto yy969; + } else { + if (yych <= 0xC1) + goto yy958; + if (yych >= 0xE0) + goto yy974; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy979; + goto yy975; + } else { + if (yych <= 0xF0) + goto yy976; + if (yych <= 0xF3) + goto yy977; + if (yych <= 0xF4) + goto yy978; + goto yy958; + } + } + yy973: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy971; + goto yy958; + yy974: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy958; + if (yych <= 0xBF) + goto yy973; + goto yy958; + yy975: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy973; + goto yy958; + yy976: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy958; + if (yych <= 0xBF) + goto yy975; + goto yy958; + yy977: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy975; + goto yy958; + yy978: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0x8F) + goto yy975; + goto yy958; + yy979: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0x9F) + goto yy973; + goto yy958; + yy980: + yyaccept = 0; + marker = ++p; + yych = *p; + yy981: + if (yych <= 0xC1) { + if (yych <= ')') { + if (yych <= ' ') + goto yy951; + if (yych <= '\'') + goto yy980; + if (yych <= '(') + goto yy971; + goto yy951; + } else { + if (yych == '\\') + goto yy982; + if (yych <= 0x7F) + goto yy980; + goto yy951; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy983; + if (yych <= 0xE0) + goto yy984; + if (yych <= 0xEC) + goto yy985; + goto yy989; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy985; + goto yy986; + } else { + if (yych <= 0xF3) + goto yy987; + if (yych <= 0xF4) + goto yy988; + goto yy951; + } + } } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '(') - goto yy1851; - if (yych <= ')') - goto yy1872; - goto yy1861; + yy982: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= 0xDF) { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy980; + if (yych <= '\r') + goto yy951; + goto yy980; } else { + if (yych <= ' ') + goto yy951; + if (yych <= 0x7F) + goto yy980; if (yych <= 0xC1) - goto yy1851; - if (yych >= 0xE0) - goto yy1866; + goto yy951; + goto yy990; } } else { if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy991; if (yych == 0xED) - goto yy1871; - goto yy1867; + goto yy996; + goto yy992; } else { if (yych <= 0xF0) - goto yy1868; + goto yy993; if (yych <= 0xF3) - goto yy1869; + goto yy994; if (yych <= 0xF4) - goto yy1870; - goto yy1851; + goto yy995; + goto yy951; } } - yy1865: + yy983: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy980; + goto yy958; + yy984: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy958; + if (yych <= 0xBF) + goto yy983; + goto yy958; + yy985: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy983; + goto yy958; + yy986: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy958; + if (yych <= 0xBF) + goto yy985; + goto yy958; + yy987: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy985; + goto yy958; + yy988: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0x8F) + goto yy985; + goto yy958; + yy989: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0x9F) + goto yy983; + goto yy958; + yy990: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1863; - goto yy1851; - yy1866: + goto yy980; + goto yy958; + yy991: ++p; yych = *p; if (yych <= 0x9F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1865; - goto yy1851; - yy1867: + goto yy990; + goto yy958; + yy992: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1865; - goto yy1851; - yy1868: + goto yy990; + goto yy958; + yy993: ++p; yych = *p; if (yych <= 0x8F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1867; - goto yy1851; - yy1869: + goto yy992; + goto yy958; + yy994: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1867; - goto yy1851; - yy1870: + goto yy992; + goto yy958; + yy995: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x8F) - goto yy1867; - goto yy1851; - yy1871: + goto yy992; + goto yy958; + yy996: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x9F) - goto yy1865; - goto yy1851; - yy1872: + goto yy990; + goto yy958; + yy997: yyaccept = 0; marker = ++p; yych = *p; - yy1873: + yy998: if (yych <= 0xC1) { if (yych <= ')') { if (yych <= ' ') - goto yy1843; + goto yy951; if (yych <= '\'') - goto yy1872; + goto yy997; if (yych <= '(') - goto yy1863; - goto yy1843; + goto yy971; + goto yy980; } else { if (yych == '\\') - goto yy1874; + goto yy999; if (yych <= 0x7F) - goto yy1872; - goto yy1843; + goto yy997; + goto yy951; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1876; + goto yy1000; if (yych <= 0xE0) - goto yy1877; + goto yy1001; if (yych <= 0xEC) - goto yy1878; - goto yy1882; + goto yy1002; + goto yy1006; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1878; - goto yy1879; + goto yy1002; + goto yy1003; } else { if (yych <= 0xF3) - goto yy1880; + goto yy1004; if (yych <= 0xF4) - goto yy1881; - goto yy1843; + goto yy1005; + goto yy951; } } } - yy1874: + yy999: yyaccept = 0; marker = ++p; yych = *p; - if (yych <= 0xDF) { - if (yych <= '[') { - if (yych <= ' ') - goto yy1843; - if (yych == '(') - goto yy1883; - goto yy1872; + if (yych <= 0xC1) { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy980; + if (yych <= '\r') + goto yy951; + if (yych <= 0x1F) + goto yy980; + goto yy951; } else { - if (yych <= '\\') - goto yy1874; + if (yych == '\\') + goto yy1007; if (yych <= 0x7F) - goto yy1872; - if (yych <= 0xC1) - goto yy1843; + goto yy997; + goto yy951; } } else { - if (yych <= 0xEF) { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy1008; if (yych <= 0xE0) - goto yy1877; - if (yych == 0xED) - goto yy1882; - goto yy1878; + goto yy1009; + if (yych <= 0xEC) + goto yy1010; + goto yy1014; } else { - if (yych <= 0xF0) - goto yy1879; - if (yych <= 0xF3) - goto yy1880; - if (yych <= 0xF4) - goto yy1881; - goto yy1843; + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy1010; + goto yy1011; + } else { + if (yych <= 0xF3) + goto yy1012; + if (yych <= 0xF4) + goto yy1013; + goto yy951; + } } } - yy1876: + yy1000: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1872; - goto yy1851; - yy1877: + goto yy997; + goto yy958; + yy1001: ++p; yych = *p; if (yych <= 0x9F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1876; - goto yy1851; - yy1878: + goto yy1000; + goto yy958; + yy1002: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1876; - goto yy1851; - yy1879: + goto yy1000; + goto yy958; + yy1003: ++p; yych = *p; if (yych <= 0x8F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1878; - goto yy1851; - yy1880: + goto yy1002; + goto yy958; + yy1004: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1878; - goto yy1851; - yy1881: + goto yy1002; + goto yy958; + yy1005: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x8F) - goto yy1878; - goto yy1851; - yy1882: + goto yy1002; + goto yy958; + yy1006: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x9F) - goto yy1876; - goto yy1851; - yy1883: - yyaccept = 0; - marker = ++p; - yych = *p; - yy1884: - if (yych <= 0xC1) { - if (yych <= ')') { - if (yych <= ' ') - goto yy1843; - if (yych <= '\'') - goto yy1883; - if (yych <= '(') - goto yy1863; - goto yy1872; - } else { - if (yych == '\\') - goto yy1885; - if (yych <= 0x7F) - goto yy1883; - goto yy1843; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy1887; - if (yych <= 0xE0) - goto yy1888; - if (yych <= 0xEC) - goto yy1889; - goto yy1893; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy1889; - goto yy1890; - } else { - if (yych <= 0xF3) - goto yy1891; - if (yych <= 0xF4) - goto yy1892; - goto yy1843; - } - } - } - yy1885: + goto yy1000; + goto yy958; + yy1007: yyaccept = 0; marker = ++p; yych = *p; - if (yych <= 0xE0) { - if (yych <= '\\') { + if (yych <= 0xDF) { + if (yych <= '[') { if (yych <= ' ') - goto yy1843; - if (yych <= '[') - goto yy1883; - goto yy1885; + goto yy951; + if (yych == '(') + goto yy971; + goto yy997; } else { + if (yych <= '\\') + goto yy999; if (yych <= 0x7F) - goto yy1883; + goto yy997; if (yych <= 0xC1) - goto yy1843; - if (yych >= 0xE0) - goto yy1888; + goto yy951; + goto yy1000; } } else { if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy1001; if (yych == 0xED) - goto yy1893; - goto yy1889; + goto yy1006; + goto yy1002; } else { if (yych <= 0xF0) - goto yy1890; + goto yy1003; if (yych <= 0xF3) - goto yy1891; + goto yy1004; if (yych <= 0xF4) - goto yy1892; - goto yy1843; + goto yy1005; + goto yy951; } } - yy1887: + yy1008: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1883; - goto yy1851; - yy1888: + goto yy997; + goto yy958; + yy1009: ++p; yych = *p; if (yych <= 0x9F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1887; - goto yy1851; - yy1889: + goto yy1008; + goto yy958; + yy1010: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1887; - goto yy1851; - yy1890: + goto yy1008; + goto yy958; + yy1011: ++p; yych = *p; if (yych <= 0x8F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1889; - goto yy1851; - yy1891: + goto yy1010; + goto yy958; + yy1012: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1889; - goto yy1851; - yy1892: + goto yy1010; + goto yy958; + yy1013: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x8F) - goto yy1889; - goto yy1851; - yy1893: + goto yy1010; + goto yy958; + yy1014: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x9F) - goto yy1887; - goto yy1851; - yy1894: + goto yy1008; + goto yy958; + yy1015: yyaccept = 0; marker = ++p; yych = *p; - if (yych <= '[') { + if (yych <= '\\') { if (yych <= '\r') { - if (yych <= '\t') { + if (yych <= 0x08) { if (yych <= 0x00) - goto yy1843; - goto yy1909; + goto yy980; } else { if (yych <= '\n') - goto yy1843; + goto yy951; if (yych <= '\f') - goto yy1909; - goto yy1843; + goto yy1029; + goto yy951; } } else { - if (yych <= '(') { - if (yych <= ' ') - goto yy1909; - if (yych >= '(') - goto yy1932; + if (yych <= '=') { + if (yych == ' ') + goto yy951; } else { - if (yych == '>') - goto yy1946; + if (yych <= '>') + goto yy1073; + if (yych >= '\\') + goto yy1074; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { - if (yych <= '\\') - goto yy1894; if (yych >= 0x80) - goto yy1843; + goto yy951; } else { if (yych <= 0xDF) - goto yy1900; + goto yy1075; if (yych <= 0xE0) - goto yy1901; - goto yy1902; + goto yy1076; + goto yy1077; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1906; + goto yy1081; if (yych <= 0xEF) - goto yy1902; - goto yy1903; + goto yy1077; + goto yy1078; } else { if (yych <= 0xF3) - goto yy1904; + goto yy1079; if (yych <= 0xF4) - goto yy1905; - goto yy1843; + goto yy1080; + goto yy951; } } } - yy1896: + yy1016: yyaccept = 0; marker = ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1896; + goto yy1016; } if (yych <= '>') { if (yych <= '\r') { - if (yych <= '\t') { + if (yych <= 0x08) { if (yych <= 0x00) - goto yy1843; - goto yy1909; + goto yy951; + goto yy1029; } else { if (yych <= '\n') - goto yy1843; + goto yy951; if (yych <= '\f') - goto yy1909; - goto yy1843; + goto yy1029; + goto yy951; } } else { if (yych <= '(') { + if (yych <= 0x1F) + goto yy1029; if (yych <= ' ') - goto yy1909; - goto yy1907; + goto yy951; + goto yy1027; } else { if (yych <= ')') - goto yy1909; + goto yy1029; if (yych <= '<') - goto yy1872; + goto yy980; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\\') - goto yy1894; - goto yy1843; + goto yy1015; + goto yy951; } else { if (yych <= 0xDF) - goto yy1900; + goto yy1020; if (yych <= 0xE0) - goto yy1901; - goto yy1902; + goto yy1021; + goto yy1022; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1906; + goto yy1026; if (yych <= 0xEF) - goto yy1902; - goto yy1903; + goto yy1022; + goto yy1023; } else { if (yych <= 0xF3) - goto yy1904; + goto yy1024; if (yych <= 0xF4) - goto yy1905; - goto yy1843; + goto yy1025; + goto yy951; } } } - yy1898: + yy1018: yyaccept = 2; yych = *(marker = ++p); if (yych <= ')') { if (yych <= ' ') - goto yy1899; + goto yy1019; if (yych <= '(') - goto yy1873; + goto yy981; } else { if (yych <= 0x7F) - goto yy1873; + goto yy981; if (yych <= 0xC1) - goto yy1899; + goto yy1019; if (yych <= 0xF4) - goto yy1873; + goto yy981; } - yy1899 : { return (bufsize_t)(p - start); } - yy1900: + yy1019 : { return (bufsize_t)(p - start); } + yy1020: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1896; - goto yy1851; - yy1901: + goto yy1016; + goto yy958; + yy1021: ++p; yych = *p; if (yych <= 0x9F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1900; - goto yy1851; - yy1902: + goto yy1020; + goto yy958; + yy1022: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1900; - goto yy1851; - yy1903: + goto yy1020; + goto yy958; + yy1023: ++p; yych = *p; if (yych <= 0x8F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1902; - goto yy1851; - yy1904: + goto yy1022; + goto yy958; + yy1024: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1902; - goto yy1851; - yy1905: + goto yy1022; + goto yy958; + yy1025: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x8F) - goto yy1902; - goto yy1851; - yy1906: + goto yy1022; + goto yy958; + yy1026: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x9F) - goto yy1900; - goto yy1851; - yy1907: + goto yy1020; + goto yy958; + yy1027: ++p; yych = *p; - if (yych <= '>') { - if (yych <= ' ') { + if (yych <= '=') { + if (yych <= 0x1F) { if (yych <= '\n') { if (yych <= 0x00) - goto yy1851; - if (yych >= '\n') - goto yy1851; + goto yy958; + if (yych >= '\t') + goto yy958; } else { if (yych == '\r') - goto yy1851; + goto yy958; } } else { - if (yych <= ')') { + if (yych <= '(') { + if (yych <= ' ') + goto yy958; if (yych <= '\'') - goto yy1907; - if (yych >= ')') - goto yy1896; + goto yy1027; } else { + if (yych <= ')') + goto yy1016; if (yych == '<') - goto yy1863; - if (yych <= '=') - goto yy1907; - goto yy1922; + goto yy971; + goto yy1027; } } } else { if (yych <= 0xE0) { - if (yych <= 0x7F) { - if (yych == '\\') - goto yy1923; - goto yy1907; + if (yych <= '\\') { + if (yych <= '>') + goto yy1042; + if (yych <= '[') + goto yy1027; + goto yy1043; } else { + if (yych <= 0x7F) + goto yy1027; if (yych <= 0xC1) - goto yy1851; + goto yy958; if (yych <= 0xDF) - goto yy1925; - goto yy1926; + goto yy1045; + goto yy1046; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1931; - goto yy1927; + goto yy1051; + goto yy1047; } else { if (yych <= 0xF0) - goto yy1928; + goto yy1048; if (yych <= 0xF3) - goto yy1929; + goto yy1049; if (yych <= 0xF4) - goto yy1930; - goto yy1851; + goto yy1050; + goto yy958; } } } - yy1909: + yy1029: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1909; + goto yy1029; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= '<') - goto yy1851; + goto yy958; if (yych >= '?') - goto yy1912; + goto yy1032; } else { if (yych <= 0xC1) - goto yy1851; + goto yy958; if (yych <= 0xDF) - goto yy1914; - goto yy1915; + goto yy1034; + goto yy1035; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1920; - goto yy1916; + goto yy1040; + goto yy1036; } else { if (yych <= 0xF0) - goto yy1917; + goto yy1037; if (yych <= 0xF3) - goto yy1918; + goto yy1038; if (yych <= 0xF4) - goto yy1919; - goto yy1851; + goto yy1039; + goto yy958; } } - yy1911: + yy1031: yych = *++p; - goto yy1899; - yy1912: + goto yy1019; + yy1032: ++p; yych = *p; - if (yych <= 0x7F) { + if (yych <= '\\') { if (yych <= '\r') { - if (yych <= '\t') { + if (yych <= 0x08) { if (yych <= 0x00) - goto yy1851; - goto yy1909; + goto yy958; + goto yy1029; } else { if (yych <= '\n') - goto yy1851; + goto yy958; if (yych <= '\f') - goto yy1909; - goto yy1851; + goto yy1029; + goto yy958; } } else { - if (yych <= '>') { - if (yych <= '=') - goto yy1909; - goto yy1921; + if (yych <= '=') { + if (yych == ' ') + goto yy958; + goto yy1029; } else { - if (yych == '\\') - goto yy1912; - goto yy1909; + if (yych <= '>') + goto yy1041; + if (yych <= '[') + goto yy1029; + goto yy1032; } } } else { - if (yych <= 0xED) { - if (yych <= 0xDF) { - if (yych <= 0xC1) - goto yy1851; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) + goto yy1029; + goto yy958; } else { + if (yych <= 0xDF) + goto yy1034; if (yych <= 0xE0) - goto yy1915; - if (yych <= 0xEC) - goto yy1916; - goto yy1920; + goto yy1035; + goto yy1036; } } else { if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1040; if (yych <= 0xEF) - goto yy1916; - goto yy1917; + goto yy1036; + goto yy1037; } else { if (yych <= 0xF3) - goto yy1918; + goto yy1038; if (yych <= 0xF4) - goto yy1919; - goto yy1851; + goto yy1039; + goto yy958; } } } - yy1914: + yy1034: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1909; - goto yy1851; - yy1915: + goto yy1029; + goto yy958; + yy1035: ++p; yych = *p; if (yych <= 0x9F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1914; - goto yy1851; - yy1916: + goto yy1034; + goto yy958; + yy1036: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1914; - goto yy1851; - yy1917: + goto yy1034; + goto yy958; + yy1037: ++p; yych = *p; if (yych <= 0x8F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1916; - goto yy1851; - yy1918: + goto yy1036; + goto yy958; + yy1038: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1916; - goto yy1851; - yy1919: + goto yy1036; + goto yy958; + yy1039: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x8F) - goto yy1916; - goto yy1851; - yy1920: + goto yy1036; + goto yy958; + yy1040: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x9F) - goto yy1914; - goto yy1851; - yy1921: + goto yy1034; + goto yy958; + yy1041: yyaccept = 2; marker = ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1909; + goto yy1029; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= '<') - goto yy1899; + goto yy1019; if (yych <= '>') - goto yy1911; - goto yy1912; + goto yy1031; + goto yy1032; } else { if (yych <= 0xC1) - goto yy1899; + goto yy1019; if (yych <= 0xDF) - goto yy1914; - goto yy1915; + goto yy1034; + goto yy1035; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1920; - goto yy1916; + goto yy1040; + goto yy1036; } else { if (yych <= 0xF0) - goto yy1917; + goto yy1037; if (yych <= 0xF3) - goto yy1918; + goto yy1038; if (yych <= 0xF4) - goto yy1919; - goto yy1899; + goto yy1039; + goto yy1019; } } - yy1922: + yy1042: yyaccept = 2; yych = *(marker = ++p); if (yych <= '(') { if (yych <= ' ') - goto yy1899; + goto yy1019; if (yych <= '\'') - goto yy1864; - goto yy1899; + goto yy972; + goto yy1019; } else { if (yych <= 0x7F) - goto yy1864; + goto yy972; if (yych <= 0xC1) - goto yy1899; + goto yy1019; if (yych <= 0xF4) - goto yy1864; - goto yy1899; + goto yy972; + goto yy1019; } - yy1923: + yy1043: ++p; yych = *p; if (yych <= '[') { - if (yych <= '\r') { - if (yych <= '\t') { + if (yych <= 0x1F) { + if (yych <= '\n') { if (yych <= 0x00) - goto yy1851; - goto yy1909; + goto yy958; + if (yych <= 0x08) + goto yy1029; + goto yy958; } else { - if (yych <= '\n') - goto yy1851; - if (yych <= '\f') - goto yy1909; - goto yy1851; + if (yych == '\r') + goto yy958; + goto yy1029; } } else { if (yych <= ')') { if (yych <= ' ') - goto yy1909; + goto yy958; if (yych <= '(') - goto yy1907; - goto yy1932; + goto yy1027; + goto yy1052; } else { if (yych == '>') - goto yy1934; - goto yy1907; + goto yy1054; + goto yy1027; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\\') - goto yy1923; + goto yy1043; if (yych <= 0x7F) - goto yy1907; - goto yy1851; + goto yy1027; + goto yy958; } else { if (yych <= 0xDF) - goto yy1925; + goto yy1045; if (yych <= 0xE0) - goto yy1926; - goto yy1927; + goto yy1046; + goto yy1047; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1931; + goto yy1051; if (yych <= 0xEF) - goto yy1927; - goto yy1928; + goto yy1047; + goto yy1048; } else { if (yych <= 0xF3) - goto yy1929; + goto yy1049; if (yych <= 0xF4) - goto yy1930; - goto yy1851; + goto yy1050; + goto yy958; } } } - yy1925: + yy1045: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1907; - goto yy1851; - yy1926: + goto yy1027; + goto yy958; + yy1046: ++p; yych = *p; if (yych <= 0x9F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1925; - goto yy1851; - yy1927: + goto yy1045; + goto yy958; + yy1047: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1925; - goto yy1851; - yy1928: + goto yy1045; + goto yy958; + yy1048: ++p; yych = *p; if (yych <= 0x8F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1927; - goto yy1851; - yy1929: + goto yy1047; + goto yy958; + yy1049: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1927; - goto yy1851; - yy1930: + goto yy1047; + goto yy958; + yy1050: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x8F) - goto yy1927; - goto yy1851; - yy1931: + goto yy1047; + goto yy958; + yy1051: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x9F) - goto yy1925; - goto yy1851; - yy1932: + goto yy1045; + goto yy958; + yy1052: yyaccept = 0; marker = ++p; yych = *p; - if (yych <= '>') { - if (yych <= ' ') { + if (yych <= '=') { + if (yych <= 0x1F) { if (yych <= '\n') { if (yych <= 0x00) - goto yy1843; - if (yych <= '\t') - goto yy1909; - goto yy1843; + goto yy951; + if (yych <= 0x08) + goto yy1029; + goto yy951; } else { if (yych == '\r') - goto yy1843; - goto yy1909; + goto yy951; + goto yy1029; } } else { - if (yych <= ')') { + if (yych <= '(') { + if (yych <= ' ') + goto yy951; if (yych <= '\'') - goto yy1932; - if (yych <= '(') - goto yy1907; - goto yy1896; + goto yy1052; + goto yy1027; } else { + if (yych <= ')') + goto yy1016; if (yych == '<') - goto yy1883; - if (yych <= '=') - goto yy1932; - goto yy1935; + goto yy997; + goto yy1052; } } } else { if (yych <= 0xE0) { - if (yych <= 0x7F) { - if (yych == '\\') - goto yy1936; - goto yy1932; + if (yych <= '\\') { + if (yych <= '>') + goto yy1055; + if (yych <= '[') + goto yy1052; + goto yy1056; } else { + if (yych <= 0x7F) + goto yy1052; if (yych <= 0xC1) - goto yy1843; + goto yy951; if (yych <= 0xDF) - goto yy1938; - goto yy1939; + goto yy1057; + goto yy1058; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1944; - goto yy1940; + goto yy1063; + goto yy1059; } else { if (yych <= 0xF0) - goto yy1941; + goto yy1060; if (yych <= 0xF3) - goto yy1942; + goto yy1061; if (yych <= 0xF4) - goto yy1943; - goto yy1843; + goto yy1062; + goto yy951; } } } - yy1934: + yy1054: yyaccept = 2; marker = ++p; yych = *p; - if (yych <= '>') { - if (yych <= ' ') { + if (yych <= '=') { + if (yych <= 0x1F) { if (yych <= '\n') { if (yych <= 0x00) - goto yy1899; - if (yych <= '\t') - goto yy1909; - goto yy1899; + goto yy1019; + if (yych <= 0x08) + goto yy1029; + goto yy1019; } else { if (yych == '\r') - goto yy1899; - goto yy1909; + goto yy1019; + goto yy1029; } } else { - if (yych <= ')') { + if (yych <= '(') { + if (yych <= ' ') + goto yy1019; if (yych <= '\'') - goto yy1907; - if (yych <= '(') - goto yy1909; - goto yy1896; + goto yy1027; + goto yy1029; } else { + if (yych <= ')') + goto yy1016; if (yych == '<') - goto yy1863; - if (yych <= '=') - goto yy1907; - goto yy1922; + goto yy971; + goto yy1027; } } } else { if (yych <= 0xE0) { - if (yych <= 0x7F) { - if (yych == '\\') - goto yy1923; - goto yy1907; + if (yych <= '\\') { + if (yych <= '>') + goto yy1042; + if (yych <= '[') + goto yy1027; + goto yy1043; } else { + if (yych <= 0x7F) + goto yy1027; if (yych <= 0xC1) - goto yy1899; + goto yy1019; if (yych <= 0xDF) - goto yy1925; - goto yy1926; + goto yy1045; + goto yy1046; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1931; - goto yy1927; + goto yy1051; + goto yy1047; } else { if (yych <= 0xF0) - goto yy1928; + goto yy1048; if (yych <= 0xF3) - goto yy1929; + goto yy1049; if (yych <= 0xF4) - goto yy1930; - goto yy1899; + goto yy1050; + goto yy1019; } } } - yy1935: + yy1055: yyaccept = 2; yych = *(marker = ++p); if (yych <= ' ') - goto yy1899; + goto yy1019; if (yych <= 0x7F) - goto yy1884; + goto yy998; if (yych <= 0xC1) - goto yy1899; + goto yy1019; if (yych <= 0xF4) - goto yy1884; - goto yy1899; - yy1936: + goto yy998; + goto yy1019; + yy1056: yyaccept = 0; marker = ++p; yych = *p; if (yych <= '\\') { if (yych <= '\r') { - if (yych <= '\t') { + if (yych <= 0x08) { if (yych <= 0x00) - goto yy1843; - goto yy1909; + goto yy980; + goto yy1016; } else { if (yych <= '\n') - goto yy1843; + goto yy951; if (yych <= '\f') - goto yy1909; - goto yy1843; + goto yy1029; + goto yy951; } } else { if (yych <= '=') { + if (yych <= 0x1F) + goto yy1016; if (yych <= ' ') - goto yy1909; - goto yy1932; + goto yy951; + goto yy1052; } else { if (yych <= '>') - goto yy1945; + goto yy1064; if (yych <= '[') - goto yy1932; - goto yy1936; + goto yy1052; + goto yy1065; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x7F) - goto yy1932; - goto yy1843; + goto yy1052; + goto yy951; } else { if (yych <= 0xDF) - goto yy1938; + goto yy1066; if (yych <= 0xE0) - goto yy1939; - goto yy1940; + goto yy1067; + goto yy1068; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1944; + goto yy1072; if (yych <= 0xEF) - goto yy1940; - goto yy1941; + goto yy1068; + goto yy1069; } else { if (yych <= 0xF3) - goto yy1942; + goto yy1070; if (yych <= 0xF4) - goto yy1943; - goto yy1843; + goto yy1071; + goto yy951; } } } - yy1938: + yy1057: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1932; - goto yy1851; - yy1939: + goto yy1052; + goto yy958; + yy1058: ++p; yych = *p; if (yych <= 0x9F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1938; - goto yy1851; - yy1940: + goto yy1057; + goto yy958; + yy1059: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1938; - goto yy1851; - yy1941: + goto yy1057; + goto yy958; + yy1060: ++p; yych = *p; if (yych <= 0x8F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1940; - goto yy1851; - yy1942: + goto yy1059; + goto yy958; + yy1061: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0xBF) - goto yy1940; - goto yy1851; - yy1943: + goto yy1059; + goto yy958; + yy1062: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x8F) - goto yy1940; - goto yy1851; - yy1944: + goto yy1059; + goto yy958; + yy1063: ++p; yych = *p; if (yych <= 0x7F) - goto yy1851; + goto yy958; if (yych <= 0x9F) - goto yy1938; - goto yy1851; - yy1945: + goto yy1057; + goto yy958; + yy1064: yyaccept = 2; marker = ++p; yych = *p; - if (yych <= '>') { - if (yych <= ' ') { + if (yych <= '=') { + if (yych <= 0x1F) { if (yych <= '\n') { if (yych <= 0x00) - goto yy1899; - if (yych <= '\t') - goto yy1909; - goto yy1899; + goto yy1019; + if (yych <= 0x08) + goto yy1029; + goto yy1019; } else { if (yych == '\r') - goto yy1899; - goto yy1909; + goto yy1019; + goto yy1029; } } else { - if (yych <= ')') { + if (yych <= '(') { + if (yych <= ' ') + goto yy1019; if (yych <= '\'') - goto yy1932; - if (yych <= '(') - goto yy1907; - goto yy1896; + goto yy1052; + goto yy1027; } else { + if (yych <= ')') + goto yy1016; if (yych == '<') - goto yy1883; - if (yych <= '=') - goto yy1932; - goto yy1935; + goto yy997; + goto yy1052; } } } else { if (yych <= 0xE0) { - if (yych <= 0x7F) { - if (yych == '\\') - goto yy1936; - goto yy1932; + if (yych <= '\\') { + if (yych <= '>') + goto yy1055; + if (yych <= '[') + goto yy1052; + goto yy1056; } else { + if (yych <= 0x7F) + goto yy1052; if (yych <= 0xC1) - goto yy1899; + goto yy1019; if (yych <= 0xDF) - goto yy1938; - goto yy1939; + goto yy1057; + goto yy1058; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1944; - goto yy1940; + goto yy1063; + goto yy1059; } else { if (yych <= 0xF0) - goto yy1941; + goto yy1060; + if (yych <= 0xF3) + goto yy1061; + if (yych <= 0xF4) + goto yy1062; + goto yy1019; + } + } + } + yy1065: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= '[') { + if (yych <= 0x1F) { + if (yych <= '\n') { + if (yych <= 0x00) + goto yy951; + if (yych <= 0x08) + goto yy1029; + goto yy951; + } else { + if (yych == '\r') + goto yy951; + goto yy1029; + } + } else { + if (yych <= '(') { + if (yych <= ' ') + goto yy951; + if (yych <= '\'') + goto yy1052; + goto yy1027; + } else { + if (yych == '>') + goto yy1064; + goto yy1052; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\\') + goto yy1056; + if (yych <= 0x7F) + goto yy1052; + goto yy951; + } else { + if (yych <= 0xDF) + goto yy1057; + if (yych <= 0xE0) + goto yy1058; + goto yy1059; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy1063; + if (yych <= 0xEF) + goto yy1059; + goto yy1060; + } else { if (yych <= 0xF3) - goto yy1942; + goto yy1061; if (yych <= 0xF4) - goto yy1943; - goto yy1899; + goto yy1062; + goto yy951; } } } - yy1946: + yy1066: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy1052; + goto yy958; + yy1067: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy958; + if (yych <= 0xBF) + goto yy1066; + goto yy958; + yy1068: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy1066; + goto yy958; + yy1069: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy958; + if (yych <= 0xBF) + goto yy1068; + goto yy958; + yy1070: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy1068; + goto yy958; + yy1071: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0x8F) + goto yy1068; + goto yy958; + yy1072: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0x9F) + goto yy1066; + goto yy958; + yy1073: yyaccept = 2; marker = ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1896; + goto yy1016; } if (yych <= '>') { if (yych <= '\r') { - if (yych <= '\t') { + if (yych <= 0x08) { if (yych <= 0x00) - goto yy1899; - goto yy1909; + goto yy1019; + goto yy1029; } else { if (yych <= '\n') - goto yy1899; + goto yy1019; if (yych <= '\f') - goto yy1909; - goto yy1899; + goto yy1029; + goto yy1019; } } else { if (yych <= '(') { + if (yych <= 0x1F) + goto yy1029; if (yych <= ' ') - goto yy1909; - goto yy1907; + goto yy1019; + goto yy1027; } else { if (yych <= ')') - goto yy1909; + goto yy1029; if (yych <= '<') - goto yy1872; - goto yy1898; + goto yy980; + goto yy1018; } } } else { if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\\') - goto yy1894; - goto yy1899; + goto yy1015; + goto yy1019; } else { if (yych <= 0xDF) - goto yy1900; + goto yy1020; if (yych <= 0xE0) - goto yy1901; - goto yy1902; + goto yy1021; + goto yy1022; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1906; + goto yy1026; if (yych <= 0xEF) - goto yy1902; - goto yy1903; + goto yy1022; + goto yy1023; + } else { + if (yych <= 0xF3) + goto yy1024; + if (yych <= 0xF4) + goto yy1025; + goto yy1019; + } + } + } + yy1074: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= '>') { + if (yych <= 0x1F) { + if (yych <= '\n') { + if (yych <= 0x00) + goto yy951; + if (yych <= 0x08) + goto yy1029; + goto yy951; + } else { + if (yych == '\r') + goto yy951; + goto yy1029; + } + } else { + if (yych <= '(') { + if (yych <= ' ') + goto yy951; + if (yych <= '\'') + goto yy1016; + goto yy1027; + } else { + if (yych <= ')') + goto yy1029; + if (yych <= '=') + goto yy1016; + goto yy1073; + } + } + } else { + if (yych <= 0xE0) { + if (yych <= 0x7F) { + if (yych == '\\') + goto yy1015; + goto yy1016; + } else { + if (yych <= 0xC1) + goto yy951; + if (yych <= 0xDF) + goto yy1020; + goto yy1021; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy1026; + goto yy1022; } else { + if (yych <= 0xF0) + goto yy1023; if (yych <= 0xF3) - goto yy1904; + goto yy1024; if (yych <= 0xF4) - goto yy1905; - goto yy1899; + goto yy1025; + goto yy951; } } } + yy1075: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy1016; + goto yy958; + yy1076: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy958; + if (yych <= 0xBF) + goto yy1075; + goto yy958; + yy1077: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy1075; + goto yy958; + yy1078: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy958; + if (yych <= 0xBF) + goto yy1077; + goto yy958; + yy1079: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0xBF) + goto yy1077; + goto yy958; + yy1080: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0x8F) + goto yy1077; + goto yy958; + yy1081: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy958; + if (yych <= 0x9F) + goto yy1075; + goto yy958; } } @@ -23609,640 +17737,640 @@ bufsize_t _scan_link_title(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '"') { if (yych == '\n') - goto yy1949; + goto yy1084; if (yych <= '!') - goto yy1953; - goto yy1950; + goto yy1088; + goto yy1085; } else { if (yych <= '\'') { if (yych <= '&') - goto yy1953; - goto yy1951; + goto yy1088; + goto yy1086; } else { if (yych <= '(') - goto yy1952; + goto yy1087; if (yych <= 0x7F) - goto yy1953; + goto yy1088; } } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1954; + goto yy1089; if (yych <= 0xE0) - goto yy1956; + goto yy1091; if (yych <= 0xEC) - goto yy1957; - goto yy1961; + goto yy1092; + goto yy1096; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1957; - goto yy1958; + goto yy1092; + goto yy1093; } else { if (yych <= 0xF3) - goto yy1959; + goto yy1094; if (yych <= 0xF4) - goto yy1960; + goto yy1095; } } } - yy1949 : { return 0; } - yy1950: + yy1084 : { return 0; } + yy1085: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x00) - goto yy1949; + goto yy1084; if (yych <= 0x7F) - goto yy1993; + goto yy1128; if (yych <= 0xC1) - goto yy1949; + goto yy1084; if (yych <= 0xF4) - goto yy1993; - goto yy1949; - yy1951: + goto yy1128; + goto yy1084; + yy1086: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x00) - goto yy1949; + goto yy1084; if (yych <= 0x7F) - goto yy1979; + goto yy1114; if (yych <= 0xC1) - goto yy1949; + goto yy1084; if (yych <= 0xF4) - goto yy1979; - goto yy1949; - yy1952: + goto yy1114; + goto yy1084; + yy1087: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x00) - goto yy1949; + goto yy1084; if (yych <= 0x7F) - goto yy1965; + goto yy1100; if (yych <= 0xC1) - goto yy1949; + goto yy1084; if (yych <= 0xF4) - goto yy1965; - goto yy1949; - yy1953: + goto yy1100; + goto yy1084; + yy1088: yych = *++p; - goto yy1949; - yy1954: + goto yy1084; + yy1089: yych = *++p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1953; - yy1955: + goto yy1088; + yy1090: p = marker; if (yyaccept <= 1) { if (yyaccept == 0) { - goto yy1949; + goto yy1084; } else { - goto yy1974; + goto yy1109; } } else { if (yyaccept == 2) { - goto yy1988; + goto yy1123; } else { - goto yy2002; + goto yy1137; } } - yy1956: + yy1091: yych = *++p; if (yych <= 0x9F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1954; - goto yy1955; - yy1957: + goto yy1089; + goto yy1090; + yy1092: yych = *++p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1954; - goto yy1955; - yy1958: + goto yy1089; + goto yy1090; + yy1093: yych = *++p; if (yych <= 0x8F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1957; - goto yy1955; - yy1959: + goto yy1092; + goto yy1090; + yy1094: yych = *++p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1957; - goto yy1955; - yy1960: + goto yy1092; + goto yy1090; + yy1095: yych = *++p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0x8F) - goto yy1957; - goto yy1955; - yy1961: + goto yy1092; + goto yy1090; + yy1096: yych = *++p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0x9F) - goto yy1954; - goto yy1955; - yy1962: + goto yy1089; + goto yy1090; + yy1097: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1964; + goto yy1099; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1955; + goto yy1090; if (yych <= ')') - goto yy1975; - goto yy1962; + goto yy1110; + goto yy1097; } else { if (yych <= 0xC1) - goto yy1955; + goto yy1090; if (yych <= 0xDF) - goto yy1966; - goto yy1967; + goto yy1101; + goto yy1102; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1972; - goto yy1968; + goto yy1107; + goto yy1103; } else { if (yych <= 0xF0) - goto yy1969; + goto yy1104; if (yych <= 0xF3) - goto yy1970; + goto yy1105; if (yych <= 0xF4) - goto yy1971; - goto yy1955; + goto yy1106; + goto yy1090; } } - yy1964: + yy1099: ++p; yych = *p; - yy1965: + yy1100: if (yybm[0 + yych] & 32) { - goto yy1964; + goto yy1099; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1955; + goto yy1090; if (yych <= ')') - goto yy1973; - goto yy1962; + goto yy1108; + goto yy1097; } else { if (yych <= 0xC1) - goto yy1955; + goto yy1090; if (yych >= 0xE0) - goto yy1967; + goto yy1102; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1972; - goto yy1968; + goto yy1107; + goto yy1103; } else { if (yych <= 0xF0) - goto yy1969; + goto yy1104; if (yych <= 0xF3) - goto yy1970; + goto yy1105; if (yych <= 0xF4) - goto yy1971; - goto yy1955; + goto yy1106; + goto yy1090; } } - yy1966: + yy1101: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1964; - goto yy1955; - yy1967: + goto yy1099; + goto yy1090; + yy1102: ++p; yych = *p; if (yych <= 0x9F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1966; - goto yy1955; - yy1968: + goto yy1101; + goto yy1090; + yy1103: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1966; - goto yy1955; - yy1969: + goto yy1101; + goto yy1090; + yy1104: ++p; yych = *p; if (yych <= 0x8F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1968; - goto yy1955; - yy1970: + goto yy1103; + goto yy1090; + yy1105: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1968; - goto yy1955; - yy1971: + goto yy1103; + goto yy1090; + yy1106: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0x8F) - goto yy1968; - goto yy1955; - yy1972: + goto yy1103; + goto yy1090; + yy1107: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0x9F) - goto yy1966; - goto yy1955; - yy1973: + goto yy1101; + goto yy1090; + yy1108: ++p; - yy1974 : { return (bufsize_t)(p - start); } - yy1975: + yy1109 : { return (bufsize_t)(p - start); } + yy1110: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1964; + goto yy1099; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1974; + goto yy1109; if (yych <= ')') - goto yy1973; - goto yy1962; + goto yy1108; + goto yy1097; } else { if (yych <= 0xC1) - goto yy1974; + goto yy1109; if (yych <= 0xDF) - goto yy1966; - goto yy1967; + goto yy1101; + goto yy1102; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1972; - goto yy1968; + goto yy1107; + goto yy1103; } else { if (yych <= 0xF0) - goto yy1969; + goto yy1104; if (yych <= 0xF3) - goto yy1970; + goto yy1105; if (yych <= 0xF4) - goto yy1971; - goto yy1974; + goto yy1106; + goto yy1109; } } - yy1976: + yy1111: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1978; + goto yy1113; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1955; + goto yy1090; if (yych <= '\'') - goto yy1989; - goto yy1976; + goto yy1124; + goto yy1111; } else { if (yych <= 0xC1) - goto yy1955; + goto yy1090; if (yych <= 0xDF) - goto yy1980; - goto yy1981; + goto yy1115; + goto yy1116; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1986; - goto yy1982; + goto yy1121; + goto yy1117; } else { if (yych <= 0xF0) - goto yy1983; + goto yy1118; if (yych <= 0xF3) - goto yy1984; + goto yy1119; if (yych <= 0xF4) - goto yy1985; - goto yy1955; + goto yy1120; + goto yy1090; } } - yy1978: + yy1113: ++p; yych = *p; - yy1979: + yy1114: if (yybm[0 + yych] & 64) { - goto yy1978; + goto yy1113; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1955; + goto yy1090; if (yych <= '\'') - goto yy1987; - goto yy1976; + goto yy1122; + goto yy1111; } else { if (yych <= 0xC1) - goto yy1955; + goto yy1090; if (yych >= 0xE0) - goto yy1981; + goto yy1116; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1986; - goto yy1982; + goto yy1121; + goto yy1117; } else { if (yych <= 0xF0) - goto yy1983; + goto yy1118; if (yych <= 0xF3) - goto yy1984; + goto yy1119; if (yych <= 0xF4) - goto yy1985; - goto yy1955; + goto yy1120; + goto yy1090; } } - yy1980: + yy1115: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1978; - goto yy1955; - yy1981: + goto yy1113; + goto yy1090; + yy1116: ++p; yych = *p; if (yych <= 0x9F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1980; - goto yy1955; - yy1982: + goto yy1115; + goto yy1090; + yy1117: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1980; - goto yy1955; - yy1983: + goto yy1115; + goto yy1090; + yy1118: ++p; yych = *p; if (yych <= 0x8F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1982; - goto yy1955; - yy1984: + goto yy1117; + goto yy1090; + yy1119: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1982; - goto yy1955; - yy1985: + goto yy1117; + goto yy1090; + yy1120: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0x8F) - goto yy1982; - goto yy1955; - yy1986: + goto yy1117; + goto yy1090; + yy1121: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0x9F) - goto yy1980; - goto yy1955; - yy1987: + goto yy1115; + goto yy1090; + yy1122: ++p; - yy1988 : { return (bufsize_t)(p - start); } - yy1989: + yy1123 : { return (bufsize_t)(p - start); } + yy1124: yyaccept = 2; marker = ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1978; + goto yy1113; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1988; + goto yy1123; if (yych <= '\'') - goto yy1987; - goto yy1976; + goto yy1122; + goto yy1111; } else { if (yych <= 0xC1) - goto yy1988; + goto yy1123; if (yych <= 0xDF) - goto yy1980; - goto yy1981; + goto yy1115; + goto yy1116; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1986; - goto yy1982; + goto yy1121; + goto yy1117; } else { if (yych <= 0xF0) - goto yy1983; + goto yy1118; if (yych <= 0xF3) - goto yy1984; + goto yy1119; if (yych <= 0xF4) - goto yy1985; - goto yy1988; + goto yy1120; + goto yy1123; } } - yy1990: + yy1125: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1992; + goto yy1127; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1955; + goto yy1090; if (yych <= '"') - goto yy2003; - goto yy1990; + goto yy1138; + goto yy1125; } else { if (yych <= 0xC1) - goto yy1955; + goto yy1090; if (yych <= 0xDF) - goto yy1994; - goto yy1995; + goto yy1129; + goto yy1130; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2000; - goto yy1996; + goto yy1135; + goto yy1131; } else { if (yych <= 0xF0) - goto yy1997; + goto yy1132; if (yych <= 0xF3) - goto yy1998; + goto yy1133; if (yych <= 0xF4) - goto yy1999; - goto yy1955; + goto yy1134; + goto yy1090; } } - yy1992: + yy1127: ++p; yych = *p; - yy1993: + yy1128: if (yybm[0 + yych] & 128) { - goto yy1992; + goto yy1127; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1955; + goto yy1090; if (yych <= '"') - goto yy2001; - goto yy1990; + goto yy1136; + goto yy1125; } else { if (yych <= 0xC1) - goto yy1955; + goto yy1090; if (yych >= 0xE0) - goto yy1995; + goto yy1130; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2000; - goto yy1996; + goto yy1135; + goto yy1131; } else { if (yych <= 0xF0) - goto yy1997; + goto yy1132; if (yych <= 0xF3) - goto yy1998; + goto yy1133; if (yych <= 0xF4) - goto yy1999; - goto yy1955; + goto yy1134; + goto yy1090; } } - yy1994: + yy1129: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1992; - goto yy1955; - yy1995: + goto yy1127; + goto yy1090; + yy1130: ++p; yych = *p; if (yych <= 0x9F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1994; - goto yy1955; - yy1996: + goto yy1129; + goto yy1090; + yy1131: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1994; - goto yy1955; - yy1997: + goto yy1129; + goto yy1090; + yy1132: ++p; yych = *p; if (yych <= 0x8F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1996; - goto yy1955; - yy1998: + goto yy1131; + goto yy1090; + yy1133: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0xBF) - goto yy1996; - goto yy1955; - yy1999: + goto yy1131; + goto yy1090; + yy1134: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0x8F) - goto yy1996; - goto yy1955; - yy2000: + goto yy1131; + goto yy1090; + yy1135: ++p; yych = *p; if (yych <= 0x7F) - goto yy1955; + goto yy1090; if (yych <= 0x9F) - goto yy1994; - goto yy1955; - yy2001: + goto yy1129; + goto yy1090; + yy1136: ++p; - yy2002 : { return (bufsize_t)(p - start); } - yy2003: + yy1137 : { return (bufsize_t)(p - start); } + yy1138: yyaccept = 3; marker = ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1992; + goto yy1127; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy2002; + goto yy1137; if (yych <= '"') - goto yy2001; - goto yy1990; + goto yy1136; + goto yy1125; } else { if (yych <= 0xC1) - goto yy2002; + goto yy1137; if (yych <= 0xDF) - goto yy1994; - goto yy1995; + goto yy1129; + goto yy1130; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2000; - goto yy1996; + goto yy1135; + goto yy1131; } else { if (yych <= 0xF0) - goto yy1997; + goto yy1132; if (yych <= 0xF3) - goto yy1998; + goto yy1133; if (yych <= 0xF4) - goto yy1999; - goto yy2002; + goto yy1134; + goto yy1137; } } } @@ -24274,104 +18402,104 @@ bufsize_t _scan_spacechars(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '\r') { if (yych <= 0x08) - goto yy2010; + goto yy1145; if (yych == '\n') - goto yy2008; - goto yy2007; + goto yy1143; + goto yy1142; } else { if (yych == ' ') - goto yy2007; + goto yy1142; if (yych <= 0x7F) - goto yy2010; + goto yy1145; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy2012; + goto yy1147; if (yych <= 0xE0) - goto yy2014; + goto yy1149; if (yych <= 0xEC) - goto yy2015; - goto yy2019; + goto yy1150; + goto yy1154; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy2015; - goto yy2016; + goto yy1150; + goto yy1151; } else { if (yych <= 0xF3) - goto yy2017; + goto yy1152; if (yych <= 0xF4) - goto yy2018; + goto yy1153; } } } - yy2006 : { return (bufsize_t)(p - start); } - yy2007: + yy1141 : { return (bufsize_t)(p - start); } + yy1142: yych = *++p; - goto yy2009; - yy2008: + goto yy1144; + yy1143: ++p; yych = *p; - yy2009: + yy1144: if (yybm[0 + yych] & 128) { - goto yy2008; + goto yy1143; } - goto yy2006; - yy2010: + goto yy1141; + yy1145: ++p; { return 0; } - yy2012: + yy1147: yych = *++p; if (yych <= 0x7F) - goto yy2013; + goto yy1148; if (yych <= 0xBF) - goto yy2010; - yy2013: + goto yy1145; + yy1148: p = marker; - goto yy2006; - yy2014: + goto yy1141; + yy1149: yych = *++p; if (yych <= 0x9F) - goto yy2013; + goto yy1148; if (yych <= 0xBF) - goto yy2012; - goto yy2013; - yy2015: + goto yy1147; + goto yy1148; + yy1150: yych = *++p; if (yych <= 0x7F) - goto yy2013; + goto yy1148; if (yych <= 0xBF) - goto yy2012; - goto yy2013; - yy2016: + goto yy1147; + goto yy1148; + yy1151: yych = *++p; if (yych <= 0x8F) - goto yy2013; + goto yy1148; if (yych <= 0xBF) - goto yy2015; - goto yy2013; - yy2017: + goto yy1150; + goto yy1148; + yy1152: yych = *++p; if (yych <= 0x7F) - goto yy2013; + goto yy1148; if (yych <= 0xBF) - goto yy2015; - goto yy2013; - yy2018: + goto yy1150; + goto yy1148; + yy1153: yych = *++p; if (yych <= 0x7F) - goto yy2013; + goto yy1148; if (yych <= 0x8F) - goto yy2015; - goto yy2013; - yy2019: + goto yy1150; + goto yy1148; + yy1154: ++p; if ((yych = *p) <= 0x7F) - goto yy2013; + goto yy1148; if (yych <= 0x9F) - goto yy2012; - goto yy2013; + goto yy1147; + goto yy1148; } } @@ -24400,178 +18528,178 @@ bufsize_t _scan_atx_heading_start(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= '"') { if (yych != '\n') - goto yy2024; + goto yy1159; } else { if (yych <= '#') - goto yy2023; + goto yy1158; if (yych <= 0x7F) - goto yy2024; + goto yy1159; if (yych >= 0xC2) - goto yy2025; + goto yy1160; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy2027; + goto yy1162; if (yych == 0xED) - goto yy2032; - goto yy2028; + goto yy1167; + goto yy1163; } else { if (yych <= 0xF0) - goto yy2029; + goto yy1164; if (yych <= 0xF3) - goto yy2030; + goto yy1165; if (yych <= 0xF4) - goto yy2031; + goto yy1166; } } - yy2022 : { return 0; } - yy2023: + yy1157 : { return 0; } + yy1158: yych = *(marker = ++p); if (yybm[0 + yych] & 128) { - goto yy2035; + goto yy1170; } if (yych <= '\f') { if (yych == '\n') - goto yy2033; - goto yy2022; + goto yy1168; + goto yy1157; } else { if (yych <= '\r') - goto yy2033; + goto yy1168; if (yych == '#') - goto yy2037; - goto yy2022; + goto yy1172; + goto yy1157; } - yy2024: + yy1159: yych = *++p; - goto yy2022; - yy2025: + goto yy1157; + yy1160: yych = *++p; if (yych <= 0x7F) - goto yy2026; + goto yy1161; if (yych <= 0xBF) - goto yy2024; - yy2026: + goto yy1159; + yy1161: p = marker; - goto yy2022; - yy2027: + goto yy1157; + yy1162: yych = *++p; if (yych <= 0x9F) - goto yy2026; + goto yy1161; if (yych <= 0xBF) - goto yy2025; - goto yy2026; - yy2028: + goto yy1160; + goto yy1161; + yy1163: yych = *++p; if (yych <= 0x7F) - goto yy2026; + goto yy1161; if (yych <= 0xBF) - goto yy2025; - goto yy2026; - yy2029: + goto yy1160; + goto yy1161; + yy1164: yych = *++p; if (yych <= 0x8F) - goto yy2026; + goto yy1161; if (yych <= 0xBF) - goto yy2028; - goto yy2026; - yy2030: + goto yy1163; + goto yy1161; + yy1165: yych = *++p; if (yych <= 0x7F) - goto yy2026; + goto yy1161; if (yych <= 0xBF) - goto yy2028; - goto yy2026; - yy2031: + goto yy1163; + goto yy1161; + yy1166: yych = *++p; if (yych <= 0x7F) - goto yy2026; + goto yy1161; if (yych <= 0x8F) - goto yy2028; - goto yy2026; - yy2032: + goto yy1163; + goto yy1161; + yy1167: yych = *++p; if (yych <= 0x7F) - goto yy2026; + goto yy1161; if (yych <= 0x9F) - goto yy2025; - goto yy2026; - yy2033: + goto yy1160; + goto yy1161; + yy1168: ++p; - yy2034 : { return (bufsize_t)(p - start); } - yy2035: + yy1169 : { return (bufsize_t)(p - start); } + yy1170: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy2035; + goto yy1170; } - goto yy2034; - yy2037: + goto yy1169; + yy1172: yych = *++p; if (yybm[0 + yych] & 128) { - goto yy2035; + goto yy1170; } if (yych <= '\f') { if (yych == '\n') - goto yy2033; - goto yy2026; + goto yy1168; + goto yy1161; } else { if (yych <= '\r') - goto yy2033; + goto yy1168; if (yych != '#') - goto yy2026; + goto yy1161; } yych = *++p; if (yybm[0 + yych] & 128) { - goto yy2035; + goto yy1170; } if (yych <= '\f') { if (yych == '\n') - goto yy2033; - goto yy2026; + goto yy1168; + goto yy1161; } else { if (yych <= '\r') - goto yy2033; + goto yy1168; if (yych != '#') - goto yy2026; + goto yy1161; } yych = *++p; if (yybm[0 + yych] & 128) { - goto yy2035; + goto yy1170; } if (yych <= '\f') { if (yych == '\n') - goto yy2033; - goto yy2026; + goto yy1168; + goto yy1161; } else { if (yych <= '\r') - goto yy2033; + goto yy1168; if (yych != '#') - goto yy2026; + goto yy1161; } yych = *++p; if (yybm[0 + yych] & 128) { - goto yy2035; + goto yy1170; } if (yych <= '\f') { if (yych == '\n') - goto yy2033; - goto yy2026; + goto yy1168; + goto yy1161; } else { if (yych <= '\r') - goto yy2033; + goto yy1168; if (yych != '#') - goto yy2026; + goto yy1161; } ++p; if (yybm[0 + (yych = *p)] & 128) { - goto yy2035; + goto yy1170; } if (yych == '\n') - goto yy2033; + goto yy1168; if (yych == '\r') - goto yy2033; - goto yy2026; + goto yy1168; + goto yy1161; } } @@ -24600,187 +18728,187 @@ bufsize_t _scan_setext_heading_line(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '-') { if (yych == '\n') - goto yy2044; + goto yy1179; if (yych <= ',') - goto yy2047; - goto yy2046; + goto yy1182; + goto yy1181; } else { if (yych == '=') - goto yy2045; + goto yy1180; if (yych <= 0x7F) - goto yy2047; + goto yy1182; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy2048; + goto yy1183; if (yych <= 0xE0) - goto yy2050; + goto yy1185; if (yych <= 0xEC) - goto yy2051; - goto yy2055; + goto yy1186; + goto yy1190; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy2051; - goto yy2052; + goto yy1186; + goto yy1187; } else { if (yych <= 0xF3) - goto yy2053; + goto yy1188; if (yych <= 0xF4) - goto yy2054; + goto yy1189; } } } - yy2044 : { return 0; } - yy2045: + yy1179 : { return 0; } + yy1180: yych = *(marker = ++p); if (yybm[0 + yych] & 128) { - goto yy2066; + goto yy1201; } if (yych <= '\f') { if (yych == '\n') - goto yy2064; - goto yy2044; + goto yy1199; + goto yy1179; } else { if (yych <= '\r') - goto yy2064; + goto yy1199; if (yych == ' ') - goto yy2062; - goto yy2044; + goto yy1197; + goto yy1179; } - yy2046: + yy1181: yych = *(marker = ++p); if (yybm[0 + yych] & 32) { - goto yy2056; + goto yy1191; } if (yych <= '\f') { if (yych == '\n') - goto yy2058; - goto yy2044; + goto yy1193; + goto yy1179; } else { if (yych <= '\r') - goto yy2058; + goto yy1193; if (yych == '-') - goto yy2060; - goto yy2044; + goto yy1195; + goto yy1179; } - yy2047: + yy1182: yych = *++p; - goto yy2044; - yy2048: + goto yy1179; + yy1183: yych = *++p; if (yych <= 0x7F) - goto yy2049; + goto yy1184; if (yych <= 0xBF) - goto yy2047; - yy2049: + goto yy1182; + yy1184: p = marker; - goto yy2044; - yy2050: + goto yy1179; + yy1185: yych = *++p; if (yych <= 0x9F) - goto yy2049; + goto yy1184; if (yych <= 0xBF) - goto yy2048; - goto yy2049; - yy2051: + goto yy1183; + goto yy1184; + yy1186: yych = *++p; if (yych <= 0x7F) - goto yy2049; + goto yy1184; if (yych <= 0xBF) - goto yy2048; - goto yy2049; - yy2052: + goto yy1183; + goto yy1184; + yy1187: yych = *++p; if (yych <= 0x8F) - goto yy2049; + goto yy1184; if (yych <= 0xBF) - goto yy2051; - goto yy2049; - yy2053: + goto yy1186; + goto yy1184; + yy1188: yych = *++p; if (yych <= 0x7F) - goto yy2049; + goto yy1184; if (yych <= 0xBF) - goto yy2051; - goto yy2049; - yy2054: + goto yy1186; + goto yy1184; + yy1189: yych = *++p; if (yych <= 0x7F) - goto yy2049; + goto yy1184; if (yych <= 0x8F) - goto yy2051; - goto yy2049; - yy2055: + goto yy1186; + goto yy1184; + yy1190: yych = *++p; if (yych <= 0x7F) - goto yy2049; + goto yy1184; if (yych <= 0x9F) - goto yy2048; - goto yy2049; - yy2056: + goto yy1183; + goto yy1184; + yy1191: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy2056; + goto yy1191; } if (yych == '\n') - goto yy2058; + goto yy1193; if (yych != '\r') - goto yy2049; - yy2058: + goto yy1184; + yy1193: ++p; { return 2; } - yy2060: + yy1195: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy2056; + goto yy1191; } if (yych <= '\f') { if (yych == '\n') - goto yy2058; - goto yy2049; + goto yy1193; + goto yy1184; } else { if (yych <= '\r') - goto yy2058; + goto yy1193; if (yych == '-') - goto yy2060; - goto yy2049; + goto yy1195; + goto yy1184; } - yy2062: + yy1197: ++p; yych = *p; if (yych <= '\f') { if (yych != '\n') - goto yy2049; + goto yy1184; } else { if (yych <= '\r') - goto yy2064; + goto yy1199; if (yych == ' ') - goto yy2062; - goto yy2049; + goto yy1197; + goto yy1184; } - yy2064: + yy1199: ++p; { return 1; } - yy2066: + yy1201: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy2066; + goto yy1201; } if (yych <= '\f') { if (yych == '\n') - goto yy2064; - goto yy2049; + goto yy1199; + goto yy1184; } else { if (yych <= '\r') - goto yy2064; + goto yy1199; if (yych == ' ') - goto yy2062; - goto yy2049; + goto yy1197; + goto yy1184; } } } @@ -24795,9 +18923,9 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { { unsigned char yych; static const unsigned char yybm[] = { - 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, 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, 32, 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, 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, @@ -24812,347 +18940,269 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { if (yych <= 0x7F) { if (yych <= '*') { if (yych == '\n') - goto yy2070; + goto yy1205; if (yych <= ')') - goto yy2074; - goto yy2071; + goto yy1209; + goto yy1206; } else { if (yych <= '-') { if (yych <= ',') - goto yy2074; - goto yy2073; + goto yy1209; + goto yy1208; } else { if (yych == '_') - goto yy2072; - goto yy2074; + goto yy1207; + goto yy1209; } } } else { if (yych <= 0xED) { if (yych <= 0xDF) { if (yych >= 0xC2) - goto yy2075; + goto yy1210; } else { if (yych <= 0xE0) - goto yy2077; + goto yy1212; if (yych <= 0xEC) - goto yy2078; - goto yy2082; + goto yy1213; + goto yy1217; } } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy2078; - goto yy2079; + goto yy1213; + goto yy1214; } else { if (yych <= 0xF3) - goto yy2080; + goto yy1215; if (yych <= 0xF4) - goto yy2081; + goto yy1216; } } } - yy2070 : { return 0; } - yy2071: + yy1205 : { return 0; } + yy1206: yych = *(marker = ++p); if (yych == ' ') - goto yy2107; + goto yy1238; if (yych == '*') - goto yy2109; - goto yy2070; - yy2072: + goto yy1240; + goto yy1205; + yy1207: yych = *(marker = ++p); if (yych == ' ') - goto yy2095; + goto yy1228; if (yych == '_') - goto yy2097; - goto yy2070; - yy2073: + goto yy1230; + goto yy1205; + yy1208: yych = *(marker = ++p); if (yybm[0 + yych] & 8) { - goto yy2083; + goto yy1218; } if (yych == '-') - goto yy2085; - goto yy2070; - yy2074: + goto yy1220; + goto yy1205; + yy1209: yych = *++p; - goto yy2070; - yy2075: + goto yy1205; + yy1210: yych = *++p; if (yych <= 0x7F) - goto yy2076; + goto yy1211; if (yych <= 0xBF) - goto yy2074; - yy2076: + goto yy1209; + yy1211: p = marker; - goto yy2070; - yy2077: + goto yy1205; + yy1212: yych = *++p; if (yych <= 0x9F) - goto yy2076; + goto yy1211; if (yych <= 0xBF) - goto yy2075; - goto yy2076; - yy2078: + goto yy1210; + goto yy1211; + yy1213: yych = *++p; if (yych <= 0x7F) - goto yy2076; + goto yy1211; if (yych <= 0xBF) - goto yy2075; - goto yy2076; - yy2079: + goto yy1210; + goto yy1211; + yy1214: yych = *++p; if (yych <= 0x8F) - goto yy2076; + goto yy1211; if (yych <= 0xBF) - goto yy2078; - goto yy2076; - yy2080: + goto yy1213; + goto yy1211; + yy1215: yych = *++p; if (yych <= 0x7F) - goto yy2076; + goto yy1211; if (yych <= 0xBF) - goto yy2078; - goto yy2076; - yy2081: + goto yy1213; + goto yy1211; + yy1216: yych = *++p; if (yych <= 0x7F) - goto yy2076; + goto yy1211; if (yych <= 0x8F) - goto yy2078; - goto yy2076; - yy2082: + goto yy1213; + goto yy1211; + yy1217: yych = *++p; if (yych <= 0x7F) - goto yy2076; + goto yy1211; if (yych <= 0x9F) - goto yy2075; - goto yy2076; - yy2083: + goto yy1210; + goto yy1211; + yy1218: ++p; yych = *p; if (yybm[0 + yych] & 8) { - goto yy2083; + goto yy1218; } if (yych != '-') - goto yy2076; - yy2085: + goto yy1211; + yy1220: ++p; yych = *p; if (yych == ' ') - goto yy2085; + goto yy1220; if (yych != '-') - goto yy2076; - yy2087: + goto yy1211; + yy1222: ++p; yych = *p; - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x08) - goto yy2076; - } else { - if (yych <= '\n') - goto yy2091; - if (yych <= '\f') - goto yy2076; - goto yy2091; - } + if (yybm[0 + yych] & 16) { + goto yy1222; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy1211; + if (yych >= '\n') + goto yy1226; } else { - if (yych <= ' ') { - if (yych <= 0x1F) - goto yy2076; - goto yy2087; - } else { - if (yych == '-') - goto yy2093; - goto yy2076; - } + if (yych == '\r') + goto yy1226; + goto yy1211; } - yy2089: + yy1224: ++p; yych = *p; - if (yybm[0 + yych] & 16) { - goto yy2089; + if (yybm[0 + yych] & 32) { + goto yy1224; } if (yych <= 0x08) - goto yy2076; + goto yy1211; if (yych <= '\n') - goto yy2091; + goto yy1226; if (yych != '\r') - goto yy2076; - yy2091: + goto yy1211; + yy1226: ++p; { return (bufsize_t)(p - start); } - yy2093: - ++p; - yych = *p; - if (yybm[0 + yych] & 32) { - goto yy2093; - } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy2076; - if (yych <= '\t') - goto yy2089; - goto yy2091; - } else { - if (yych == '\r') - goto yy2091; - goto yy2076; - } - yy2095: + yy1228: ++p; yych = *p; if (yych == ' ') - goto yy2095; + goto yy1228; if (yych != '_') - goto yy2076; - yy2097: + goto yy1211; + yy1230: ++p; yych = *p; if (yych == ' ') - goto yy2097; + goto yy1230; if (yych != '_') - goto yy2076; - yy2099: + goto yy1211; + yy1232: ++p; yych = *p; - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x08) - goto yy2076; - } else { - if (yych <= '\n') - goto yy2103; - if (yych <= '\f') - goto yy2076; - goto yy2103; - } + if (yybm[0 + yych] & 64) { + goto yy1232; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy1211; + if (yych >= '\n') + goto yy1236; } else { - if (yych <= ' ') { - if (yych <= 0x1F) - goto yy2076; - goto yy2099; - } else { - if (yych == '_') - goto yy2105; - goto yy2076; - } + if (yych == '\r') + goto yy1236; + goto yy1211; } - yy2101: + yy1234: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) - goto yy2076; + goto yy1211; if (yych <= '\t') - goto yy2101; + goto yy1234; if (yych >= '\v') - goto yy2076; + goto yy1211; } else { if (yych <= '\r') - goto yy2103; + goto yy1236; if (yych == ' ') - goto yy2101; - goto yy2076; + goto yy1234; + goto yy1211; } - yy2103: + yy1236: ++p; { return (bufsize_t)(p - start); } - yy2105: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy2105; - } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy2076; - if (yych <= '\t') - goto yy2101; - goto yy2103; - } else { - if (yych == '\r') - goto yy2103; - goto yy2076; - } - yy2107: + yy1238: ++p; yych = *p; if (yych == ' ') - goto yy2107; + goto yy1238; if (yych != '*') - goto yy2076; - yy2109: + goto yy1211; + yy1240: ++p; yych = *p; if (yych == ' ') - goto yy2109; + goto yy1240; if (yych != '*') - goto yy2076; - yy2111: + goto yy1211; + yy1242: ++p; yych = *p; - if (yych <= '\r') { - if (yych <= '\t') { - if (yych <= 0x08) - goto yy2076; - } else { - if (yych <= '\n') - goto yy2115; - if (yych <= '\f') - goto yy2076; - goto yy2115; - } + if (yybm[0 + yych] & 128) { + goto yy1242; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy1211; + if (yych >= '\n') + goto yy1246; } else { - if (yych <= ' ') { - if (yych <= 0x1F) - goto yy2076; - goto yy2111; - } else { - if (yych == '*') - goto yy2117; - goto yy2076; - } + if (yych == '\r') + goto yy1246; + goto yy1211; } - yy2113: + yy1244: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) - goto yy2076; + goto yy1211; if (yych <= '\t') - goto yy2113; + goto yy1244; if (yych >= '\v') - goto yy2076; + goto yy1211; } else { if (yych <= '\r') - goto yy2115; + goto yy1246; if (yych == ' ') - goto yy2113; - goto yy2076; + goto yy1244; + goto yy1211; } - yy2115: + yy1246: ++p; { return (bufsize_t)(p - start); } - yy2117: - ++p; - yych = *p; - if (yybm[0 + yych] & 128) { - goto yy2117; - } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy2076; - if (yych <= '\t') - goto yy2113; - goto yy2115; - } else { - if (yych == '\r') - goto yy2115; - goto yy2076; - } } } @@ -25188,374 +19238,374 @@ bufsize_t _scan_open_code_fence(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '`') { if (yych == '\n') - goto yy2121; + goto yy1250; if (yych <= '_') - goto yy2124; - goto yy2122; + goto yy1253; + goto yy1251; } else { if (yych == '~') - goto yy2123; + goto yy1252; if (yych <= 0x7F) - goto yy2124; + goto yy1253; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy2125; + goto yy1254; if (yych <= 0xE0) - goto yy2127; + goto yy1256; if (yych <= 0xEC) - goto yy2128; - goto yy2132; + goto yy1257; + goto yy1261; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy2128; - goto yy2129; + goto yy1257; + goto yy1258; } else { if (yych <= 0xF3) - goto yy2130; + goto yy1259; if (yych <= 0xF4) - goto yy2131; + goto yy1260; } } } - yy2121 : { return 0; } - yy2122: + yy1250 : { return 0; } + yy1251: yych = *(marker = ++p); if (yych == '`') - goto yy2147; - goto yy2121; - yy2123: + goto yy1276; + goto yy1250; + yy1252: yych = *(marker = ++p); if (yych == '~') - goto yy2133; - goto yy2121; - yy2124: + goto yy1262; + goto yy1250; + yy1253: yych = *++p; - goto yy2121; - yy2125: + goto yy1250; + yy1254: yych = *++p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2124; - yy2126: + goto yy1253; + yy1255: p = marker; - goto yy2121; - yy2127: + goto yy1250; + yy1256: yych = *++p; if (yych <= 0x9F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2125; - goto yy2126; - yy2128: + goto yy1254; + goto yy1255; + yy1257: yych = *++p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2125; - goto yy2126; - yy2129: + goto yy1254; + goto yy1255; + yy1258: yych = *++p; if (yych <= 0x8F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2128; - goto yy2126; - yy2130: + goto yy1257; + goto yy1255; + yy1259: yych = *++p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2128; - goto yy2126; - yy2131: + goto yy1257; + goto yy1255; + yy1260: yych = *++p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0x8F) - goto yy2128; - goto yy2126; - yy2132: + goto yy1257; + goto yy1255; + yy1261: yych = *++p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0x9F) - goto yy2125; - goto yy2126; - yy2133: + goto yy1254; + goto yy1255; + yy1262: yych = *++p; if (yybm[0 + yych] & 16) { - goto yy2134; + goto yy1263; } - goto yy2126; - yy2134: + goto yy1255; + yy1263: + marker = p + 1; ++p; yych = *p; - marker = p; if (yybm[0 + yych] & 32) { - goto yy2136; + goto yy1265; } if (yych <= 0xE0) { if (yych <= '~') { if (yych <= 0x00) - goto yy2126; + goto yy1255; if (yych <= '\r') - goto yy2145; - goto yy2134; + goto yy1274; + goto yy1263; } else { if (yych <= 0xC1) - goto yy2126; + goto yy1255; if (yych <= 0xDF) - goto yy2138; - goto yy2139; + goto yy1267; + goto yy1268; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2144; - goto yy2140; + goto yy1273; + goto yy1269; } else { if (yych <= 0xF0) - goto yy2141; + goto yy1270; if (yych <= 0xF3) - goto yy2142; + goto yy1271; if (yych <= 0xF4) - goto yy2143; - goto yy2126; + goto yy1272; + goto yy1255; } } - yy2136: + yy1265: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy2136; + goto yy1265; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy2126; + goto yy1255; if (yych <= '\r') - goto yy2145; - goto yy2126; + goto yy1274; + goto yy1255; } else { if (yych <= 0xDF) - goto yy2138; + goto yy1267; if (yych <= 0xE0) - goto yy2139; - goto yy2140; + goto yy1268; + goto yy1269; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy2144; + goto yy1273; if (yych <= 0xEF) - goto yy2140; - goto yy2141; + goto yy1269; + goto yy1270; } else { if (yych <= 0xF3) - goto yy2142; + goto yy1271; if (yych <= 0xF4) - goto yy2143; - goto yy2126; + goto yy1272; + goto yy1255; } } - yy2138: + yy1267: ++p; yych = *p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2136; - goto yy2126; - yy2139: + goto yy1265; + goto yy1255; + yy1268: ++p; yych = *p; if (yych <= 0x9F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2138; - goto yy2126; - yy2140: + goto yy1267; + goto yy1255; + yy1269: ++p; yych = *p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2138; - goto yy2126; - yy2141: + goto yy1267; + goto yy1255; + yy1270: ++p; yych = *p; if (yych <= 0x8F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2140; - goto yy2126; - yy2142: + goto yy1269; + goto yy1255; + yy1271: ++p; yych = *p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2140; - goto yy2126; - yy2143: + goto yy1269; + goto yy1255; + yy1272: ++p; yych = *p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0x8F) - goto yy2140; - goto yy2126; - yy2144: + goto yy1269; + goto yy1255; + yy1273: ++p; yych = *p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0x9F) - goto yy2138; - goto yy2126; - yy2145: + goto yy1267; + goto yy1255; + yy1274: ++p; p = marker; { return (bufsize_t)(p - start); } - yy2147: + yy1276: yych = *++p; if (yybm[0 + yych] & 64) { - goto yy2148; + goto yy1277; } - goto yy2126; - yy2148: + goto yy1255; + yy1277: + marker = p + 1; ++p; yych = *p; - marker = p; if (yybm[0 + yych] & 128) { - goto yy2150; + goto yy1279; } if (yych <= 0xE0) { if (yych <= '`') { if (yych <= 0x00) - goto yy2126; + goto yy1255; if (yych <= '\r') - goto yy2159; - goto yy2148; + goto yy1288; + goto yy1277; } else { if (yych <= 0xC1) - goto yy2126; + goto yy1255; if (yych <= 0xDF) - goto yy2152; - goto yy2153; + goto yy1281; + goto yy1282; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy2158; - goto yy2154; + goto yy1287; + goto yy1283; } else { if (yych <= 0xF0) - goto yy2155; + goto yy1284; if (yych <= 0xF3) - goto yy2156; + goto yy1285; if (yych <= 0xF4) - goto yy2157; - goto yy2126; + goto yy1286; + goto yy1255; } } - yy2150: + yy1279: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy2150; + goto yy1279; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy2126; + goto yy1255; if (yych <= '\r') - goto yy2159; - goto yy2126; + goto yy1288; + goto yy1255; } else { if (yych <= 0xDF) - goto yy2152; + goto yy1281; if (yych <= 0xE0) - goto yy2153; - goto yy2154; + goto yy1282; + goto yy1283; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy2158; + goto yy1287; if (yych <= 0xEF) - goto yy2154; - goto yy2155; + goto yy1283; + goto yy1284; } else { if (yych <= 0xF3) - goto yy2156; + goto yy1285; if (yych <= 0xF4) - goto yy2157; - goto yy2126; + goto yy1286; + goto yy1255; } } - yy2152: + yy1281: ++p; yych = *p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2150; - goto yy2126; - yy2153: + goto yy1279; + goto yy1255; + yy1282: ++p; yych = *p; if (yych <= 0x9F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2152; - goto yy2126; - yy2154: + goto yy1281; + goto yy1255; + yy1283: ++p; yych = *p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2152; - goto yy2126; - yy2155: + goto yy1281; + goto yy1255; + yy1284: ++p; yych = *p; if (yych <= 0x8F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2154; - goto yy2126; - yy2156: + goto yy1283; + goto yy1255; + yy1285: ++p; yych = *p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0xBF) - goto yy2154; - goto yy2126; - yy2157: + goto yy1283; + goto yy1255; + yy1286: ++p; yych = *p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0x8F) - goto yy2154; - goto yy2126; - yy2158: + goto yy1283; + goto yy1255; + yy1287: ++p; yych = *p; if (yych <= 0x7F) - goto yy2126; + goto yy1255; if (yych <= 0x9F) - goto yy2152; - goto yy2126; - yy2159: + goto yy1281; + goto yy1255; + yy1288: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -25587,190 +19637,190 @@ bufsize_t _scan_close_code_fence(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '`') { if (yych == '\n') - goto yy2163; + goto yy1292; if (yych <= '_') - goto yy2166; - goto yy2164; + goto yy1295; + goto yy1293; } else { if (yych == '~') - goto yy2165; + goto yy1294; if (yych <= 0x7F) - goto yy2166; + goto yy1295; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy2167; + goto yy1296; if (yych <= 0xE0) - goto yy2169; + goto yy1298; if (yych <= 0xEC) - goto yy2170; - goto yy2174; + goto yy1299; + goto yy1303; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy2170; - goto yy2171; + goto yy1299; + goto yy1300; } else { if (yych <= 0xF3) - goto yy2172; + goto yy1301; if (yych <= 0xF4) - goto yy2173; + goto yy1302; } } } - yy2163 : { return 0; } - yy2164: + yy1292 : { return 0; } + yy1293: yych = *(marker = ++p); if (yych == '`') - goto yy2182; - goto yy2163; - yy2165: + goto yy1311; + goto yy1292; + yy1294: yych = *(marker = ++p); if (yych == '~') - goto yy2175; - goto yy2163; - yy2166: + goto yy1304; + goto yy1292; + yy1295: yych = *++p; - goto yy2163; - yy2167: + goto yy1292; + yy1296: yych = *++p; if (yych <= 0x7F) - goto yy2168; + goto yy1297; if (yych <= 0xBF) - goto yy2166; - yy2168: + goto yy1295; + yy1297: p = marker; - goto yy2163; - yy2169: + goto yy1292; + yy1298: yych = *++p; if (yych <= 0x9F) - goto yy2168; + goto yy1297; if (yych <= 0xBF) - goto yy2167; - goto yy2168; - yy2170: + goto yy1296; + goto yy1297; + yy1299: yych = *++p; if (yych <= 0x7F) - goto yy2168; + goto yy1297; if (yych <= 0xBF) - goto yy2167; - goto yy2168; - yy2171: + goto yy1296; + goto yy1297; + yy1300: yych = *++p; if (yych <= 0x8F) - goto yy2168; + goto yy1297; if (yych <= 0xBF) - goto yy2170; - goto yy2168; - yy2172: + goto yy1299; + goto yy1297; + yy1301: yych = *++p; if (yych <= 0x7F) - goto yy2168; + goto yy1297; if (yych <= 0xBF) - goto yy2170; - goto yy2168; - yy2173: + goto yy1299; + goto yy1297; + yy1302: yych = *++p; if (yych <= 0x7F) - goto yy2168; + goto yy1297; if (yych <= 0x8F) - goto yy2170; - goto yy2168; - yy2174: + goto yy1299; + goto yy1297; + yy1303: yych = *++p; if (yych <= 0x7F) - goto yy2168; + goto yy1297; if (yych <= 0x9F) - goto yy2167; - goto yy2168; - yy2175: + goto yy1296; + goto yy1297; + yy1304: yych = *++p; if (yybm[0 + yych] & 32) { - goto yy2176; + goto yy1305; } - goto yy2168; - yy2176: + goto yy1297; + yy1305: + marker = p + 1; ++p; yych = *p; - marker = p; if (yybm[0 + yych] & 64) { - goto yy2178; + goto yy1307; } if (yych <= '\f') { if (yych <= 0x08) - goto yy2168; + goto yy1297; if (yych <= '\n') - goto yy2180; - goto yy2168; + goto yy1309; + goto yy1297; } else { if (yych <= '\r') - goto yy2180; + goto yy1309; if (yych == '~') - goto yy2176; - goto yy2168; + goto yy1305; + goto yy1297; } - yy2178: + yy1307: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy2178; + goto yy1307; } if (yych <= 0x08) - goto yy2168; + goto yy1297; if (yych <= '\n') - goto yy2180; + goto yy1309; if (yych != '\r') - goto yy2168; - yy2180: + goto yy1297; + yy1309: ++p; p = marker; { return (bufsize_t)(p - start); } - yy2182: + yy1311: yych = *++p; if (yybm[0 + yych] & 128) { - goto yy2183; + goto yy1312; } - goto yy2168; - yy2183: + goto yy1297; + yy1312: + marker = p + 1; ++p; yych = *p; - marker = p; if (yybm[0 + yych] & 128) { - goto yy2183; + goto yy1312; } if (yych <= '\f') { if (yych <= 0x08) - goto yy2168; + goto yy1297; if (yych <= '\t') - goto yy2185; + goto yy1314; if (yych <= '\n') - goto yy2187; - goto yy2168; + goto yy1316; + goto yy1297; } else { if (yych <= '\r') - goto yy2187; + goto yy1316; if (yych != ' ') - goto yy2168; + goto yy1297; } - yy2185: + yy1314: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) - goto yy2168; + goto yy1297; if (yych <= '\t') - goto yy2185; + goto yy1314; if (yych >= '\v') - goto yy2168; + goto yy1297; } else { if (yych <= '\r') - goto yy2187; + goto yy1316; if (yych == ' ') - goto yy2185; - goto yy2168; + goto yy1314; + goto yy1297; } - yy2187: + yy1316: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -25789,997 +19839,997 @@ bufsize_t _scan_entity(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= '%') { if (yych != '\n') - goto yy2193; + goto yy1322; } else { if (yych <= '&') - goto yy2192; + goto yy1321; if (yych <= 0x7F) - goto yy2193; + goto yy1322; if (yych >= 0xC2) - goto yy2194; + goto yy1323; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy2196; + goto yy1325; if (yych == 0xED) - goto yy2201; - goto yy2197; + goto yy1330; + goto yy1326; } else { if (yych <= 0xF0) - goto yy2198; + goto yy1327; if (yych <= 0xF3) - goto yy2199; + goto yy1328; if (yych <= 0xF4) - goto yy2200; + goto yy1329; } } - yy2191 : { return 0; } - yy2192: + yy1320 : { return 0; } + yy1321: yych = *(marker = ++p); if (yych <= '@') { if (yych == '#') - goto yy2202; - goto yy2191; + goto yy1331; + goto yy1320; } else { if (yych <= 'Z') - goto yy2203; + goto yy1332; if (yych <= '`') - goto yy2191; + goto yy1320; if (yych <= 'z') - goto yy2203; - goto yy2191; + goto yy1332; + goto yy1320; } - yy2193: + yy1322: yych = *++p; - goto yy2191; - yy2194: + goto yy1320; + yy1323: yych = *++p; if (yych <= 0x7F) - goto yy2195; + goto yy1324; if (yych <= 0xBF) - goto yy2193; - yy2195: + goto yy1322; + yy1324: p = marker; - goto yy2191; - yy2196: + goto yy1320; + yy1325: yych = *++p; if (yych <= 0x9F) - goto yy2195; + goto yy1324; if (yych <= 0xBF) - goto yy2194; - goto yy2195; - yy2197: + goto yy1323; + goto yy1324; + yy1326: yych = *++p; if (yych <= 0x7F) - goto yy2195; + goto yy1324; if (yych <= 0xBF) - goto yy2194; - goto yy2195; - yy2198: + goto yy1323; + goto yy1324; + yy1327: yych = *++p; if (yych <= 0x8F) - goto yy2195; + goto yy1324; if (yych <= 0xBF) - goto yy2197; - goto yy2195; - yy2199: + goto yy1326; + goto yy1324; + yy1328: yych = *++p; if (yych <= 0x7F) - goto yy2195; + goto yy1324; if (yych <= 0xBF) - goto yy2197; - goto yy2195; - yy2200: + goto yy1326; + goto yy1324; + yy1329: yych = *++p; if (yych <= 0x7F) - goto yy2195; + goto yy1324; if (yych <= 0x8F) - goto yy2197; - goto yy2195; - yy2201: + goto yy1326; + goto yy1324; + yy1330: yych = *++p; if (yych <= 0x7F) - goto yy2195; + goto yy1324; if (yych <= 0x9F) - goto yy2194; - goto yy2195; - yy2202: + goto yy1323; + goto yy1324; + yy1331: yych = *++p; if (yych <= 'W') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2238; - goto yy2195; + goto yy1367; + goto yy1324; } else { if (yych <= 'X') - goto yy2237; + goto yy1366; if (yych == 'x') - goto yy2237; - goto yy2195; + goto yy1366; + goto yy1324; } - yy2203: + yy1332: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych >= ':') - goto yy2195; + goto yy1324; } else { if (yych <= 'Z') - goto yy2204; + goto yy1333; if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } - yy2204: + yy1333: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2207; + goto yy1336; if (yych <= ':') - goto yy2195; + goto yy1324; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; - goto yy2207; + goto yy1324; + goto yy1336; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych <= 'z') - goto yy2207; - goto yy2195; + goto yy1336; + goto yy1324; } } - yy2205: + yy1334: ++p; { return (bufsize_t)(p - start); } - yy2207: + yy1336: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2208; + goto yy1337; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2208: + yy1337: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2209; + goto yy1338; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2209: + yy1338: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2210; + goto yy1339; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2210: + yy1339: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2211; + goto yy1340; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2211: + yy1340: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2212; + goto yy1341; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2212: + yy1341: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2213; + goto yy1342; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2213: + yy1342: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2214; + goto yy1343; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2214: + yy1343: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2215; + goto yy1344; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2215: + yy1344: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2216; + goto yy1345; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2216: + yy1345: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2217; + goto yy1346; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2217: + yy1346: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2218; + goto yy1347; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2218: + yy1347: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2219; + goto yy1348; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2219: + yy1348: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2220; + goto yy1349; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2220: + yy1349: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2221; + goto yy1350; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2221: + yy1350: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2222; + goto yy1351; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2222: + yy1351: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2223; + goto yy1352; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2223: + yy1352: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2224; + goto yy1353; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2224: + yy1353: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2225; + goto yy1354; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2225: + yy1354: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2226; + goto yy1355; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2226: + yy1355: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2227; + goto yy1356; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2227: + yy1356: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2228; + goto yy1357; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2228: + yy1357: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2229; + goto yy1358; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2229: + yy1358: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2230; + goto yy1359; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2230: + yy1359: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2231; + goto yy1360; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2231: + yy1360: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2232; + goto yy1361; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2232: + yy1361: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2233; + goto yy1362; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2233: + yy1362: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2234; + goto yy1363; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2234: + yy1363: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2235; + goto yy1364; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2235: + yy1364: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2236; + goto yy1365; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= '{') - goto yy2195; + goto yy1324; } } - yy2236: + yy1365: yych = *++p; if (yych == ';') - goto yy2205; - goto yy2195; - yy2237: + goto yy1334; + goto yy1324; + yy1366: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2245; - goto yy2195; + goto yy1374; + goto yy1324; } else { if (yych <= 'F') - goto yy2245; + goto yy1374; if (yych <= '`') - goto yy2195; + goto yy1324; if (yych <= 'f') - goto yy2245; - goto yy2195; + goto yy1374; + goto yy1324; } - yy2238: + yy1367: yych = *++p; if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2239; + goto yy1368; if (yych == ';') - goto yy2205; - goto yy2195; - yy2239: + goto yy1334; + goto yy1324; + yy1368: yych = *++p; if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2240; + goto yy1369; if (yych == ';') - goto yy2205; - goto yy2195; - yy2240: + goto yy1334; + goto yy1324; + yy1369: yych = *++p; if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2241; + goto yy1370; if (yych == ';') - goto yy2205; - goto yy2195; - yy2241: + goto yy1334; + goto yy1324; + yy1370: yych = *++p; if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2242; + goto yy1371; if (yych == ';') - goto yy2205; - goto yy2195; - yy2242: + goto yy1334; + goto yy1324; + yy1371: yych = *++p; if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2243; + goto yy1372; if (yych == ';') - goto yy2205; - goto yy2195; - yy2243: + goto yy1334; + goto yy1324; + yy1372: yych = *++p; if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2244; + goto yy1373; if (yych == ';') - goto yy2205; - goto yy2195; - yy2244: + goto yy1334; + goto yy1324; + yy1373: yych = *++p; if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2236; + goto yy1365; if (yych == ';') - goto yy2205; - goto yy2195; - yy2245: + goto yy1334; + goto yy1324; + yy1374: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2246; + goto yy1375; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= 'g') - goto yy2195; + goto yy1324; } } - yy2246: + yy1375: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2247; + goto yy1376; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= 'g') - goto yy2195; + goto yy1324; } } - yy2247: + yy1376: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2248; + goto yy1377; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= 'g') - goto yy2195; + goto yy1324; } } - yy2248: + yy1377: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2249; + goto yy1378; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= 'g') - goto yy2195; + goto yy1324; } } - yy2249: + yy1378: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2250; + goto yy1379; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= 'g') - goto yy2195; + goto yy1324; } } - yy2250: + yy1379: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2251; + goto yy1380; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2195; + goto yy1324; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych >= 'g') - goto yy2195; + goto yy1324; } } - yy2251: + yy1380: ++p; if ((yych = *p) <= ';') { if (yych <= '/') - goto yy2195; + goto yy1324; if (yych <= '9') - goto yy2236; + goto yy1365; if (yych <= ':') - goto yy2195; - goto yy2205; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy2195; - goto yy2236; + goto yy1324; + goto yy1365; } else { if (yych <= '`') - goto yy2195; + goto yy1324; if (yych <= 'f') - goto yy2236; - goto yy2195; + goto yy1365; + goto yy1324; } } } @@ -26799,415 +20849,415 @@ bufsize_t _scan_dangerous_url(const unsigned char *p) { if (yych <= 'I') { if (yych <= 'C') { if (yych != '\n') - goto yy2259; + goto yy1388; } else { if (yych <= 'D') - goto yy2255; + goto yy1384; if (yych == 'F') - goto yy2258; - goto yy2259; + goto yy1387; + goto yy1388; } } else { if (yych <= 'V') { if (yych <= 'J') - goto yy2256; + goto yy1385; if (yych <= 'U') - goto yy2259; - goto yy2257; + goto yy1388; + goto yy1386; } else { if (yych == 'd') - goto yy2255; + goto yy1384; if (yych <= 'e') - goto yy2259; - goto yy2258; + goto yy1388; + goto yy1387; } } } else { if (yych <= 0xDF) { if (yych <= 'u') { if (yych == 'j') - goto yy2256; - goto yy2259; + goto yy1385; + goto yy1388; } else { if (yych <= 'v') - goto yy2257; + goto yy1386; if (yych <= 0x7F) - goto yy2259; + goto yy1388; if (yych >= 0xC2) - goto yy2260; + goto yy1389; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy2262; + goto yy1391; if (yych == 0xED) - goto yy2267; - goto yy2263; + goto yy1396; + goto yy1392; } else { if (yych <= 0xF0) - goto yy2264; + goto yy1393; if (yych <= 0xF3) - goto yy2265; + goto yy1394; if (yych <= 0xF4) - goto yy2266; + goto yy1395; } } } - yy2254 : { return 0; } - yy2255: + yy1383 : { return 0; } + yy1384: yyaccept = 0; yych = *(marker = ++p); if (yych == 'A') - goto yy2289; + goto yy1418; if (yych == 'a') - goto yy2289; - goto yy2254; - yy2256: + goto yy1418; + goto yy1383; + yy1385: yyaccept = 0; yych = *(marker = ++p); if (yych == 'A') - goto yy2280; + goto yy1409; if (yych == 'a') - goto yy2280; - goto yy2254; - yy2257: + goto yy1409; + goto yy1383; + yy1386: yyaccept = 0; yych = *(marker = ++p); if (yych == 'B') - goto yy2273; + goto yy1402; if (yych == 'b') - goto yy2273; - goto yy2254; - yy2258: + goto yy1402; + goto yy1383; + yy1387: yyaccept = 0; yych = *(marker = ++p); if (yych == 'I') - goto yy2268; + goto yy1397; if (yych == 'i') - goto yy2268; - goto yy2254; - yy2259: + goto yy1397; + goto yy1383; + yy1388: yych = *++p; - goto yy2254; - yy2260: + goto yy1383; + yy1389: yych = *++p; if (yych <= 0x7F) - goto yy2261; + goto yy1390; if (yych <= 0xBF) - goto yy2259; - yy2261: + goto yy1388; + yy1390: p = marker; if (yyaccept == 0) { - goto yy2254; + goto yy1383; } else { - goto yy2272; + goto yy1401; } - yy2262: + yy1391: yych = *++p; if (yych <= 0x9F) - goto yy2261; + goto yy1390; if (yych <= 0xBF) - goto yy2260; - goto yy2261; - yy2263: + goto yy1389; + goto yy1390; + yy1392: yych = *++p; if (yych <= 0x7F) - goto yy2261; + goto yy1390; if (yych <= 0xBF) - goto yy2260; - goto yy2261; - yy2264: + goto yy1389; + goto yy1390; + yy1393: yych = *++p; if (yych <= 0x8F) - goto yy2261; + goto yy1390; if (yych <= 0xBF) - goto yy2263; - goto yy2261; - yy2265: + goto yy1392; + goto yy1390; + yy1394: yych = *++p; if (yych <= 0x7F) - goto yy2261; + goto yy1390; if (yych <= 0xBF) - goto yy2263; - goto yy2261; - yy2266: + goto yy1392; + goto yy1390; + yy1395: yych = *++p; if (yych <= 0x7F) - goto yy2261; + goto yy1390; if (yych <= 0x8F) - goto yy2263; - goto yy2261; - yy2267: + goto yy1392; + goto yy1390; + yy1396: yych = *++p; if (yych <= 0x7F) - goto yy2261; + goto yy1390; if (yych <= 0x9F) - goto yy2260; - goto yy2261; - yy2268: + goto yy1389; + goto yy1390; + yy1397: yych = *++p; if (yych == 'L') - goto yy2269; + goto yy1398; if (yych != 'l') - goto yy2261; - yy2269: + goto yy1390; + yy1398: yych = *++p; if (yych == 'E') - goto yy2270; + goto yy1399; if (yych != 'e') - goto yy2261; - yy2270: + goto yy1390; + yy1399: yych = *++p; if (yych != ':') - goto yy2261; - yy2271: + goto yy1390; + yy1400: ++p; - yy2272 : { return (bufsize_t)(p - start); } - yy2273: + yy1401 : { return (bufsize_t)(p - start); } + yy1402: yych = *++p; if (yych == 'S') - goto yy2274; + goto yy1403; if (yych != 's') - goto yy2261; - yy2274: + goto yy1390; + yy1403: yych = *++p; if (yych == 'C') - goto yy2275; + goto yy1404; if (yych != 'c') - goto yy2261; - yy2275: + goto yy1390; + yy1404: yych = *++p; if (yych == 'R') - goto yy2276; + goto yy1405; if (yych != 'r') - goto yy2261; - yy2276: + goto yy1390; + yy1405: yych = *++p; if (yych == 'I') - goto yy2277; + goto yy1406; if (yych != 'i') - goto yy2261; - yy2277: + goto yy1390; + yy1406: yych = *++p; if (yych == 'P') - goto yy2278; + goto yy1407; if (yych != 'p') - goto yy2261; - yy2278: + goto yy1390; + yy1407: yych = *++p; if (yych == 'T') - goto yy2279; + goto yy1408; if (yych != 't') - goto yy2261; - yy2279: + goto yy1390; + yy1408: yych = *++p; if (yych == ':') - goto yy2271; - goto yy2261; - yy2280: + goto yy1400; + goto yy1390; + yy1409: yych = *++p; if (yych == 'V') - goto yy2281; + goto yy1410; if (yych != 'v') - goto yy2261; - yy2281: + goto yy1390; + yy1410: yych = *++p; if (yych == 'A') - goto yy2282; + goto yy1411; if (yych != 'a') - goto yy2261; - yy2282: + goto yy1390; + yy1411: yych = *++p; if (yych == 'S') - goto yy2283; + goto yy1412; if (yych != 's') - goto yy2261; - yy2283: + goto yy1390; + yy1412: yych = *++p; if (yych == 'C') - goto yy2284; + goto yy1413; if (yych != 'c') - goto yy2261; - yy2284: + goto yy1390; + yy1413: yych = *++p; if (yych == 'R') - goto yy2285; + goto yy1414; if (yych != 'r') - goto yy2261; - yy2285: + goto yy1390; + yy1414: yych = *++p; if (yych == 'I') - goto yy2286; + goto yy1415; if (yych != 'i') - goto yy2261; - yy2286: + goto yy1390; + yy1415: yych = *++p; if (yych == 'P') - goto yy2287; + goto yy1416; if (yych != 'p') - goto yy2261; - yy2287: + goto yy1390; + yy1416: yych = *++p; if (yych == 'T') - goto yy2288; + goto yy1417; if (yych != 't') - goto yy2261; - yy2288: + goto yy1390; + yy1417: yych = *++p; if (yych == ':') - goto yy2271; - goto yy2261; - yy2289: + goto yy1400; + goto yy1390; + yy1418: yych = *++p; if (yych == 'T') - goto yy2290; + goto yy1419; if (yych != 't') - goto yy2261; - yy2290: + goto yy1390; + yy1419: yych = *++p; if (yych == 'A') - goto yy2291; + goto yy1420; if (yych != 'a') - goto yy2261; - yy2291: + goto yy1390; + yy1420: yych = *++p; if (yych != ':') - goto yy2261; + goto yy1390; yyaccept = 1; yych = *(marker = ++p); if (yych == 'I') - goto yy2293; + goto yy1422; if (yych != 'i') - goto yy2272; - yy2293: + goto yy1401; + yy1422: yych = *++p; if (yych == 'M') - goto yy2294; + goto yy1423; if (yych != 'm') - goto yy2261; - yy2294: + goto yy1390; + yy1423: yych = *++p; if (yych == 'A') - goto yy2295; + goto yy1424; if (yych != 'a') - goto yy2261; - yy2295: + goto yy1390; + yy1424: yych = *++p; if (yych == 'G') - goto yy2296; + goto yy1425; if (yych != 'g') - goto yy2261; - yy2296: + goto yy1390; + yy1425: yych = *++p; if (yych == 'E') - goto yy2297; + goto yy1426; if (yych != 'e') - goto yy2261; - yy2297: + goto yy1390; + yy1426: yych = *++p; if (yych != '/') - goto yy2261; + goto yy1390; yych = *++p; if (yych <= 'W') { if (yych <= 'J') { if (yych == 'G') - goto yy2300; + goto yy1429; if (yych <= 'I') - goto yy2261; - goto yy2301; + goto yy1390; + goto yy1430; } else { if (yych == 'P') - goto yy2299; + goto yy1428; if (yych <= 'V') - goto yy2261; - goto yy2302; + goto yy1390; + goto yy1431; } } else { if (yych <= 'j') { if (yych == 'g') - goto yy2300; + goto yy1429; if (yych <= 'i') - goto yy2261; - goto yy2301; + goto yy1390; + goto yy1430; } else { if (yych <= 'p') { if (yych <= 'o') - goto yy2261; + goto yy1390; } else { if (yych == 'w') - goto yy2302; - goto yy2261; + goto yy1431; + goto yy1390; } } } - yy2299: + yy1428: yych = *++p; if (yych == 'N') - goto yy2310; + goto yy1439; if (yych == 'n') - goto yy2310; - goto yy2261; - yy2300: + goto yy1439; + goto yy1390; + yy1429: yych = *++p; if (yych == 'I') - goto yy2309; + goto yy1438; if (yych == 'i') - goto yy2309; - goto yy2261; - yy2301: + goto yy1438; + goto yy1390; + yy1430: yych = *++p; if (yych == 'P') - goto yy2307; + goto yy1436; if (yych == 'p') - goto yy2307; - goto yy2261; - yy2302: + goto yy1436; + goto yy1390; + yy1431: yych = *++p; if (yych == 'E') - goto yy2303; + goto yy1432; if (yych != 'e') - goto yy2261; - yy2303: + goto yy1390; + yy1432: yych = *++p; if (yych == 'B') - goto yy2304; + goto yy1433; if (yych != 'b') - goto yy2261; - yy2304: + goto yy1390; + yy1433: yych = *++p; if (yych == 'P') - goto yy2305; + goto yy1434; if (yych != 'p') - goto yy2261; - yy2305: + goto yy1390; + yy1434: ++p; { return 0; } - yy2307: + yy1436: yych = *++p; if (yych == 'E') - goto yy2308; + goto yy1437; if (yych != 'e') - goto yy2261; - yy2308: + goto yy1390; + yy1437: yych = *++p; if (yych == 'G') - goto yy2305; + goto yy1434; if (yych == 'g') - goto yy2305; - goto yy2261; - yy2309: + goto yy1434; + goto yy1390; + yy1438: yych = *++p; if (yych == 'F') - goto yy2305; + goto yy1434; if (yych == 'f') - goto yy2305; - goto yy2261; - yy2310: + goto yy1434; + goto yy1390; + yy1439: ++p; if ((yych = *p) == 'G') - goto yy2305; + goto yy1434; if (yych == 'g') - goto yy2305; - goto yy2261; + goto yy1434; + goto yy1390; } } diff --git a/scanners.re b/scanners.re index 8176590..8b1c91e 100644 --- a/scanners.re +++ b/scanners.re @@ -71,7 +71,7 @@ bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, in_single_quotes = ['] (escaped_char|[^'\x00])* [']; in_parens = [(] (escaped_char|[^)\x00])* [)]; - scheme = 'coap'|'doi'|'javascript'|'aaa'|'aaas'|'about'|'acap'|'cap'|'cid'|'crid'|'data'|'dav'|'dict'|'dns'|'file'|'ftp'|'geo'|'go'|'gopher'|'h323'|'http'|'https'|'iax'|'icap'|'im'|'imap'|'info'|'ipp'|'iris'|'iris.beep'|'iris.xpc'|'iris.xpcs'|'iris.lwz'|'ldap'|'mailto'|'mid'|'msrp'|'msrps'|'mtqp'|'mupdate'|'news'|'nfs'|'ni'|'nih'|'nntp'|'opaquelocktoken'|'pop'|'pres'|'rtsp'|'service'|'session'|'shttp'|'sieve'|'sip'|'sips'|'sms'|'snmp'|'soap.beep'|'soap.beeps'|'tag'|'tel'|'telnet'|'tftp'|'thismessage'|'tn3270'|'tip'|'tv'|'urn'|'vemmi'|'ws'|'wss'|'xcon'|'xcon-userid'|'xmlrpc.beep'|'xmlrpc.beeps'|'xmpp'|'z39.50r'|'z39.50s'|'adiumxtra'|'afp'|'afs'|'aim'|'apt'|'attachment'|'aw'|'beshare'|'bitcoin'|'bolo'|'callto'|'chrome'|'chrome-extension'|'com-eventbrite-attendee'|'content'|'cvs'|'dlna-playsingle'|'dlna-playcontainer'|'dtn'|'dvb'|'ed2k'|'facetime'|'feed'|'finger'|'fish'|'gg'|'git'|'gizmoproject'|'gtalk'|'hcp'|'icon'|'ipn'|'irc'|'irc6'|'ircs'|'itms'|'jar'|'jms'|'keyparc'|'lastfm'|'ldaps'|'magnet'|'maps'|'market'|'message'|'mms'|'ms-help'|'msnim'|'mumble'|'mvn'|'notes'|'oid'|'palm'|'paparazzi'|'platform'|'proxy'|'psyc'|'query'|'res'|'resource'|'rmi'|'rsync'|'rtmp'|'secondlife'|'sftp'|'sgn'|'skype'|'smb'|'soldat'|'spotify'|'ssh'|'steam'|'svn'|'teamspeak'|'things'|'udp'|'unreal'|'ut2004'|'ventrilo'|'view-source'|'webcal'|'wtai'|'wyciwyg'|'xfire'|'xri'|'ymsgr'; + scheme = [A-Za-z ][A-Za-z.+-]{1,31}; */ // Try to match a scheme including colon. @@ -214,8 +214,8 @@ bufsize_t _scan_link_url(const unsigned char *p) const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - [ \r\n]* [<] ([^<>\r\n\\\x00] | escaped_char | [\\])* [>] { return (bufsize_t)(p - start); } - [ \r\n]* (reg_char+ | escaped_char | [\\] | in_parens_nosp)* { return (bufsize_t)(p - start); } + [ \r\n]* [<] ([^<> \t\r\n\\\x00] | escaped_char | [\\])* [>] { return (bufsize_t)(p - start); } + [ \r\n]* (reg_char+ | escaped_char | [\\] [^() \t\v\f\r\n] | in_parens_nosp)* [\\]? { return (bufsize_t)(p - start); } .? { return 0; } */ } From 59d78f236b0b7b05739a0b2c7896d371472712e4 Mon Sep 17 00:00:00 2001 From: jcadam Date: Mon, 18 Jan 2016 16:40:42 -0500 Subject: [PATCH 21/26] updated to cmark 0.24.1 --- cmark_version.h | 4 ++-- commonmark.c | 35 ++++++++++++++++++++++------------- iterator.c | 3 +++ render.c | 20 ++++++++++++++++---- 4 files changed, 43 insertions(+), 19 deletions(-) diff --git a/cmark_version.h b/cmark_version.h index b7af51d..a56570f 100644 --- a/cmark_version.h +++ b/cmark_version.h @@ -1,7 +1,7 @@ #ifndef CMARK_VERSION_H #define CMARK_VERSION_H -#define CMARK_VERSION ((0 << 16) | (24 << 8) | 0) -#define CMARK_VERSION_STRING "0.24.0" +#define CMARK_VERSION ((0 << 16) | (24 << 8) | 1) +#define CMARK_VERSION_STRING "0.24.1" #endif diff --git a/commonmark.c b/commonmark.c index 1a61334..751a5df 100644 --- a/commonmark.c +++ b/commonmark.c @@ -24,6 +24,8 @@ static inline void outc(cmark_renderer *renderer, cmark_escaping escape, int32_t c, unsigned char nextc) { bool needs_escaping = false; char encoded[20]; + bool follows_digit = renderer->buffer->size > 0 && + cmark_isdigit(renderer->buffer->ptr[renderer->buffer->size - 1]); needs_escaping = escape != LITERAL && @@ -31,9 +33,12 @@ static inline void outc(cmark_renderer *renderer, cmark_escaping escape, (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' || c == '>' || c == '\\' || c == '`' || c == '!' || (c == '&' && isalpha(nextc)) || (c == '!' && nextc == '[') || - (renderer->begin_content && (c == '-' || c == '+' || c == '=')) || - ((c == '.' || c == ')') && - isdigit(renderer->buffer->ptr[renderer->buffer->size - 1])))) || + (renderer->begin_content && (c == '-' || c == '+' || c == '=') && + // begin_content doesn't get set to false til we've passed digits + // at the beginning of line, so... + !follows_digit) || + (renderer->begin_content && (c == '.' || c == ')') && follows_digit && + (nextc == 0 || cmark_isspace(nextc))))) || (escape == URL && (c == '`' || c == '<' || c == '>' || isspace(c) || c == '\\' || c == ')' || c == '(')) || (escape == TITLE && @@ -121,6 +126,9 @@ static bool is_autolink(cmark_node *node) { } link_text = node->first_child; + if (link_text == NULL) { + return false; + } cmark_consolidate_text_nodes(link_text); realurl = (char *)url->data; realurllen = url->len; @@ -193,15 +201,17 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, case CMARK_NODE_LIST: if (!entering && node->next && (node->next->type == CMARK_NODE_CODE_BLOCK || node->next->type == CMARK_NODE_LIST)) { - // this ensures 2 blank lines after list, - // if before code block or list: - LIT("\n"); + // this ensures that a following code block or list will be + // inteprereted correctly. + CR(); + LIT(""); + BLANKLINE(); } break; case CMARK_NODE_ITEM: if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { - marker_width = 2; + marker_width = 4; } else { list_number = cmark_node_get_list_start(node->parent); list_delim = cmark_node_get_list_delim(node->parent); @@ -220,15 +230,14 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, } if (entering) { if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { - LIT("* "); + LIT(" - "); renderer->begin_content = true; - cmark_strbuf_puts(renderer->prefix, " "); } else { LIT(listmarker); renderer->begin_content = true; - for (i = marker_width; i--;) { - cmark_strbuf_putc(renderer->prefix, ' '); - } + } + for (i = marker_width; i--;) { + cmark_strbuf_putc(renderer->prefix, ' '); } } else { cmark_strbuf_truncate(renderer->prefix, @@ -320,7 +329,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, case CMARK_NODE_LINEBREAK: if (!(CMARK_OPT_HARDBREAKS & options)) { - LIT("\\"); + LIT(" "); } CR(); break; diff --git a/iterator.c b/iterator.c index c477f01..351b81f 100644 --- a/iterator.c +++ b/iterator.c @@ -89,6 +89,9 @@ cmark_event_type cmark_iter_get_event_type(cmark_iter *iter) { cmark_node *cmark_iter_get_root(cmark_iter *iter) { return iter->root; } void cmark_consolidate_text_nodes(cmark_node *root) { + if (root == NULL) { + return; + } cmark_iter *iter = cmark_iter_new(root); cmark_strbuf buf = GH_BUF_INIT; cmark_event_type ev_type; diff --git a/render.c b/render.c index d477363..2c941bf 100644 --- a/render.c +++ b/render.c @@ -23,6 +23,7 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, unsigned char nextc; int32_t c; int i = 0; + int last_nonspace; int len; cmark_chunk remainder = cmark_chunk_literal(""); int k = renderer->buffer->size - 1; @@ -63,15 +64,20 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, nextc = source[i + len]; if (c == 32 && wrap) { if (!renderer->begin_line) { + last_nonspace = renderer->buffer->size; cmark_strbuf_putc(renderer->buffer, ' '); renderer->column += 1; renderer->begin_line = false; renderer->begin_content = false; - renderer->last_breakable = renderer->buffer->size - 1; // skip following spaces while (source[i + 1] == ' ') { i++; } + // We don't allow breaks that make a digit the first character + // because this causes problems with commonmark output. + if (!cmark_isdigit(source[i + 1])) { + renderer->last_breakable = last_nonspace; + } } } else if (c == 10) { @@ -83,11 +89,17 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, } else if (escape == LITERAL) { cmark_render_code_point(renderer, c); renderer->begin_line = false; - renderer->begin_content = false; + // we don't set 'begin_content' to false til we've + // finished parsing a digit. Reason: in commonmark + // we need to escape a potential list marker after + // a digit: + renderer->begin_content = renderer->begin_content && + cmark_isdigit(c) == 1; } else { (renderer->outc)(renderer, escape, c, nextc); renderer->begin_line = false; - renderer->begin_content = false; + renderer->begin_content = renderer->begin_content && + cmark_isdigit(c) == 1; } // If adding the character went beyond width, look for an @@ -142,7 +154,7 @@ char *cmark_render(cmark_node *root, int options, int width, cmark_iter *iter = cmark_iter_new(root); cmark_renderer renderer = {&buf, &pref, 0, width, 0, 0, true, - false, false, false, + true, false, false, outc, S_cr, S_blankline, S_out}; while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { From 3026c7ac78d79db4a750b99a087d87dbcded0905 Mon Sep 17 00:00:00 2001 From: rhinoman Date: Sat, 26 Mar 2016 19:59:52 -0400 Subject: [PATCH 22/26] updated to cmark 0.25.2 --- .gitignore | 3 + .travis.yml | 2 +- blocks.c | 652 +++--- buffer.c | 5 +- chunk.h | 8 +- cmark.h | 6 +- cmark_version.h | 4 +- commonmark.c | 35 +- commonmark_test.go | 3 + config.h | 51 + html.c | 16 +- inlines.c | 22 +- latex.c | 8 +- man.c | 5 +- node.c | 4 +- node.go | 15 +- parser.h | 2 + render.c | 26 +- scanners.c | 5051 +++++++++++++++++++++----------------------- xml.c | 20 +- 20 files changed, 2993 insertions(+), 2945 deletions(-) diff --git a/.gitignore b/.gitignore index 58ce8ad..57c6d8d 100644 --- a/.gitignore +++ b/.gitignore @@ -22,3 +22,6 @@ _testmain.go #Misc junk *.swp + +.idea/ +*.iml diff --git a/.travis.yml b/.travis.yml index e810723..cddd1a2 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,8 +1,8 @@ # Travis build settings for go-commonmark language: go go: - - 1.4 - 1.5 + - 1.6 before_install: - echo "yes" | sudo add-apt-repository ppa:kalakris/cmake - sudo apt-get update -qq diff --git a/blocks.c b/blocks.c index 9f41e1f..f49ad4e 100644 --- a/blocks.c +++ b/blocks.c @@ -1,3 +1,10 @@ +/** + * Block parsing implementation. + * + * For a high-level overview of the block parsing process, + * see http://spec.commonmark.org/0.24/#phase-1-block-structure + */ + #include #include #include @@ -17,12 +24,20 @@ #define CODE_INDENT 4 #define TAB_STOP 4 +#ifndef MIN +#define MIN(x, y) ((x < y) ? x : y) +#endif + #define peek_at(i, n) (i)->data[n] -static inline bool S_is_line_end_char(char c) { +static CMARK_INLINE bool S_is_line_end_char(char c) { return (c == '\n' || c == '\r'); } +static CMARK_INLINE bool S_is_space_or_tab(char c) { + return (c == ' ' || c == '\t'); +} + static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len, bool eof); @@ -70,10 +85,12 @@ cmark_parser *cmark_parser_new(int options) { parser->first_nonspace_column = 0; parser->indent = 0; parser->blank = false; + parser->partially_consumed_tab = false; parser->curline = line; parser->last_line_length = 0; parser->linebuf = buf; parser->options = options; + parser->last_buffer_ended_with_cr = false; return parser; } @@ -110,7 +127,7 @@ static bool is_blank(cmark_strbuf *s, bufsize_t offset) { return true; } -static inline bool can_contain(cmark_node_type parent_type, +static CMARK_INLINE bool can_contain(cmark_node_type parent_type, cmark_node_type child_type) { return (parent_type == CMARK_NODE_DOCUMENT || parent_type == CMARK_NODE_BLOCK_QUOTE || @@ -118,15 +135,32 @@ static inline bool can_contain(cmark_node_type parent_type, (parent_type == CMARK_NODE_LIST && child_type == CMARK_NODE_ITEM)); } -static inline bool accepts_lines(cmark_node_type block_type) { +static CMARK_INLINE bool accepts_lines(cmark_node_type block_type) { return (block_type == CMARK_NODE_PARAGRAPH || block_type == CMARK_NODE_HEADING || block_type == CMARK_NODE_CODE_BLOCK); } -static void add_line(cmark_node *node, cmark_chunk *ch, bufsize_t offset) { +static CMARK_INLINE bool contains_inlines(cmark_node_type block_type) { + return (block_type == CMARK_NODE_PARAGRAPH || + block_type == CMARK_NODE_HEADING); +} + +static void add_line(cmark_node *node, cmark_chunk *ch, cmark_parser *parser) { + int chars_to_tab; + int i; assert(node->open); - cmark_strbuf_put(&node->string_content, ch->data + offset, ch->len - offset); + if (parser->partially_consumed_tab) { + parser->offset += 1; // skip over tab + // add space characters: + chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); + for (i = 0; i < chars_to_tab; i++) { + cmark_strbuf_putc(&node->string_content, ' '); + } + } + cmark_strbuf_put(&node->string_content, + ch->data + parser->offset, + ch->len - parser->offset); } static void remove_trailing_blank_lines(cmark_strbuf *ln) { @@ -336,8 +370,7 @@ static void process_inlines(cmark_node *root, cmark_reference_map *refmap, 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 == CMARK_NODE_PARAGRAPH || - cur->type == CMARK_NODE_HEADING) { + if (contains_inlines(cur->type)) { cmark_parse_inlines(cur, refmap, options); } } @@ -474,6 +507,11 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, const unsigned char *end = buffer + len; static const uint8_t repl[] = {239, 191, 189}; + if (parser->last_buffer_ended_with_cr && *buffer == '\n') { + // skip NL if last buffer ended with CR ; see #117 + buffer++; + } + parser->last_buffer_ended_with_cr = false; while (buffer < end) { const unsigned char *eol; bufsize_t chunk_len; @@ -514,8 +552,11 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, buffer += chunk_len; // skip over line ending characters: - if (buffer < end && *buffer == '\r') + if (buffer < end && *buffer == '\r') { buffer++; + if (buffer == end) + parser->last_buffer_ended_with_cr = true; + } if (buffer < end && *buffer == '\n') buffer++; } @@ -532,13 +573,15 @@ static void chop_trailing_hashtags(cmark_chunk *ch) { n--; // Check for a space before the final #s: - if (n != orig_n && n >= 0 && - (peek_at(ch, n) == ' ' || peek_at(ch, n) == '\t')) { + if (n != orig_n && n >= 0 && S_is_space_or_tab(peek_at(ch, n))) { ch->len = n; cmark_chunk_rtrim(ch); } } +// Find first nonspace character from current offset, setting +// parser->first_nonspace, parser->first_nonspace_column, +// parser->indent, and parser->blank. Does not advance parser->offset. static void S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input) { char c; int chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); @@ -566,17 +609,37 @@ static void S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input) { parser->blank = S_is_line_end_char(peek_at(input, parser->first_nonspace)); } +// Advance parser->offset and parser->column. parser->offset is the +// byte position in input; parser->column is a virtual column number +// that takes into account tabs. (Multibyte characters are not taken +// into account, because the Markdown line prefixes we are interested in +// analyzing are entirely ASCII.) The count parameter indicates +// how far to advance the offset. If columns is true, then count +// indicates a number of columns; otherwise, a number of bytes. +// If advancing a certain number of columns partially consumes +// a tab character, parser->partially_consumed_tab is set to true. static void S_advance_offset(cmark_parser *parser, cmark_chunk *input, bufsize_t count, bool columns) { char c; int chars_to_tab; + int chars_to_advance; while (count > 0 && (c = peek_at(input, parser->offset))) { if (c == '\t') { chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); - parser->column += chars_to_tab; - parser->offset += 1; - count -= (columns ? chars_to_tab : 1); + if (columns) { + parser->partially_consumed_tab = chars_to_tab > count; + chars_to_advance = MIN(count, chars_to_tab); + parser->column += chars_to_advance; + parser->offset += (parser->partially_consumed_tab ? 0 : 1); + count -= chars_to_advance; + } else { + parser->partially_consumed_tab = false; + parser->column += chars_to_tab; + parser->offset += 1; + count -= 1; + } } else { + parser->partially_consumed_tab = false; parser->offset += 1; parser->column += 1; // assume ascii; block starts are ascii count -= 1; @@ -584,263 +647,314 @@ static void S_advance_offset(cmark_parser *parser, cmark_chunk *input, } } -static void S_process_line(cmark_parser *parser, const unsigned char *buffer, - bufsize_t bytes) { - cmark_node *last_matched_container; +static bool S_last_child_is_open(cmark_node *container) { + return container->last_child && container->last_child->open; +} + +static bool parse_block_quote_prefix(cmark_parser *parser, + cmark_chunk *input) +{ + bool res = false; bufsize_t matched = 0; - int lev = 0; - int i; - cmark_list *data = NULL; - bool all_matched = true; - cmark_node *container; - bool indented; - cmark_chunk input; - bool maybe_lazy; - if (parser->options & CMARK_OPT_VALIDATE_UTF8) { - cmark_utf8proc_check(parser->curline, buffer, bytes); - } else { - cmark_strbuf_put(parser->curline, buffer, bytes); - } - // ensure line ends with a newline: - if (bytes == 0 || !S_is_line_end_char(parser->curline->ptr[bytes - 1])) { - cmark_strbuf_putc(parser->curline, '\n'); - } - parser->offset = 0; - parser->column = 0; - parser->blank = false; + matched = + parser->indent <= 3 && peek_at(input, parser->first_nonspace) == '>'; + if (matched) { - input.data = parser->curline->ptr; - input.len = parser->curline->size; + S_advance_offset(parser, input, parser->indent + 1, true); - // container starts at the document root. - container = parser->root; + if (S_is_space_or_tab(peek_at(input, parser->offset))) { + S_advance_offset(parser, input, 1, true); + } - parser->line_number++; + res = true; + } + return res; +} - // for each containing node, try to parse the associated line start. - // bail out on failure: container will point to the last matching node. +static bool parse_node_item_prefix(cmark_parser *parser, + cmark_chunk *input, + cmark_node *container) +{ + bool res = false; + + if (parser->indent >= + container->as.list.marker_offset + container->as.list.padding) { + S_advance_offset(parser, input, container->as.list.marker_offset + + container->as.list.padding, + true); + res = true; + } else if (parser->blank && container->first_child != NULL) { + // if container->first_child is NULL, then the opening line + // of the list item was blank after the list marker; in this + // case, we are done with the list item. + S_advance_offset(parser, input, + parser->first_nonspace - parser->offset, false); + res = true; + } + return res; +} - while (container->last_child && container->last_child->open) { - container = container->last_child; +static bool parse_code_block_prefix(cmark_parser *parser, + cmark_chunk *input, + cmark_node *container, + bool *should_continue) +{ + bool res = false; + + if (!container->as.code.fenced) { // indented + if (parser->indent >= CODE_INDENT) { + S_advance_offset(parser, input, CODE_INDENT, true); + res = true; + } else if (parser->blank) { + S_advance_offset(parser, input, + parser->first_nonspace - parser->offset, false); + res = true; + } + } else { // fenced + bufsize_t matched = 0; - S_find_first_nonspace(parser, &input); + if (parser->indent <= 3 && (peek_at(input, parser->first_nonspace) == + container->as.code.fence_char)) { + matched = scan_close_code_fence(input, parser->first_nonspace); + } - if (container->type == CMARK_NODE_BLOCK_QUOTE) { - matched = - parser->indent <= 3 && peek_at(&input, parser->first_nonspace) == '>'; - if (matched) { - S_advance_offset(parser, &input, parser->indent + 1, true); - if (peek_at(&input, parser->offset) == ' ') - parser->offset++; - } else { - all_matched = false; - } + if (matched >= container->as.code.fence_length) { + // closing fence - and since we're at + // the end of a line, we can stop processing it: + *should_continue = false; + S_advance_offset(parser, input, matched, false); + parser->current = finalize(parser, container); + } else { + // skip opt. spaces of fence parser->offset + int i = container->as.code.fence_offset; - } else if (container->type == CMARK_NODE_ITEM) { - if (parser->indent >= - container->as.list.marker_offset + container->as.list.padding) { - S_advance_offset(parser, &input, container->as.list.marker_offset + - container->as.list.padding, - true); - } else if (parser->blank && container->first_child != NULL) { - // if container->first_child is NULL, then the opening line - // of the list item was blank after the list marker; in this - // case, we are done with the list item. - S_advance_offset(parser, &input, - parser->first_nonspace - parser->offset, false); - } else { - all_matched = false; + while (i > 0 && S_is_space_or_tab(peek_at(input, parser->offset))) { + S_advance_offset(parser, input, 1, true); + i--; } + res = true; + } + } - } else if (container->type == CMARK_NODE_CODE_BLOCK) { + return res; +} - if (!container->as.code.fenced) { // indented - if (parser->indent >= CODE_INDENT) { - S_advance_offset(parser, &input, CODE_INDENT, true); - } else if (parser->blank) { - S_advance_offset(parser, &input, - parser->first_nonspace - parser->offset, false); - } else { - all_matched = false; - } - } else { // fenced - matched = 0; - if (parser->indent <= 3 && (peek_at(&input, parser->first_nonspace) == - container->as.code.fence_char)) { - matched = scan_close_code_fence(&input, parser->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; - S_advance_offset(parser, &input, matched, false); - parser->current = finalize(parser, container); - goto finished; - } else { - // skip opt. spaces of fence parser->offset - i = container->as.code.fence_offset; - while (i > 0 && peek_at(&input, parser->offset) == ' ') { - S_advance_offset(parser, &input, 1, false); - i--; - } - } - } - } else if (container->type == CMARK_NODE_HEADING) { +static bool parse_html_block_prefix(cmark_parser *parser, + cmark_node *container) +{ + bool res = false; + int html_block_type = container->as.html_block_type; + + assert(html_block_type >= 1 && html_block_type <= 7); + switch (html_block_type) { + case 1: + case 2: + case 3: + case 4: + case 5: + // these types of blocks can accept blanks + res = true; + break; + case 6: + case 7: + res = !parser->blank; + break; + } - // a heading can never contain more than one line - all_matched = false; + return res; +} - } else if (container->type == CMARK_NODE_HTML_BLOCK) { +/** + * For each containing node, try to parse the associated line start. + * + * Will not close unmatched blocks, as we may have a lazy continuation + * line -> http://spec.commonmark.org/0.24/#lazy-continuation-line + * + * Returns: The last matching node, or NULL + */ +static cmark_node *check_open_blocks(cmark_parser *parser, + cmark_chunk *input, + bool *all_matched) +{ + bool should_continue = true; + *all_matched = false; + cmark_node *container = parser->root; + cmark_node_type cont_type; + + while (S_last_child_is_open(container)) { + container = container->last_child; + cont_type = container->type; - switch (container->as.html_block_type) { - case 1: - case 2: - case 3: - case 4: - case 5: - // these types of blocks can accept blanks + S_find_first_nonspace(parser, input); + + switch (cont_type) { + case CMARK_NODE_BLOCK_QUOTE: + if (!parse_block_quote_prefix(parser, input)) + goto done; break; - case 6: - case 7: - if (parser->blank) { - all_matched = false; - } + case CMARK_NODE_ITEM: + if (!parse_node_item_prefix(parser, input, container)) + goto done; + break; + case CMARK_NODE_CODE_BLOCK: + if (!parse_code_block_prefix(parser, input, container, &should_continue)) + goto done; + break; + case CMARK_NODE_HEADING: + // a heading can never contain more than one line + goto done; + case CMARK_NODE_HTML_BLOCK: + if (!parse_html_block_prefix(parser, container)) + goto done; + break; + case CMARK_NODE_PARAGRAPH: + if (parser->blank) + goto done; break; default: - fprintf(stderr, "Error (%s:%d): Unknown HTML block type %d\n", __FILE__, - __LINE__, container->as.html_block_type); - exit(1); - } + break; + } + } - } else if (container->type == CMARK_NODE_PARAGRAPH) { + *all_matched = true; - if (parser->blank) { - all_matched = false; - } - } +done: + if (!*all_matched) { + container = container->parent; // back up to last matching node + } - if (!all_matched) { - container = container->parent; // back up to last matching node - break; - } + if (!should_continue) { + container = NULL; } - last_matched_container = container; + return container; +} - // check to see if we've hit 2nd blank line, break out of list: - if (parser->blank && container->last_line_blank) { - break_out_of_lists(parser, &container); - } +static void open_new_blocks(cmark_parser *parser, + cmark_node **container, + cmark_chunk *input, + bool all_matched) +{ + bool indented; + cmark_list *data = NULL; + bool maybe_lazy = parser->current->type == CMARK_NODE_PARAGRAPH; + cmark_node_type cont_type = (*container)->type; + bufsize_t matched = 0; + int lev = 0; + bool save_partially_consumed_tab; + int save_offset; + int save_column; - maybe_lazy = parser->current->type == CMARK_NODE_PARAGRAPH; - // try new container starts: - while (container->type != CMARK_NODE_CODE_BLOCK && - container->type != CMARK_NODE_HTML_BLOCK) { + while (cont_type != CMARK_NODE_CODE_BLOCK && + cont_type != CMARK_NODE_HTML_BLOCK) { - S_find_first_nonspace(parser, &input); + S_find_first_nonspace(parser, input); indented = parser->indent >= CODE_INDENT; - if (!indented && peek_at(&input, parser->first_nonspace) == '>') { + if (!indented && peek_at(input, parser->first_nonspace) == '>') { - S_advance_offset(parser, &input, + S_advance_offset(parser, input, parser->first_nonspace + 1 - parser->offset, false); // optional following character - if (peek_at(&input, parser->offset) == ' ') - S_advance_offset(parser, &input, 1, false); - container = add_child(parser, container, CMARK_NODE_BLOCK_QUOTE, + if (S_is_space_or_tab(peek_at(input, parser->offset))) { + S_advance_offset(parser, input, 1, true); + } + *container = add_child(parser, *container, CMARK_NODE_BLOCK_QUOTE, parser->offset + 1); } else if (!indented && (matched = scan_atx_heading_start( - &input, parser->first_nonspace))) { + input, parser->first_nonspace))) { + bufsize_t hashpos; + int level = 0; - S_advance_offset(parser, &input, + S_advance_offset(parser, input, parser->first_nonspace + matched - parser->offset, false); - container = - add_child(parser, container, CMARK_NODE_HEADING, parser->offset + 1); + *container = + add_child(parser, *container, CMARK_NODE_HEADING, parser->offset + 1); - bufsize_t hashpos = - cmark_chunk_strchr(&input, '#', parser->first_nonspace); - int level = 0; + hashpos = cmark_chunk_strchr(input, '#', parser->first_nonspace); - while (peek_at(&input, hashpos) == '#') { + while (peek_at(input, hashpos) == '#') { level++; hashpos++; } - container->as.heading.level = level; - container->as.heading.setext = false; - } else if (!indented && (matched = scan_open_code_fence( - &input, parser->first_nonspace))) { + (*container)->as.heading.level = level; + (*container)->as.heading.setext = false; - container = add_child(parser, container, CMARK_NODE_CODE_BLOCK, + } else if (!indented && (matched = scan_open_code_fence( + input, parser->first_nonspace))) { + *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK, parser->first_nonspace + 1); - container->as.code.fenced = true; - container->as.code.fence_char = peek_at(&input, parser->first_nonspace); - container->as.code.fence_length = matched; - container->as.code.fence_offset = + (*container)->as.code.fenced = true; + (*container)->as.code.fence_char = peek_at(input, parser->first_nonspace); + (*container)->as.code.fence_length = matched; + (*container)->as.code.fence_offset = (int8_t)(parser->first_nonspace - parser->offset); - container->as.code.info = cmark_chunk_literal(""); - S_advance_offset(parser, &input, + (*container)->as.code.info = cmark_chunk_literal(""); + S_advance_offset(parser, input, parser->first_nonspace + matched - parser->offset, false); } else if (!indented && ((matched = scan_html_block_start( - &input, parser->first_nonspace)) || - (container->type != CMARK_NODE_PARAGRAPH && + input, parser->first_nonspace)) || + (cont_type != CMARK_NODE_PARAGRAPH && (matched = scan_html_block_start_7( - &input, parser->first_nonspace))))) { - - container = add_child(parser, container, CMARK_NODE_HTML_BLOCK, + input, parser->first_nonspace))))) { + *container = add_child(parser, *container, CMARK_NODE_HTML_BLOCK, parser->first_nonspace + 1); - container->as.html_block_type = matched; + (*container)->as.html_block_type = matched; // note, we don't adjust parser->offset because the tag is part of the // text - - } else if (!indented && container->type == CMARK_NODE_PARAGRAPH && + } else if (!indented && cont_type == CMARK_NODE_PARAGRAPH && (lev = - scan_setext_heading_line(&input, parser->first_nonspace))) { - - container->type = CMARK_NODE_HEADING; - container->as.heading.level = lev; - container->as.heading.setext = true; - S_advance_offset(parser, &input, input.len - 1 - parser->offset, false); - + scan_setext_heading_line(input, parser->first_nonspace))) { + (*container)->type = CMARK_NODE_HEADING; + (*container)->as.heading.level = lev; + (*container)->as.heading.setext = true; + S_advance_offset(parser, input, input->len - 1 - parser->offset, false); } else if (!indented && - !(container->type == CMARK_NODE_PARAGRAPH && !all_matched) && + !(cont_type == CMARK_NODE_PARAGRAPH && !all_matched) && (matched = - scan_thematic_break(&input, parser->first_nonspace))) { - + scan_thematic_break(input, parser->first_nonspace))) { // it's only now that we know the line is not part of a setext heading: - container = add_child(parser, container, CMARK_NODE_THEMATIC_BREAK, + *container = add_child(parser, *container, CMARK_NODE_THEMATIC_BREAK, parser->first_nonspace + 1); - S_advance_offset(parser, &input, input.len - 1 - parser->offset, false); - + S_advance_offset(parser, input, input->len - 1 - parser->offset, false); } else if ((matched = - parse_list_marker(&input, parser->first_nonspace, &data)) && - (!indented || container->type == CMARK_NODE_LIST)) { + parse_list_marker(input, parser->first_nonspace, &data)) && + (!indented || cont_type == CMARK_NODE_LIST)) { // Note that we can have new list items starting with >= 4 // spaces indent, as long as the list container is still open. + int i = 0; // compute padding: - S_advance_offset(parser, &input, + S_advance_offset(parser, input, parser->first_nonspace + matched - parser->offset, false); - i = 0; - while (i <= 5 && peek_at(&input, parser->offset + i) == ' ') { - i++; + + save_partially_consumed_tab = parser->partially_consumed_tab; + save_offset = parser->offset; + save_column = parser->column; + + while (parser->column - save_column <= 5 && + S_is_space_or_tab(peek_at(input, parser->offset))) { + S_advance_offset(parser, input, 1, true); } - // i = number of spaces after marker, up to 5 - if (i >= 5 || i < 1 || - S_is_line_end_char(peek_at(&input, parser->offset))) { + + i = parser->column - save_column; + if (i >= 5 || i < 1) { data->padding = matched + 1; + parser->offset = save_offset; + parser->column = save_column; + parser->partially_consumed_tab = save_partially_consumed_tab; if (i > 0) { - S_advance_offset(parser, &input, 1, false); + S_advance_offset(parser, input, 1, true); } } else { data->padding = matched + i; - S_advance_offset(parser, &input, i, true); } // check container; if it's a list, see if this list item @@ -848,50 +962,57 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, data->marker_offset = parser->indent; - if (container->type != CMARK_NODE_LIST || - !lists_match(&container->as.list, data)) { - container = add_child(parser, container, CMARK_NODE_LIST, + if (cont_type != CMARK_NODE_LIST || + !lists_match(&((*container)->as.list), data)) { + *container = add_child(parser, *container, CMARK_NODE_LIST, parser->first_nonspace + 1); - memcpy(&container->as.list, data, sizeof(*data)); + memcpy(&((*container)->as.list), data, sizeof(*data)); } // add the list item - container = add_child(parser, container, CMARK_NODE_ITEM, + *container = add_child(parser, *container, CMARK_NODE_ITEM, parser->first_nonspace + 1); /* TODO: static */ - memcpy(&container->as.list, data, sizeof(*data)); + memcpy(&((*container)->as.list), data, sizeof(*data)); free(data); - } else if (indented && !maybe_lazy && !parser->blank) { - S_advance_offset(parser, &input, CODE_INDENT, true); - container = add_child(parser, container, CMARK_NODE_CODE_BLOCK, + S_advance_offset(parser, input, CODE_INDENT, true); + *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK, parser->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(""); + (*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 { break; } - if (accepts_lines(container->type)) { + if (accepts_lines((*container)->type)) { // if it's a line container, it can't contain other containers break; } + + cont_type = (*container)->type; maybe_lazy = false; } +} +static void add_text_to_container (cmark_parser *parser, + cmark_node *container, + cmark_node *last_matched_container, + cmark_chunk *input) +{ + cmark_node *tmp; // what remains at parser->offset is a text line. add the text to the // appropriate container. - S_find_first_nonspace(parser, &input); + S_find_first_nonspace(parser, input); - if (parser->blank && container->last_child) { + if (parser->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 @@ -906,61 +1027,61 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, !(container->type == CMARK_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; + tmp = container; + while (tmp->parent) { + tmp->parent->last_line_blank = false; + tmp = tmp->parent; } + // If the last line processed belonged to a paragraph node, + // and we didn't match all of the line prefixes for the open containers, + // and we didn't start any new containers, + // and the line isn't blank, + // then treat this as a "lazy continuation line" and add it to + // the open paragraph. if (parser->current != last_matched_container && - container == last_matched_container && !parser->blank && - parser->current->type == CMARK_NODE_PARAGRAPH && - cmark_strbuf_len(&parser->current->string_content) > 0) { - - add_line(parser->current, &input, parser->offset); - + container == last_matched_container && + !parser->blank && + parser->current->type == CMARK_NODE_PARAGRAPH) { + add_line(parser->current, input, parser); } else { // not a lazy continuation - - // finalize any blocks that were not matched and set cur to container: + // 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 == CMARK_NODE_CODE_BLOCK) { - - add_line(container, &input, parser->offset); - + add_line(container, input, parser); } else if (container->type == CMARK_NODE_HTML_BLOCK) { - - add_line(container, &input, parser->offset); + add_line(container, input, parser); int matches_end_condition; switch (container->as.html_block_type) { case 1: // , , matches_end_condition = - scan_html_block_end_1(&input, parser->first_nonspace); + scan_html_block_end_1(input, parser->first_nonspace); break; case 2: // --> matches_end_condition = - scan_html_block_end_2(&input, parser->first_nonspace); + scan_html_block_end_2(input, parser->first_nonspace); break; case 3: // ?> matches_end_condition = - scan_html_block_end_3(&input, parser->first_nonspace); + scan_html_block_end_3(input, parser->first_nonspace); break; case 4: // > matches_end_condition = - scan_html_block_end_4(&input, parser->first_nonspace); + scan_html_block_end_4(input, parser->first_nonspace); break; case 5: // ]]> matches_end_condition = - scan_html_block_end_5(&input, parser->first_nonspace); + scan_html_block_end_5(input, parser->first_nonspace); break; default: matches_end_condition = 0; @@ -971,28 +1092,69 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, container = finalize(parser, container); assert(parser->current != NULL); } - } else if (parser->blank) { - // ??? do nothing - } else if (accepts_lines(container->type)) { - if (container->type == CMARK_NODE_HEADING && container->as.heading.setext == false) { - chop_trailing_hashtags(&input); + chop_trailing_hashtags(input); } - add_line(container, &input, parser->first_nonspace); - + S_advance_offset(parser, input, parser->first_nonspace - parser->offset, false); + add_line(container, input, parser); } else { // create paragraph container for line container = add_child(parser, container, CMARK_NODE_PARAGRAPH, parser->first_nonspace + 1); - add_line(container, &input, parser->first_nonspace); + S_advance_offset(parser, input, parser->first_nonspace - parser->offset, false); + add_line(container, input, parser); } parser->current = container; } +} + +/* See http://spec.commonmark.org/0.24/#phase-1-block-structure */ +static void S_process_line(cmark_parser *parser, const unsigned char *buffer, + bufsize_t bytes) { + cmark_node *last_matched_container; + bool all_matched = true; + cmark_node *container; + cmark_chunk input; + + if (parser->options & CMARK_OPT_VALIDATE_UTF8) + cmark_utf8proc_check(parser->curline, buffer, bytes); + else + cmark_strbuf_put(parser->curline, buffer, bytes); + + // ensure line ends with a newline: + if (bytes == 0 || !S_is_line_end_char(parser->curline->ptr[bytes - 1])) + cmark_strbuf_putc(parser->curline, '\n'); + + parser->offset = 0; + parser->column = 0; + parser->blank = false; + parser->partially_consumed_tab = false; + + input.data = parser->curline->ptr; + input.len = parser->curline->size; + + parser->line_number++; + + last_matched_container = check_open_blocks(parser, &input, &all_matched); + + if (!last_matched_container) + goto finished; + + container = last_matched_container; + + // check to see if we've hit 2nd blank line, break out of list: + if (parser->blank && container->last_line_blank) + break_out_of_lists(parser, &container); + + open_new_blocks(parser, &container, &input, all_matched); + + add_text_to_container(parser, container, last_matched_container, &input); + finished: parser->last_line_length = input.len; if (parser->last_line_length && diff --git a/buffer.c b/buffer.c index a89c82e..4efa97b 100644 --- a/buffer.c +++ b/buffer.c @@ -33,7 +33,7 @@ void cmark_strbuf_overflow_err() { abort(); } -static inline void S_strbuf_grow_by(cmark_strbuf *buf, size_t add) { +static CMARK_INLINE void S_strbuf_grow_by(cmark_strbuf *buf, size_t add) { size_t target_size = (size_t)buf->size + add; if (target_size < add /* Integer overflow. */ @@ -217,7 +217,8 @@ bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos) { if (pos >= buf->size) pos = buf->size - 1; - for (bufsize_t i = pos; i >= 0; i--) { + bufsize_t i; + for (i = pos; i >= 0; i--) { if (buf->ptr[i] == (unsigned char)c) return i; } diff --git a/chunk.h b/chunk.h index 7007492..b25831b 100644 --- a/chunk.h +++ b/chunk.h @@ -48,8 +48,8 @@ static CMARK_INLINE void cmark_chunk_trim(cmark_chunk *c) { cmark_chunk_rtrim(c); } -static CMARK_INLINE bufsize_t - cmark_chunk_strchr(cmark_chunk *ch, int c, bufsize_t offset) { +static CMARK_INLINE bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c, + bufsize_t offset) { const unsigned char *p = (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); return p ? (bufsize_t)(p - ch->data) : ch->len; @@ -96,8 +96,8 @@ static CMARK_INLINE cmark_chunk cmark_chunk_literal(const char *data) { return c; } -static CMARK_INLINE cmark_chunk - cmark_chunk_dup(const cmark_chunk *ch, bufsize_t pos, bufsize_t len) { +static CMARK_INLINE cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, + bufsize_t pos, bufsize_t len) { cmark_chunk c = {ch->data + pos, len, 0}; return c; } diff --git a/cmark.h b/cmark.h index d0f1953..7deaf31 100644 --- a/cmark.h +++ b/cmark.h @@ -20,7 +20,7 @@ extern "C" { */ /** Convert 'text' (assumed to be a UTF-8 encoded string with length - * 'len' from CommonMark Markdown to HTML, returning a null-terminated, + * 'len') from CommonMark Markdown to HTML, returning a null-terminated, * UTF-8-encoded string. */ CMARK_EXPORT @@ -96,7 +96,7 @@ typedef struct cmark_iter cmark_iter; */ CMARK_EXPORT cmark_node *cmark_node_new(cmark_node_type type); -/** Frees the memory allocated for a node. +/** Frees the memory allocated for a node and any children. */ CMARK_EXPORT void cmark_node_free(cmark_node *node); @@ -418,7 +418,7 @@ CMARK_EXPORT void cmark_consolidate_text_nodes(cmark_node *root); * Streaming interface: * * cmark_parser *parser = cmark_parser_new(CMARK_OPT_DEFAULT); - * FILE *fp = fopen("myfile.md", "r"); + * FILE *fp = fopen("myfile.md", "rb"); * while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { * cmark_parser_feed(parser, buffer, bytes); * if (bytes < sizeof(buffer)) { diff --git a/cmark_version.h b/cmark_version.h index a56570f..5e873b2 100644 --- a/cmark_version.h +++ b/cmark_version.h @@ -1,7 +1,7 @@ #ifndef CMARK_VERSION_H #define CMARK_VERSION_H -#define CMARK_VERSION ((0 << 16) | (24 << 8) | 1) -#define CMARK_VERSION_STRING "0.24.1" +#define CMARK_VERSION ((0 << 16) | (25 << 8) | 2) +#define CMARK_VERSION_STRING "0.25.2" #endif diff --git a/commonmark.c b/commonmark.c index 751a5df..f5a352d 100644 --- a/commonmark.c +++ b/commonmark.c @@ -17,15 +17,18 @@ #define LIT(s) renderer->out(renderer, s, false, LITERAL) #define CR() renderer->cr(renderer) #define BLANKLINE() renderer->blankline(renderer) +#define ENCODED_SIZE 20 +#define LISTMARKER_SIZE 20 // Functions to convert cmark_nodes to commonmark strings. -static inline void outc(cmark_renderer *renderer, cmark_escaping escape, +static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape, int32_t c, unsigned char nextc) { bool needs_escaping = false; - char encoded[20]; - bool follows_digit = renderer->buffer->size > 0 && - cmark_isdigit(renderer->buffer->ptr[renderer->buffer->size - 1]); + bool follows_digit = + renderer->buffer->size > 0 && + cmark_isdigit(renderer->buffer->ptr[renderer->buffer->size - 1]); + char encoded[ENCODED_SIZE]; needs_escaping = escape != LITERAL && @@ -34,11 +37,11 @@ static inline void outc(cmark_renderer *renderer, cmark_escaping escape, c == '>' || c == '\\' || c == '`' || c == '!' || (c == '&' && isalpha(nextc)) || (c == '!' && nextc == '[') || (renderer->begin_content && (c == '-' || c == '+' || c == '=') && - // begin_content doesn't get set to false til we've passed digits - // at the beginning of line, so... - !follows_digit) || + // begin_content doesn't get set to false til we've passed digits + // at the beginning of line, so... + !follows_digit) || (renderer->begin_content && (c == '.' || c == ')') && follows_digit && - (nextc == 0 || cmark_isspace(nextc))))) || + (nextc == 0 || cmark_isspace(nextc))))) || (escape == URL && (c == '`' || c == '<' || c == '>' || isspace(c) || c == '\\' || c == ')' || c == '(')) || (escape == TITLE && @@ -47,7 +50,7 @@ static inline void outc(cmark_renderer *renderer, cmark_escaping escape, if (needs_escaping) { if (isspace(c)) { // use percent encoding for spaces - sprintf(encoded, "%%%2x", c); + snprintf(encoded, ENCODED_SIZE, "%%%2x", c); cmark_strbuf_puts(renderer->buffer, encoded); renderer->column += 3; } else { @@ -166,7 +169,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, bool entering = (ev_type == CMARK_EVENT_ENTER); const char *info, *code, *title; size_t info_len, code_len; - char listmarker[20]; + char listmarker[LISTMARKER_SIZE]; char *emph_delim; bufsize_t marker_width; @@ -176,7 +179,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && entering)) { tmp = get_containing_block(node); renderer->in_tight_list_item = - tmp && // tmp might be NULL if there is no containing block + tmp && // tmp might be NULL if there is no containing block ((tmp->type == CMARK_NODE_ITEM && cmark_node_get_list_tight(tmp->parent)) || (tmp && tmp->parent && tmp->parent->type == CMARK_NODE_ITEM && @@ -223,9 +226,9 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, // we ensure a width of at least 4 so // we get nice transition from single digits // to double - sprintf(listmarker, "%d%s%s", list_number, - list_delim == CMARK_PAREN_DELIM ? ")" : ".", - list_number < 10 ? " " : " "); + snprintf(listmarker, LISTMARKER_SIZE, "%d%s%s", list_number, + list_delim == CMARK_PAREN_DELIM ? ")" : ".", + list_number < 10 ? " " : " "); marker_width = safe_strlen(listmarker); } if (entering) { @@ -270,8 +273,8 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, // begin or end with a blank line, and code isn't // first thing in a list item if (info_len == 0 && - (code_len > 2 && !isspace(code[0]) && - !(isspace(code[code_len - 1]) && isspace(code[code_len - 2]))) && + (code_len > 2 && !isspace((unsigned char)code[0]) && + !(isspace((unsigned char)code[code_len - 1]) && isspace((unsigned char)code[code_len - 2]))) && !(node->prev == NULL && node->parent && node->parent->type == CMARK_NODE_ITEM)) { LIT(" "); diff --git a/commonmark_test.go b/commonmark_test.go index 0d649e1..8f112c5 100644 --- a/commonmark_test.go +++ b/commonmark_test.go @@ -171,6 +171,9 @@ func TestCMarkNodeOps(t *testing.T) { root.SetNodeUserData("STRING!") x := root.GetNodeUserData() t.Logf("X: %v", x) + if x != "STRING!"{ + t.Error("NodeUserData is wrong!") + } //header2.Free() root.Free() } diff --git a/config.h b/config.h index 2af3403..d38c7c7 100644 --- a/config.h +++ b/config.h @@ -1,3 +1,10 @@ +#ifndef CMARK_CONFIG_H +#define CMARK_CONFIG_H + +#ifdef __cplusplus +extern "C" { +#endif + #define HAVE_STDBOOL_H #ifdef HAVE_STDBOOL_H @@ -23,3 +30,47 @@ #define CMARK_INLINE inline #endif #endif + +/* snprintf and vsnprintf fallbacks for MSVC before 2015, + due to Valentin Milea http://stackoverflow.com/questions/2915672/ +*/ + +#if defined(_MSC_VER) && _MSC_VER < 1900 + +#include +#include + +#define snprintf c99_snprintf +#define vsnprintf c99_vsnprintf + +CMARK_INLINE int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap) +{ + int count = -1; + + if (size != 0) + count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap); + if (count == -1) + count = _vscprintf(format, ap); + + return count; +} + +CMARK_INLINE int c99_snprintf(char *outBuf, size_t size, const char *format, ...) +{ + int count; + va_list ap; + + va_start(ap, format); + count = c99_vsnprintf(outBuf, size, format, ap); + va_end(ap); + + return count; +} + +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/html.c b/html.c index 54f27ba..9ffa08a 100644 --- a/html.c +++ b/html.c @@ -10,6 +10,8 @@ #include "houdini.h" #include "scanners.h" +#define BUFFER_SIZE 100 + // Functions to convert cmark_nodes to HTML strings. static void escape_html(cmark_strbuf *dest, const unsigned char *source, @@ -17,7 +19,7 @@ static void escape_html(cmark_strbuf *dest, const unsigned char *source, houdini_escape_html0(dest, source, length, 0); } -static inline void cr(cmark_strbuf *html) { +static CMARK_INLINE void cr(cmark_strbuf *html) { if (html->size && html->ptr[html->size - 1] != '\n') cmark_strbuf_putc(html, '\n'); } @@ -29,11 +31,11 @@ struct render_state { static void S_render_sourcepos(cmark_node *node, cmark_strbuf *html, int options) { - char buffer[100]; + char buffer[BUFFER_SIZE]; if (CMARK_OPT_SOURCEPOS & options) { - sprintf(buffer, " 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)); + snprintf(buffer, BUFFER_SIZE, " 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)); cmark_strbuf_puts(html, buffer); } } @@ -46,7 +48,7 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, char start_heading[] = "\n"); } else { - sprintf(buffer, "
    \n"); diff --git a/inlines.c b/inlines.c index 1199831..8ff8131 100644 --- a/inlines.c +++ b/inlines.c @@ -48,7 +48,7 @@ typedef struct { delimiter *last_delim; } subject; -static inline bool S_is_line_end_char(char c) { +static CMARK_INLINE bool S_is_line_end_char(char c) { return (c == '\n' || c == '\r'); } @@ -62,7 +62,7 @@ static void subject_from_buf(subject *e, cmark_strbuf *buffer, static bufsize_t subject_find_special_char(subject *subj, int options); // Create an inline with a literal string value. -static inline cmark_node *make_literal(cmark_node_type t, cmark_chunk s) { +static CMARK_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; @@ -81,7 +81,7 @@ static inline cmark_node *make_literal(cmark_node_type t, cmark_chunk s) { } // Create an inline with no value. -static inline cmark_node *make_simple(cmark_node_type t) { +static CMARK_INLINE cmark_node *make_simple(cmark_node_type t) { cmark_node *e = (cmark_node *)calloc(1, sizeof(*e)); if (e != NULL) { e->type = t; @@ -141,7 +141,7 @@ static cmark_chunk cmark_clean_autolink(cmark_chunk *url, int is_email) { return cmark_chunk_buf_detach(&buf); } -static inline cmark_node *make_autolink(cmark_chunk url, int is_email) { +static CMARK_INLINE cmark_node *make_autolink(cmark_chunk url, int is_email) { cmark_node *link = make_simple(CMARK_NODE_LINK); link->as.link.url = cmark_clean_autolink(&url, is_email); link->as.link.title = cmark_chunk_literal(""); @@ -159,28 +159,28 @@ static void subject_from_buf(subject *e, cmark_strbuf *buffer, e->last_delim = NULL; } -static inline int isbacktick(int c) { return (c == '`'); } +static CMARK_INLINE int isbacktick(int c) { return (c == '`'); } -static inline unsigned char peek_char(subject *subj) { +static CMARK_INLINE unsigned char peek_char(subject *subj) { // NULL bytes should have been stripped out by now. If they're // present, it's a programming error: assert(!(subj->pos < subj->input.len && subj->input.data[subj->pos] == 0)); return (subj->pos < subj->input.len) ? subj->input.data[subj->pos] : 0; } -static inline unsigned char peek_at(subject *subj, bufsize_t pos) { +static CMARK_INLINE unsigned char peek_at(subject *subj, bufsize_t pos) { return subj->input.data[pos]; } // Return true if there are more characters in the subject. -static inline int is_eof(subject *subj) { +static CMARK_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 -static inline bool skip_spaces(subject *subj) { +static CMARK_INLINE bool skip_spaces(subject *subj) { bool skipped = false; while (peek_char(subj) == ' ' || peek_char(subj) == '\t') { advance(subj); @@ -189,7 +189,7 @@ static inline bool skip_spaces(subject *subj) { return skipped; } -static inline bool skip_line_end(subject *subj) { +static CMARK_INLINE bool skip_line_end(subject *subj) { bool seen_line_end_char = false; if (peek_char(subj) == '\r') { advance(subj); @@ -203,7 +203,7 @@ static inline bool skip_line_end(subject *subj) { } // Take characters while a predicate holds, and return a string. -static inline cmark_chunk take_while(subject *subj, int (*f)(int)) { +static CMARK_INLINE cmark_chunk take_while(subject *subj, int (*f)(int)) { unsigned char c; bufsize_t startpos = subj->pos; bufsize_t len = 0; diff --git a/latex.c b/latex.c index 57d474c..cd2f6f3 100644 --- a/latex.c +++ b/latex.c @@ -17,8 +17,9 @@ #define LIT(s) renderer->out(renderer, s, false, LITERAL) #define CR() renderer->cr(renderer) #define BLANKLINE() renderer->blankline(renderer) +#define LIST_NUMBER_STRING_SIZE 20 -static inline void outc(cmark_renderer *renderer, cmark_escaping escape, +static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape, int32_t c, unsigned char nextc) { if (escape == LITERAL) { cmark_render_code_point(renderer, c); @@ -217,7 +218,7 @@ static int S_get_enumlevel(cmark_node *node) { static int S_render_node(cmark_renderer *renderer, cmark_node *node, cmark_event_type ev_type, int options) { int list_number; - char list_number_string[20]; + char list_number_string[LIST_NUMBER_STRING_SIZE]; bool entering = (ev_type == CMARK_EVENT_ENTER); cmark_list_type list_type; const char *roman_numerals[] = {"", "i", "ii", "iii", "iv", "v", @@ -249,7 +250,8 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, CR(); list_number = cmark_node_get_list_start(node); if (list_number > 1) { - sprintf(list_number_string, "%d", list_number); + snprintf(list_number_string, LIST_NUMBER_STRING_SIZE, "%d", + list_number); LIT("\\setcounter{enum"); LIT((char *)roman_numerals[S_get_enumlevel(node)]); LIT("}{"); diff --git a/man.c b/man.c index 99a2803..3d8bc20 100644 --- a/man.c +++ b/man.c @@ -14,6 +14,7 @@ #define LIT(s) renderer->out(renderer, s, false, LITERAL) #define CR() renderer->cr(renderer) #define BLANKLINE() renderer->blankline(renderer) +#define LIST_NUMBER_SIZE 20 // Functions to convert cmark_nodes to groff man strings. static void S_outc(cmark_renderer *renderer, cmark_escaping escape, int32_t c, @@ -110,8 +111,8 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, tmp = tmp->prev; list_number += 1; } - char list_number_s[20]; - sprintf(list_number_s, "\"%d.\" 4", list_number); + char list_number_s[LIST_NUMBER_SIZE]; + snprintf(list_number_s, LIST_NUMBER_SIZE, "\"%d.\" 4", list_number); LIT(list_number_s); } CR(); diff --git a/node.c b/node.c index 26a8e25..00edbb1 100644 --- a/node.c +++ b/node.c @@ -6,7 +6,7 @@ static void S_node_unlink(cmark_node *node); -static inline bool S_is_block(cmark_node *node) { +static CMARK_INLINE bool S_is_block(cmark_node *node) { if (node == NULL) { return false; } @@ -14,7 +14,7 @@ static inline bool S_is_block(cmark_node *node) { node->type <= CMARK_NODE_LAST_BLOCK; } -static inline bool S_is_inline(cmark_node *node) { +static CMARK_INLINE bool S_is_inline(cmark_node *node) { if (node == NULL) { return false; } diff --git a/node.go b/node.go index 2df07cc..a7b05dd 100644 --- a/node.go +++ b/node.go @@ -2,6 +2,7 @@ package commonmark /* #include +#include #include "cmark.h" */ import "C" @@ -182,16 +183,18 @@ func (node *CMarkNode) LastChild() *CMarkNode { //Accessor functions -//Sets arbiturary user data for node -func (node *CMarkNode) SetNodeUserData(userData interface{}) bool { - return success(C.cmark_node_set_user_data(node.node, - unsafe.Pointer(&userData))) +//Sets arbitrary user data for node +func (node *CMarkNode) SetNodeUserData(userData string) bool { + cstr := C.CString(userData) + res := C.cmark_node_set_user_data(node.node, unsafe.Pointer(&cstr)) + return success(res) } //Returns the user data of the node as an //unsafe.Pointer. Hope you know what you're doing. -func (node *CMarkNode) GetNodeUserData() interface{} { - return C.cmark_node_get_user_data(node.node) +func (node *CMarkNode) GetNodeUserData() string { + data := C.cmark_node_get_user_data(node.node) + return C.GoString((*C.char)(*(*unsafe.Pointer)(data))) } //Get the node type diff --git a/parser.h b/parser.h index f359e10..ab21d0f 100644 --- a/parser.h +++ b/parser.h @@ -22,10 +22,12 @@ struct cmark_parser { bufsize_t first_nonspace_column; int indent; bool blank; + bool partially_consumed_tab; cmark_strbuf *curline; bufsize_t last_line_length; cmark_strbuf *linebuf; int options; + bool last_buffer_ended_with_cr; }; #ifdef __cplusplus diff --git a/render.c b/render.c index 2c941bf..50f03e6 100644 --- a/render.c +++ b/render.c @@ -5,13 +5,13 @@ #include "utf8.h" #include "render.h" -static inline void S_cr(cmark_renderer *renderer) { +static CMARK_INLINE void S_cr(cmark_renderer *renderer) { if (renderer->need_cr < 1) { renderer->need_cr = 1; } } -static inline void S_blankline(cmark_renderer *renderer) { +static CMARK_INLINE void S_blankline(cmark_renderer *renderer) { if (renderer->need_cr < 2) { renderer->need_cr = 2; } @@ -64,7 +64,7 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, nextc = source[i + len]; if (c == 32 && wrap) { if (!renderer->begin_line) { - last_nonspace = renderer->buffer->size; + last_nonspace = renderer->buffer->size; cmark_strbuf_putc(renderer->buffer, ' '); renderer->column += 1; renderer->begin_line = false; @@ -73,11 +73,11 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, while (source[i + 1] == ' ') { i++; } - // We don't allow breaks that make a digit the first character - // because this causes problems with commonmark output. - if (!cmark_isdigit(source[i + 1])) { + // We don't allow breaks that make a digit the first character + // because this causes problems with commonmark output. + if (!cmark_isdigit(source[i + 1])) { renderer->last_breakable = last_nonspace; - } + } } } else if (c == 10) { @@ -93,13 +93,13 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, // finished parsing a digit. Reason: in commonmark // we need to escape a potential list marker after // a digit: - renderer->begin_content = renderer->begin_content && - cmark_isdigit(c) == 1; + renderer->begin_content = + renderer->begin_content && cmark_isdigit(c) == 1; } else { (renderer->outc)(renderer, escape, c, nextc); renderer->begin_line = false; - renderer->begin_content = renderer->begin_content && - cmark_isdigit(c) == 1; + renderer->begin_content = + renderer->begin_content && cmark_isdigit(c) == 1; } // If adding the character went beyond width, look for an @@ -153,8 +153,8 @@ char *cmark_render(cmark_node *root, int options, int width, char *result; cmark_iter *iter = cmark_iter_new(root); - cmark_renderer renderer = {&buf, &pref, 0, width, 0, 0, true, - true, false, false, + cmark_renderer renderer = {&buf, &pref, 0, width, 0, + 0, true, true, false, false, outc, S_cr, S_blankline, S_out}; while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { diff --git a/scanners.c b/scanners.c index 28821ba..712093c 100644 --- a/scanners.c +++ b/scanners.c @@ -1,4 +1,4 @@ -/* Generated by re2c 0.14.3 */ +/* Generated by re2c 0.15.3 */ #include #include "chunk.h" #include "scanners.h" @@ -28,7 +28,6 @@ bufsize_t _scan_scheme(const unsigned char *p) { { unsigned char yych; - yych = *(marker = p); if (yych <= 0x7F) { if (yych <= ' ') { @@ -2074,14 +2073,14 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy119; + goto yy120; } else { if (yych <= '/') goto yy107; - if (yych <= '9') - goto yy119; - goto yy107; + if (yych >= ':') + goto yy107; } } else { if (yych <= 'Z') { @@ -2089,48 +2088,26 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy119; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy119; - goto yy107; - } - } - yych = *++p; - if (yych <= '9') { - if (yych == '-') - goto yy247; - if (yych <= '/') - goto yy107; - goto yy248; - } else { - if (yych <= 'Z') { - if (yych <= '@') - goto yy107; - goto yy248; - } else { - if (yych <= '`') + if (yych >= '{') goto yy107; - if (yych <= 'z') - goto yy248; - goto yy107; } } - yy119: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; if (yych <= '-') - goto yy247; + goto yy248; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy248; + goto yy247; goto yy107; } } else { @@ -2139,12 +2116,33 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; + goto yy247; + } else { + if (yych <= '`') + goto yy107; + if (yych <= 'z') + goto yy247; + goto yy107; + } + } + yy119: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy248; + if (yych <= '/') + goto yy107; + goto yy247; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy107; + goto yy247; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy248; + goto yy247; goto yy107; } } @@ -2176,14 +2174,14 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy125; + goto yy120; } else { if (yych <= '/') goto yy107; - if (yych <= '9') - goto yy125; - goto yy107; + if (yych >= ':') + goto yy107; } } else { if (yych <= 'Z') { @@ -2191,50 +2189,27 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy125; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy125; - goto yy107; - } - } - ++p; - yych = *p; - if (yych <= '9') { - if (yych == '-') - goto yy126; - if (yych <= '/') - goto yy107; - goto yy127; - } else { - if (yych <= 'Z') { - if (yych <= '@') - goto yy107; - goto yy127; - } else { - if (yych <= '`') + if (yych >= '{') goto yy107; - if (yych <= 'z') - goto yy127; - goto yy107; } } - yy125: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy127; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy127; + goto yy126; goto yy107; } } else { @@ -2243,51 +2218,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy127; + goto yy126; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy127; + goto yy126; goto yy107; } } - yy126: + yy125: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy128; + goto yy127; if (yych <= '/') goto yy107; - goto yy129; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy129; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy129; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy127: + yy126: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy129; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy129; + goto yy128; goto yy107; } } else { @@ -2296,51 +2269,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy129; + goto yy128; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy129; + goto yy128; goto yy107; } } - yy128: + yy127: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy130; + goto yy129; if (yych <= '/') goto yy107; - goto yy131; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy131; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy131; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy129: + yy128: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy131; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy131; + goto yy130; goto yy107; } } else { @@ -2349,51 +2320,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy131; + goto yy130; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy131; + goto yy130; goto yy107; } } - yy130: + yy129: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy132; + goto yy131; if (yych <= '/') goto yy107; - goto yy133; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy133; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy133; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy131: + yy130: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy133; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy133; + goto yy132; goto yy107; } } else { @@ -2402,51 +2371,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy133; + goto yy132; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy133; + goto yy132; goto yy107; } } - yy132: + yy131: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy134; + goto yy133; if (yych <= '/') goto yy107; - goto yy135; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy135; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy135; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy133: + yy132: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy135; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy135; + goto yy134; goto yy107; } } else { @@ -2455,51 +2422,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy135; + goto yy134; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy135; + goto yy134; goto yy107; } } - yy134: + yy133: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy136; + goto yy135; if (yych <= '/') goto yy107; - goto yy137; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy137; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy137; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy135: + yy134: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy137; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy137; + goto yy136; goto yy107; } } else { @@ -2508,51 +2473,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy137; + goto yy136; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy137; + goto yy136; goto yy107; } } - yy136: + yy135: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy138; + goto yy137; if (yych <= '/') goto yy107; - goto yy139; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy139; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy139; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy137: + yy136: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy139; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy139; + goto yy138; goto yy107; } } else { @@ -2561,51 +2524,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy139; + goto yy138; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy139; + goto yy138; goto yy107; } } - yy138: + yy137: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy140; + goto yy139; if (yych <= '/') goto yy107; - goto yy141; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy141; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy141; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy139: + yy138: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy141; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy141; + goto yy140; goto yy107; } } else { @@ -2614,51 +2575,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy141; + goto yy140; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy141; + goto yy140; goto yy107; } } - yy140: + yy139: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy142; + goto yy141; if (yych <= '/') goto yy107; - goto yy143; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy143; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy143; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy141: + yy140: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy143; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy143; + goto yy142; goto yy107; } } else { @@ -2667,51 +2626,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy143; + goto yy142; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy143; + goto yy142; goto yy107; } } - yy142: + yy141: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy144; + goto yy143; if (yych <= '/') goto yy107; - goto yy145; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy145; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy145; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy143: + yy142: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy145; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy145; + goto yy144; goto yy107; } } else { @@ -2720,51 +2677,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy145; + goto yy144; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy145; + goto yy144; goto yy107; } } - yy144: + yy143: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy146; + goto yy145; if (yych <= '/') goto yy107; - goto yy147; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy147; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy147; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy145: + yy144: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy147; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy147; + goto yy146; goto yy107; } } else { @@ -2773,51 +2728,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy147; + goto yy146; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy147; + goto yy146; goto yy107; } } - yy146: + yy145: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy148; + goto yy147; if (yych <= '/') goto yy107; - goto yy149; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy149; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy149; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy147: + yy146: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy149; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy149; + goto yy148; goto yy107; } } else { @@ -2826,51 +2779,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy149; + goto yy148; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy149; + goto yy148; goto yy107; } } - yy148: + yy147: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy150; + goto yy149; if (yych <= '/') goto yy107; - goto yy151; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy151; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy151; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy149: + yy148: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy151; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy151; + goto yy150; goto yy107; } } else { @@ -2879,51 +2830,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy151; + goto yy150; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy151; + goto yy150; goto yy107; } } - yy150: + yy149: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy152; + goto yy151; if (yych <= '/') goto yy107; - goto yy153; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy153; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy153; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy151: + yy150: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy153; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy153; + goto yy152; goto yy107; } } else { @@ -2932,51 +2881,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy153; + goto yy152; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy153; + goto yy152; goto yy107; } } - yy152: + yy151: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy154; + goto yy153; if (yych <= '/') goto yy107; - goto yy155; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy155; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy155; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy153: + yy152: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy155; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy155; + goto yy154; goto yy107; } } else { @@ -2985,51 +2932,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy155; + goto yy154; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy155; + goto yy154; goto yy107; } } - yy154: + yy153: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy156; + goto yy155; if (yych <= '/') goto yy107; - goto yy157; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy157; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy157; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy155: + yy154: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy157; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy157; + goto yy156; goto yy107; } } else { @@ -3038,51 +2983,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy157; + goto yy156; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy157; + goto yy156; goto yy107; } } - yy156: + yy155: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy158; + goto yy157; if (yych <= '/') goto yy107; - goto yy159; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy159; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy159; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy157: + yy156: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy159; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy159; + goto yy158; goto yy107; } } else { @@ -3091,51 +3034,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy159; + goto yy158; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy159; + goto yy158; goto yy107; } } - yy158: + yy157: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy160; + goto yy159; if (yych <= '/') goto yy107; - goto yy161; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy161; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy161; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy159: + yy158: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy161; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy161; + goto yy160; goto yy107; } } else { @@ -3144,51 +3085,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy161; + goto yy160; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy161; + goto yy160; goto yy107; } } - yy160: + yy159: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy162; + goto yy161; if (yych <= '/') goto yy107; - goto yy163; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy163; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy163; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy161: + yy160: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy163; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy163; + goto yy162; goto yy107; } } else { @@ -3197,51 +3136,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy163; + goto yy162; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy163; + goto yy162; goto yy107; } } - yy162: + yy161: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy164; + goto yy163; if (yych <= '/') goto yy107; - goto yy165; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy165; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy165; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy163: + yy162: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy165; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy165; + goto yy164; goto yy107; } } else { @@ -3250,51 +3187,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy165; + goto yy164; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy165; + goto yy164; goto yy107; } } - yy164: + yy163: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy166; + goto yy165; if (yych <= '/') goto yy107; - goto yy167; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy167; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy167; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy165: + yy164: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy167; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy167; + goto yy166; goto yy107; } } else { @@ -3303,51 +3238,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy167; + goto yy166; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy167; + goto yy166; goto yy107; } } - yy166: + yy165: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy168; + goto yy167; if (yych <= '/') goto yy107; - goto yy169; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy169; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy169; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy167: + yy166: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy169; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy169; + goto yy168; goto yy107; } } else { @@ -3356,51 +3289,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy169; + goto yy168; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy169; + goto yy168; goto yy107; } } - yy168: + yy167: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy170; + goto yy169; if (yych <= '/') goto yy107; - goto yy171; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy171; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy171; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy169: + yy168: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy171; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy171; + goto yy170; goto yy107; } } else { @@ -3409,51 +3340,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy171; + goto yy170; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy171; + goto yy170; goto yy107; } } - yy170: + yy169: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy172; + goto yy171; if (yych <= '/') goto yy107; - goto yy173; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy173; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy173; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy171: + yy170: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy173; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy173; + goto yy172; goto yy107; } } else { @@ -3462,51 +3391,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy173; + goto yy172; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy173; + goto yy172; goto yy107; } } - yy172: + yy171: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy174; + goto yy173; if (yych <= '/') goto yy107; - goto yy175; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy175; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy175; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy173: + yy172: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy175; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy175; + goto yy174; goto yy107; } } else { @@ -3515,51 +3442,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy175; + goto yy174; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy175; + goto yy174; goto yy107; } } - yy174: + yy173: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy176; + goto yy175; if (yych <= '/') goto yy107; - goto yy177; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy177; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy177; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy175: + yy174: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy177; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy177; + goto yy176; goto yy107; } } else { @@ -3568,51 +3493,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy177; + goto yy176; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy177; + goto yy176; goto yy107; } } - yy176: + yy175: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy178; + goto yy177; if (yych <= '/') goto yy107; - goto yy179; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy179; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy179; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy177: + yy176: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy179; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy179; + goto yy178; goto yy107; } } else { @@ -3621,51 +3544,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy179; + goto yy178; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy179; + goto yy178; goto yy107; } } - yy178: + yy177: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy180; + goto yy179; if (yych <= '/') goto yy107; - goto yy181; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy181; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy181; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy179: + yy178: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy181; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy181; + goto yy180; goto yy107; } } else { @@ -3674,51 +3595,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy181; + goto yy180; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy181; + goto yy180; goto yy107; } } - yy180: + yy179: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy182; + goto yy181; if (yych <= '/') goto yy107; - goto yy183; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy183; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy183; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy181: + yy180: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy183; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy183; + goto yy182; goto yy107; } } else { @@ -3727,51 +3646,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy183; + goto yy182; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy183; + goto yy182; goto yy107; } } - yy182: + yy181: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy184; + goto yy183; if (yych <= '/') goto yy107; - goto yy185; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy185; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy185; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy183: + yy182: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy185; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy185; + goto yy184; goto yy107; } } else { @@ -3780,51 +3697,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy185; + goto yy184; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy185; + goto yy184; goto yy107; } } - yy184: + yy183: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy186; + goto yy185; if (yych <= '/') goto yy107; - goto yy187; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy187; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy187; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy185: + yy184: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy187; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy187; + goto yy186; goto yy107; } } else { @@ -3833,51 +3748,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy187; + goto yy186; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy187; + goto yy186; goto yy107; } } - yy186: + yy185: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy188; + goto yy187; if (yych <= '/') goto yy107; - goto yy189; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy189; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy189; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy187: + yy186: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy189; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy189; + goto yy188; goto yy107; } } else { @@ -3886,51 +3799,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy189; + goto yy188; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy189; + goto yy188; goto yy107; } } - yy188: + yy187: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy190; + goto yy189; if (yych <= '/') goto yy107; - goto yy191; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy191; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy191; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy189: + yy188: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy191; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy191; + goto yy190; goto yy107; } } else { @@ -3939,51 +3850,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy191; + goto yy190; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy191; + goto yy190; goto yy107; } } - yy190: + yy189: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy192; + goto yy191; if (yych <= '/') goto yy107; - goto yy193; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy193; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy193; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy191: + yy190: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy193; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy193; + goto yy192; goto yy107; } } else { @@ -3992,51 +3901,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy193; + goto yy192; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy193; + goto yy192; goto yy107; } } - yy192: + yy191: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy194; + goto yy193; if (yych <= '/') goto yy107; - goto yy195; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy195; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy195; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy193: + yy192: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy195; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy195; + goto yy194; goto yy107; } } else { @@ -4045,51 +3952,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy195; + goto yy194; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy195; + goto yy194; goto yy107; } } - yy194: + yy193: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy196; + goto yy195; if (yych <= '/') goto yy107; - goto yy197; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy197; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy197; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy195: + yy194: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy197; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy197; + goto yy196; goto yy107; } } else { @@ -4098,51 +4003,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy197; + goto yy196; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy197; + goto yy196; goto yy107; } } - yy196: + yy195: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy198; + goto yy197; if (yych <= '/') goto yy107; - goto yy199; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy199; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy199; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy197: + yy196: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy199; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy199; + goto yy198; goto yy107; } } else { @@ -4151,51 +4054,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy199; + goto yy198; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy199; + goto yy198; goto yy107; } } - yy198: + yy197: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy200; + goto yy199; if (yych <= '/') goto yy107; - goto yy201; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy201; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy201; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy199: + yy198: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy201; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy201; + goto yy200; goto yy107; } } else { @@ -4204,51 +4105,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy201; + goto yy200; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy201; + goto yy200; goto yy107; } } - yy200: + yy199: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy202; + goto yy201; if (yych <= '/') goto yy107; - goto yy203; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy203; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy203; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy201: + yy200: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy203; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy203; + goto yy202; goto yy107; } } else { @@ -4257,51 +4156,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy203; + goto yy202; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy203; + goto yy202; goto yy107; } } - yy202: + yy201: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy204; + goto yy203; if (yych <= '/') goto yy107; - goto yy205; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy205; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy205; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy203: + yy202: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy205; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy205; + goto yy204; goto yy107; } } else { @@ -4310,51 +4207,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy205; + goto yy204; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy205; + goto yy204; goto yy107; } } - yy204: + yy203: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy206; + goto yy205; if (yych <= '/') goto yy107; - goto yy207; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy207; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy207; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy205: + yy204: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy207; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy207; + goto yy206; goto yy107; } } else { @@ -4363,51 +4258,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy207; + goto yy206; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy207; + goto yy206; goto yy107; } } - yy206: + yy205: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy208; + goto yy207; if (yych <= '/') goto yy107; - goto yy209; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy209; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy209; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy207: + yy206: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy209; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy209; + goto yy208; goto yy107; } } else { @@ -4416,51 +4309,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy209; + goto yy208; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy209; + goto yy208; goto yy107; } } - yy208: + yy207: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy210; + goto yy209; if (yych <= '/') goto yy107; - goto yy211; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy211; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy211; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy209: + yy208: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy211; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy211; + goto yy210; goto yy107; } } else { @@ -4469,51 +4360,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy211; + goto yy210; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy211; + goto yy210; goto yy107; } } - yy210: + yy209: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy212; + goto yy211; if (yych <= '/') goto yy107; - goto yy213; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy213; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy213; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy211: + yy210: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy213; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy213; + goto yy212; goto yy107; } } else { @@ -4522,51 +4411,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy213; + goto yy212; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy213; + goto yy212; goto yy107; } } - yy212: + yy211: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy214; + goto yy213; if (yych <= '/') goto yy107; - goto yy215; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy215; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy215; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy213: + yy212: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy215; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy215; + goto yy214; goto yy107; } } else { @@ -4575,51 +4462,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy215; + goto yy214; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy215; + goto yy214; goto yy107; } } - yy214: + yy213: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy216; + goto yy215; if (yych <= '/') goto yy107; - goto yy217; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy217; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy217; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy215: + yy214: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy217; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy217; + goto yy216; goto yy107; } } else { @@ -4628,51 +4513,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy217; + goto yy216; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy217; + goto yy216; goto yy107; } } - yy216: + yy215: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy218; + goto yy217; if (yych <= '/') goto yy107; - goto yy219; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy219; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy219; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy217: + yy216: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy219; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy219; + goto yy218; goto yy107; } } else { @@ -4681,51 +4564,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy219; + goto yy218; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy219; + goto yy218; goto yy107; } } - yy218: + yy217: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy220; + goto yy219; if (yych <= '/') goto yy107; - goto yy221; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy221; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy221; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy219: + yy218: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy221; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy221; + goto yy220; goto yy107; } } else { @@ -4734,51 +4615,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy221; + goto yy220; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy221; + goto yy220; goto yy107; } } - yy220: + yy219: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy222; + goto yy221; if (yych <= '/') goto yy107; - goto yy223; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy223; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy223; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy221: + yy220: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy223; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy223; + goto yy222; goto yy107; } } else { @@ -4787,51 +4666,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy223; + goto yy222; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy223; + goto yy222; goto yy107; } } - yy222: + yy221: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy224; + goto yy223; if (yych <= '/') goto yy107; - goto yy225; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy225; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy225; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy223: + yy222: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; - } else { - if (yych <= '/') + if (yych <= '-') + goto yy225; + goto yy120; + } else { + if (yych <= '/') goto yy107; if (yych <= '9') - goto yy225; + goto yy224; goto yy107; } } else { @@ -4840,51 +4717,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy225; + goto yy224; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy225; + goto yy224; goto yy107; } } - yy224: + yy223: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy226; + goto yy225; if (yych <= '/') goto yy107; - goto yy227; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy227; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy227; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy225: + yy224: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy227; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy227; + goto yy226; goto yy107; } } else { @@ -4893,51 +4768,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy227; + goto yy226; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy227; + goto yy226; goto yy107; } } - yy226: + yy225: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy228; + goto yy227; if (yych <= '/') goto yy107; - goto yy229; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy229; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy229; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy227: + yy226: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy229; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy229; + goto yy228; goto yy107; } } else { @@ -4946,51 +4819,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy229; + goto yy228; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy229; + goto yy228; goto yy107; } } - yy228: + yy227: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy230; + goto yy229; if (yych <= '/') goto yy107; - goto yy231; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy231; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy231; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy229: + yy228: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy231; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy231; + goto yy230; goto yy107; } } else { @@ -4999,51 +4870,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy231; + goto yy230; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy231; + goto yy230; goto yy107; } } - yy230: + yy229: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy232; + goto yy231; if (yych <= '/') goto yy107; - goto yy233; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy233; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy233; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy231: + yy230: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy233; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy233; + goto yy232; goto yy107; } } else { @@ -5052,51 +4921,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy233; + goto yy232; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy233; + goto yy232; goto yy107; } } - yy232: + yy231: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy234; + goto yy233; if (yych <= '/') goto yy107; - goto yy235; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy235; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy235; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy233: + yy232: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy235; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy235; + goto yy234; goto yy107; } } else { @@ -5105,51 +4972,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy235; + goto yy234; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy235; + goto yy234; goto yy107; } } - yy234: + yy233: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy236; + goto yy235; if (yych <= '/') goto yy107; - goto yy237; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy237; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy237; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy235: + yy234: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy237; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy237; + goto yy236; goto yy107; } } else { @@ -5158,51 +5023,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy237; + goto yy236; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy237; + goto yy236; goto yy107; } } - yy236: + yy235: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy238; + goto yy237; if (yych <= '/') goto yy107; - goto yy239; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy239; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy239; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy237: + yy236: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy239; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy239; + goto yy238; goto yy107; } } else { @@ -5211,51 +5074,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy239; + goto yy238; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy239; + goto yy238; goto yy107; } } - yy238: + yy237: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy240; + goto yy239; if (yych <= '/') goto yy107; - goto yy241; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy241; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy241; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy239: + yy238: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy241; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy241; + goto yy240; goto yy107; } } else { @@ -5264,51 +5125,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy241; + goto yy240; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy241; + goto yy240; goto yy107; } } - yy240: + yy239: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy242; + goto yy241; if (yych <= '/') goto yy107; - goto yy243; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy243; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy243; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy241: + yy240: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy243; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy243; + goto yy242; goto yy107; } } else { @@ -5317,51 +5176,49 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy243; + goto yy242; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy243; + goto yy242; goto yy107; } } - yy242: + yy241: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy244; + goto yy243; if (yych <= '/') goto yy107; - goto yy245; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy245; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy245; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy243: + yy242: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy245; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy245; + goto yy244; goto yy107; } } else { @@ -5370,34 +5227,35 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy245; + goto yy244; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy245; + goto yy244; goto yy107; } } - yy244: + yy243: ++p; yych = *p; - if (yych <= '@') { + if (yych <= '9') { + if (yych == '-') + goto yy245; if (yych <= '/') goto yy107; - if (yych <= '9') - goto yy246; - goto yy107; } else { - if (yych <= 'Z') - goto yy246; - if (yych <= '`') - goto yy107; - if (yych <= 'z') - goto yy246; - goto yy107; + if (yych <= 'Z') { + if (yych <= '@') + goto yy107; + } else { + if (yych <= '`') + goto yy107; + if (yych >= '{') + goto yy107; + } } - yy245: + yy244: ++p; yych = *p; if (yych <= '=') { @@ -5408,8 +5266,9 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { } else { if (yych <= '/') goto yy107; - if (yych >= ':') - goto yy107; + if (yych <= '9') + goto yy246; + goto yy107; } } else { if (yych <= 'Z') { @@ -5417,13 +5276,31 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; + goto yy246; } else { if (yych <= '`') goto yy107; - if (yych >= '{') - goto yy107; + if (yych <= 'z') + goto yy246; + goto yy107; } } + yy245: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') + goto yy107; + if (yych >= ':') + goto yy107; + } else { + if (yych <= 'Z') + goto yy246; + if (yych <= '`') + goto yy107; + if (yych >= '{') + goto yy107; + } yy246: ++p; yych = *p; @@ -5433,39 +5310,19 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; goto yy107; yy247: - yych = *++p; - if (yych <= '9') { - if (yych == '-') - goto yy249; - if (yych <= '/') - goto yy107; - goto yy250; - } else { - if (yych <= 'Z') { - if (yych <= '@') - goto yy107; - goto yy250; - } else { - if (yych <= '`') - goto yy107; - if (yych <= 'z') - goto yy250; - goto yy107; - } - } - yy248: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy250; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy250; + goto yy249; goto yy107; } } else { @@ -5474,49 +5331,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy250; + goto yy249; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy250; + goto yy249; goto yy107; } } - yy249: + yy248: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy251; + goto yy250; if (yych <= '/') goto yy107; - goto yy252; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy252; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy252; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy250: + yy249: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy252; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy252; + goto yy251; goto yy107; } } else { @@ -5525,49 +5380,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy252; + goto yy251; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy252; + goto yy251; goto yy107; } } - yy251: + yy250: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy253; + goto yy252; if (yych <= '/') goto yy107; - goto yy254; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy254; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy254; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy252: + yy251: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy254; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy254; + goto yy253; goto yy107; } } else { @@ -5576,49 +5429,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy254; + goto yy253; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy254; + goto yy253; goto yy107; } } - yy253: + yy252: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy255; + goto yy254; if (yych <= '/') goto yy107; - goto yy256; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy256; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy256; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy254: + yy253: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy256; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy256; + goto yy255; goto yy107; } } else { @@ -5627,49 +5478,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy256; + goto yy255; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy256; + goto yy255; goto yy107; } } - yy255: + yy254: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy257; + goto yy256; if (yych <= '/') goto yy107; - goto yy258; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy258; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy258; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy256: + yy255: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy258; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy258; + goto yy257; goto yy107; } } else { @@ -5678,49 +5527,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy258; + goto yy257; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy258; + goto yy257; goto yy107; } } - yy257: + yy256: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy259; + goto yy258; if (yych <= '/') goto yy107; - goto yy260; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy260; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy260; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy258: + yy257: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy260; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy260; + goto yy259; goto yy107; } } else { @@ -5729,49 +5576,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy260; + goto yy259; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy260; + goto yy259; goto yy107; } } - yy259: + yy258: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy261; + goto yy260; if (yych <= '/') goto yy107; - goto yy262; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy262; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy262; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy260: + yy259: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy262; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy262; + goto yy261; goto yy107; } } else { @@ -5780,49 +5625,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy262; + goto yy261; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy262; + goto yy261; goto yy107; } } - yy261: + yy260: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy263; + goto yy262; if (yych <= '/') goto yy107; - goto yy264; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy264; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy264; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy262: + yy261: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy264; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy264; + goto yy263; goto yy107; } } else { @@ -5831,49 +5674,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy264; + goto yy263; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy264; + goto yy263; goto yy107; } } - yy263: + yy262: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy265; + goto yy264; if (yych <= '/') goto yy107; - goto yy266; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy266; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy266; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy264: + yy263: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy266; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy266; + goto yy265; goto yy107; } } else { @@ -5882,49 +5723,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy266; + goto yy265; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy266; + goto yy265; goto yy107; } } - yy265: + yy264: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy267; + goto yy266; if (yych <= '/') goto yy107; - goto yy268; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy268; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy268; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy266: + yy265: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy268; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy268; + goto yy267; goto yy107; } } else { @@ -5933,49 +5772,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy268; + goto yy267; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy268; + goto yy267; goto yy107; } } - yy267: + yy266: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy269; + goto yy268; if (yych <= '/') goto yy107; - goto yy270; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy270; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy270; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy268: + yy267: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy270; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy270; + goto yy269; goto yy107; } } else { @@ -5984,49 +5821,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy270; + goto yy269; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy270; + goto yy269; goto yy107; } } - yy269: + yy268: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy271; + goto yy270; if (yych <= '/') goto yy107; - goto yy272; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy272; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy272; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy270: + yy269: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy272; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy272; + goto yy271; goto yy107; } } else { @@ -6035,49 +5870,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy272; + goto yy271; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy272; + goto yy271; goto yy107; } } - yy271: + yy270: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy273; + goto yy272; if (yych <= '/') goto yy107; - goto yy274; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy274; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy274; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy272: + yy271: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy274; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy274; + goto yy273; goto yy107; } } else { @@ -6086,49 +5919,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy274; + goto yy273; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy274; + goto yy273; goto yy107; } } - yy273: + yy272: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy275; + goto yy274; if (yych <= '/') goto yy107; - goto yy276; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy276; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy276; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy274: + yy273: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy276; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy276; + goto yy275; goto yy107; } } else { @@ -6137,49 +5968,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy276; + goto yy275; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy276; + goto yy275; goto yy107; } } - yy275: + yy274: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy277; + goto yy276; if (yych <= '/') goto yy107; - goto yy278; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy278; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy278; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy276: + yy275: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy278; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy278; + goto yy277; goto yy107; } } else { @@ -6188,49 +6017,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy278; + goto yy277; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy278; + goto yy277; goto yy107; } } - yy277: + yy276: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy279; + goto yy278; if (yych <= '/') goto yy107; - goto yy280; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy280; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy280; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy278: + yy277: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy280; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy280; + goto yy279; goto yy107; } } else { @@ -6239,49 +6066,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy280; + goto yy279; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy280; + goto yy279; goto yy107; } } - yy279: + yy278: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy281; + goto yy280; if (yych <= '/') goto yy107; - goto yy282; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy282; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy282; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy280: + yy279: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy282; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy282; + goto yy281; goto yy107; } } else { @@ -6290,49 +6115,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy282; + goto yy281; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy282; + goto yy281; goto yy107; } } - yy281: + yy280: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy283; + goto yy282; if (yych <= '/') goto yy107; - goto yy284; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy284; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy284; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy282: + yy281: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy284; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy284; + goto yy283; goto yy107; } } else { @@ -6341,49 +6164,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy284; + goto yy283; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy284; + goto yy283; goto yy107; } } - yy283: + yy282: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy285; + goto yy284; if (yych <= '/') goto yy107; - goto yy286; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy286; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy286; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy284: + yy283: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy286; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy286; + goto yy285; goto yy107; } } else { @@ -6392,49 +6213,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy286; + goto yy285; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy286; + goto yy285; goto yy107; } } - yy285: + yy284: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy287; + goto yy286; if (yych <= '/') goto yy107; - goto yy288; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy288; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy288; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy286: + yy285: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy288; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy288; + goto yy287; goto yy107; } } else { @@ -6443,49 +6262,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy288; + goto yy287; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy288; + goto yy287; goto yy107; } } - yy287: + yy286: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy289; + goto yy288; if (yych <= '/') goto yy107; - goto yy290; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy290; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy290; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy288: + yy287: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy290; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy290; + goto yy289; goto yy107; } } else { @@ -6494,49 +6311,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy290; + goto yy289; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy290; + goto yy289; goto yy107; } } - yy289: + yy288: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy291; + goto yy290; if (yych <= '/') goto yy107; - goto yy292; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy292; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy292; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy290: + yy289: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy292; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy292; + goto yy291; goto yy107; } } else { @@ -6545,49 +6360,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy292; + goto yy291; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy292; + goto yy291; goto yy107; } } - yy291: + yy290: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy293; + goto yy292; if (yych <= '/') goto yy107; - goto yy294; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy294; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy294; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy292: + yy291: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy294; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy294; + goto yy293; goto yy107; } } else { @@ -6596,49 +6409,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy294; + goto yy293; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy294; + goto yy293; goto yy107; } } - yy293: + yy292: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy295; + goto yy294; if (yych <= '/') goto yy107; - goto yy296; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy296; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy296; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy294: + yy293: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy296; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy296; + goto yy295; goto yy107; } } else { @@ -6647,49 +6458,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy296; + goto yy295; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy296; + goto yy295; goto yy107; } } - yy295: + yy294: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy297; + goto yy296; if (yych <= '/') goto yy107; - goto yy298; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy298; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy298; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy296: + yy295: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy298; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy298; + goto yy297; goto yy107; } } else { @@ -6698,49 +6507,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy298; + goto yy297; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy298; + goto yy297; goto yy107; } } - yy297: + yy296: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy299; + goto yy298; if (yych <= '/') goto yy107; - goto yy300; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy300; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy300; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy298: + yy297: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy300; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy300; + goto yy299; goto yy107; } } else { @@ -6749,49 +6556,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy300; + goto yy299; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy300; + goto yy299; goto yy107; } } - yy299: + yy298: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy301; + goto yy300; if (yych <= '/') goto yy107; - goto yy302; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy302; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy302; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy300: + yy299: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; - } else { + if (yych <= '-') + goto yy302; + goto yy120; + } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy302; + goto yy301; goto yy107; } } else { @@ -6800,49 +6605,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy302; + goto yy301; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy302; + goto yy301; goto yy107; } } - yy301: + yy300: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy303; + goto yy302; if (yych <= '/') goto yy107; - goto yy304; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy304; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy304; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy302: + yy301: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy304; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy304; + goto yy303; goto yy107; } } else { @@ -6851,49 +6654,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy304; + goto yy303; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy304; + goto yy303; goto yy107; } } - yy303: + yy302: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy305; + goto yy304; if (yych <= '/') goto yy107; - goto yy306; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy306; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy306; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy304: + yy303: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy306; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy306; + goto yy305; goto yy107; } } else { @@ -6902,49 +6703,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy306; + goto yy305; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy306; + goto yy305; goto yy107; } } - yy305: + yy304: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy307; + goto yy306; if (yych <= '/') goto yy107; - goto yy308; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy308; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy308; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy306: + yy305: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy308; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy308; + goto yy307; goto yy107; } } else { @@ -6953,49 +6752,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy308; + goto yy307; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy308; + goto yy307; goto yy107; } } - yy307: + yy306: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy309; + goto yy308; if (yych <= '/') goto yy107; - goto yy310; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy310; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy310; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy308: + yy307: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy310; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy310; + goto yy309; goto yy107; } } else { @@ -7004,49 +6801,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy310; + goto yy309; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy310; + goto yy309; goto yy107; } } - yy309: + yy308: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy311; + goto yy310; if (yych <= '/') goto yy107; - goto yy312; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy312; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy312; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy310: + yy309: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy312; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy312; + goto yy311; goto yy107; } } else { @@ -7055,49 +6850,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy312; + goto yy311; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy312; + goto yy311; goto yy107; } } - yy311: + yy310: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy313; + goto yy312; if (yych <= '/') goto yy107; - goto yy314; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy314; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy314; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy312: + yy311: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy314; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy314; + goto yy313; goto yy107; } } else { @@ -7106,49 +6899,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy314; + goto yy313; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy314; + goto yy313; goto yy107; } } - yy313: + yy312: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy315; + goto yy314; if (yych <= '/') goto yy107; - goto yy316; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy316; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy316; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy314: + yy313: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy316; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy316; + goto yy315; goto yy107; } } else { @@ -7157,49 +6948,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy316; + goto yy315; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy316; + goto yy315; goto yy107; } } - yy315: + yy314: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy317; + goto yy316; if (yych <= '/') goto yy107; - goto yy318; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy318; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy318; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy316: + yy315: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy318; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy318; + goto yy317; goto yy107; } } else { @@ -7208,49 +6997,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy318; + goto yy317; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy318; + goto yy317; goto yy107; } } - yy317: + yy316: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy319; + goto yy318; if (yych <= '/') goto yy107; - goto yy320; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy320; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy320; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy318: + yy317: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy320; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy320; + goto yy319; goto yy107; } } else { @@ -7259,49 +7046,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy320; + goto yy319; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy320; + goto yy319; goto yy107; } } - yy319: + yy318: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy321; + goto yy320; if (yych <= '/') goto yy107; - goto yy322; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy322; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy322; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy320: + yy319: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy322; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy322; + goto yy321; goto yy107; } } else { @@ -7310,49 +7095,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy322; + goto yy321; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy322; + goto yy321; goto yy107; } } - yy321: + yy320: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy323; + goto yy322; if (yych <= '/') goto yy107; - goto yy324; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy324; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy324; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy322: + yy321: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy324; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy324; + goto yy323; goto yy107; } } else { @@ -7361,49 +7144,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy324; + goto yy323; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy324; + goto yy323; goto yy107; } } - yy323: + yy322: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy325; + goto yy324; if (yych <= '/') goto yy107; - goto yy326; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy326; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy326; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy324: + yy323: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy326; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy326; + goto yy325; goto yy107; } } else { @@ -7412,49 +7193,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy326; + goto yy325; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy326; + goto yy325; goto yy107; } } - yy325: + yy324: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy327; + goto yy326; if (yych <= '/') goto yy107; - goto yy328; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy328; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy328; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy326: + yy325: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy328; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy328; + goto yy327; goto yy107; } } else { @@ -7463,49 +7242,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy328; + goto yy327; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy328; + goto yy327; goto yy107; } } - yy327: + yy326: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy329; + goto yy328; if (yych <= '/') goto yy107; - goto yy330; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy330; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy330; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy328: + yy327: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy330; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy330; + goto yy329; goto yy107; } } else { @@ -7514,49 +7291,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy330; + goto yy329; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy330; + goto yy329; goto yy107; } } - yy329: + yy328: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy331; + goto yy330; if (yych <= '/') goto yy107; - goto yy332; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy332; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy332; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy330: + yy329: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy332; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy332; + goto yy331; goto yy107; } } else { @@ -7565,49 +7340,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy332; + goto yy331; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy332; + goto yy331; goto yy107; } } - yy331: + yy330: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy333; + goto yy332; if (yych <= '/') goto yy107; - goto yy334; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy334; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy334; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy332: + yy331: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy334; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy334; + goto yy333; goto yy107; } } else { @@ -7616,49 +7389,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy334; + goto yy333; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy334; + goto yy333; goto yy107; } } - yy333: + yy332: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy335; + goto yy334; if (yych <= '/') goto yy107; - goto yy336; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy336; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy336; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy334: + yy333: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy336; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy336; + goto yy335; goto yy107; } } else { @@ -7667,49 +7438,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy336; + goto yy335; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy336; + goto yy335; goto yy107; } } - yy335: + yy334: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy337; + goto yy336; if (yych <= '/') goto yy107; - goto yy338; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy338; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy338; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy336: + yy335: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy338; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy338; + goto yy337; goto yy107; } } else { @@ -7718,49 +7487,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy338; + goto yy337; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy338; + goto yy337; goto yy107; } } - yy337: + yy336: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy339; + goto yy338; if (yych <= '/') goto yy107; - goto yy340; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy340; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy340; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy338: + yy337: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy340; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy340; + goto yy339; goto yy107; } } else { @@ -7769,49 +7536,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy340; + goto yy339; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy340; + goto yy339; goto yy107; } } - yy339: + yy338: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy341; + goto yy340; if (yych <= '/') goto yy107; - goto yy342; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy342; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy342; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy340: + yy339: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy342; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy342; + goto yy341; goto yy107; } } else { @@ -7820,49 +7585,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy342; + goto yy341; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy342; + goto yy341; goto yy107; } } - yy341: + yy340: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy343; + goto yy342; if (yych <= '/') goto yy107; - goto yy344; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy344; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy344; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy342: + yy341: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy344; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy344; + goto yy343; goto yy107; } } else { @@ -7871,49 +7634,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy344; + goto yy343; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy344; + goto yy343; goto yy107; } } - yy343: + yy342: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy345; + goto yy344; if (yych <= '/') goto yy107; - goto yy346; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy346; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy346; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy344: + yy343: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy346; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy346; + goto yy345; goto yy107; } } else { @@ -7922,49 +7683,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy346; + goto yy345; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy346; + goto yy345; goto yy107; } } - yy345: + yy344: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy347; + goto yy346; if (yych <= '/') goto yy107; - goto yy348; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy348; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy348; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy346: + yy345: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy348; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy348; + goto yy347; goto yy107; } } else { @@ -7973,49 +7732,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy348; + goto yy347; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy348; + goto yy347; goto yy107; } } - yy347: + yy346: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy349; + goto yy348; if (yych <= '/') goto yy107; - goto yy350; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy350; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy350; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy348: + yy347: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy350; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy350; + goto yy349; goto yy107; } } else { @@ -8024,49 +7781,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy350; + goto yy349; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy350; + goto yy349; goto yy107; } } - yy349: + yy348: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy351; + goto yy350; if (yych <= '/') goto yy107; - goto yy352; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy352; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy352; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy350: + yy349: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy352; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy352; + goto yy351; goto yy107; } } else { @@ -8075,49 +7830,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy352; + goto yy351; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy352; + goto yy351; goto yy107; } } - yy351: + yy350: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy353; + goto yy352; if (yych <= '/') goto yy107; - goto yy354; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy354; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy354; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy352: + yy351: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy354; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy354; + goto yy353; goto yy107; } } else { @@ -8126,49 +7879,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy354; + goto yy353; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy354; + goto yy353; goto yy107; } } - yy353: + yy352: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy355; + goto yy354; if (yych <= '/') goto yy107; - goto yy356; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy356; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy356; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy354: + yy353: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy356; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy356; + goto yy355; goto yy107; } } else { @@ -8177,49 +7928,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy356; + goto yy355; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy356; + goto yy355; goto yy107; } } - yy355: + yy354: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy357; + goto yy356; if (yych <= '/') goto yy107; - goto yy358; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy358; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy358; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy356: + yy355: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy358; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy358; + goto yy357; goto yy107; } } else { @@ -8228,49 +7977,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy358; + goto yy357; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy358; + goto yy357; goto yy107; } } - yy357: + yy356: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy359; + goto yy358; if (yych <= '/') goto yy107; - goto yy360; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy360; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy360; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy358: + yy357: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy360; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy360; + goto yy359; goto yy107; } } else { @@ -8279,49 +8026,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy360; + goto yy359; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy360; + goto yy359; goto yy107; } } - yy359: + yy358: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy361; + goto yy360; if (yych <= '/') goto yy107; - goto yy362; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy362; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy362; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy360: + yy359: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy362; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy362; + goto yy361; goto yy107; } } else { @@ -8330,49 +8075,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy362; + goto yy361; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy362; + goto yy361; goto yy107; } } - yy361: + yy360: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy363; + goto yy362; if (yych <= '/') goto yy107; - goto yy364; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy364; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy364; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy362: + yy361: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy364; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy364; + goto yy363; goto yy107; } } else { @@ -8381,49 +8124,47 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy364; + goto yy363; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy364; + goto yy363; goto yy107; } } - yy363: + yy362: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy365; + goto yy364; if (yych <= '/') goto yy107; - goto yy366; } else { if (yych <= 'Z') { if (yych <= '@') goto yy107; - goto yy366; } else { if (yych <= '`') goto yy107; - if (yych <= 'z') - goto yy366; - goto yy107; + if (yych >= '{') + goto yy107; } } - yy364: + yy363: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') goto yy107; - if (yych >= '.') - goto yy120; + if (yych <= '-') + goto yy366; + goto yy120; } else { if (yych <= '/') goto yy107; if (yych <= '9') - goto yy366; + goto yy365; goto yy107; } } else { @@ -8432,35 +8173,36 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy121; if (yych <= '@') goto yy107; - goto yy366; + goto yy365; } else { if (yych <= '`') goto yy107; if (yych <= 'z') - goto yy366; + goto yy365; goto yy107; } } - yy365: + yy364: yych = *++p; - if (yych <= '@') { + if (yych <= '9') { + if (yych == '-') + goto yy366; if (yych <= '/') goto yy107; - if (yych <= '9') - goto yy246; - goto yy107; } else { - if (yych <= 'Z') - goto yy246; - if (yych <= '`') - goto yy107; - if (yych <= 'z') - goto yy246; - goto yy107; + if (yych <= 'Z') { + if (yych <= '@') + goto yy107; + } else { + if (yych <= '`') + goto yy107; + if (yych >= '{') + goto yy107; + } } - yy366: - ++p; - if ((yych = *p) <= '=') { + yy365: + yych = *++p; + if (yych <= '=') { if (yych <= '.') { if (yych <= '-') goto yy107; @@ -8487,6 +8229,23 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { goto yy107; } } + yy366: + ++p; + if ((yych = *p) <= '@') { + if (yych <= '/') + goto yy107; + if (yych <= '9') + goto yy246; + goto yy107; + } else { + if (yych <= 'Z') + goto yy246; + if (yych <= '`') + goto yy107; + if (yych <= 'z') + goto yy246; + goto yy107; + } } } @@ -10925,50 +10684,24 @@ bufsize_t _scan_html_block_start(const unsigned char *p) { } yy545: yych = *++p; - if (yych <= 'U') { - if (yych <= 'E') { - if (yych == 'C') - goto yy587; - if (yych <= 'D') - goto yy525; - goto yy590; - } else { - if (yych <= 'O') { - if (yych <= 'N') - goto yy525; - goto yy589; - } else { - if (yych <= 'S') - goto yy525; - if (yych <= 'T') - goto yy586; - goto yy588; - } - } - } else { - if (yych <= 'n') { - if (yych <= 'c') { - if (yych <= 'b') - goto yy525; - goto yy587; - } else { - if (yych == 'e') - goto yy590; - goto yy525; - } - } else { - if (yych <= 's') { - if (yych <= 'o') - goto yy589; - goto yy525; - } else { - if (yych <= 't') - goto yy586; - if (yych <= 'u') - goto yy588; - goto yy525; - } - } + switch (yych) { + case 'C': + case 'c': + goto yy587; + case 'E': + case 'e': + goto yy590; + case 'O': + case 'o': + goto yy589; + case 'T': + case 't': + goto yy586; + case 'U': + case 'u': + goto yy588; + default: + goto yy525; } yy546: yych = *++p; @@ -18923,9 +18656,9 @@ bufsize_t _scan_thematic_break(const unsigned char *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, 16, 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, 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, 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, @@ -18984,16 +18717,16 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { yy1206: yych = *(marker = ++p); if (yych == ' ') - goto yy1238; + goto yy1242; if (yych == '*') - goto yy1240; + goto yy1244; goto yy1205; yy1207: yych = *(marker = ++p); if (yych == ' ') - goto yy1228; - if (yych == '_') goto yy1230; + if (yych == '_') + goto yy1232; goto yy1205; yy1208: yych = *(marker = ++p); @@ -19075,23 +18808,32 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { yy1222: ++p; yych = *p; - if (yybm[0 + yych] & 16) { - goto yy1222; - } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy1211; - if (yych >= '\n') + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x08) + goto yy1211; + } else { + if (yych <= '\n') + goto yy1226; + if (yych <= '\f') + goto yy1211; goto yy1226; + } } else { - if (yych == '\r') - goto yy1226; - goto yy1211; + if (yych <= ' ') { + if (yych <= 0x1F) + goto yy1211; + goto yy1222; + } else { + if (yych == '-') + goto yy1228; + goto yy1211; + } } yy1224: ++p; yych = *p; - if (yybm[0 + yych] & 32) { + if (yybm[0 + yych] & 16) { goto yy1224; } if (yych <= 0x08) @@ -19106,10 +18848,20 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { yy1228: ++p; yych = *p; - if (yych == ' ') + if (yybm[0 + yych] & 32) { goto yy1228; - if (yych != '_') + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy1211; + if (yych <= '\t') + goto yy1224; + goto yy1226; + } else { + if (yych == '\r') + goto yy1226; goto yy1211; + } yy1230: ++p; yych = *p; @@ -19120,89 +18872,148 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { yy1232: ++p; yych = *p; - if (yybm[0 + yych] & 64) { + if (yych == ' ') goto yy1232; - } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy1211; - if (yych >= '\n') - goto yy1236; - } else { - if (yych == '\r') - goto yy1236; + if (yych != '_') goto yy1211; - } yy1234: + ++p; + yych = *p; + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x08) + goto yy1211; + } else { + if (yych <= '\n') + goto yy1238; + if (yych <= '\f') + goto yy1211; + goto yy1238; + } + } else { + if (yych <= ' ') { + if (yych <= 0x1F) + goto yy1211; + goto yy1234; + } else { + if (yych == '_') + goto yy1240; + goto yy1211; + } + } + yy1236: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) goto yy1211; if (yych <= '\t') - goto yy1234; + goto yy1236; if (yych >= '\v') goto yy1211; } else { if (yych <= '\r') - goto yy1236; + goto yy1238; if (yych == ' ') - goto yy1234; + goto yy1236; goto yy1211; } - yy1236: + yy1238: ++p; { return (bufsize_t)(p - start); } - yy1238: + yy1240: ++p; yych = *p; - if (yych == ' ') + if (yybm[0 + yych] & 64) { + goto yy1240; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy1211; + if (yych <= '\t') + goto yy1236; goto yy1238; + } else { + if (yych == '\r') + goto yy1238; + goto yy1211; + } + yy1242: + ++p; + yych = *p; + if (yych == ' ') + goto yy1242; if (yych != '*') goto yy1211; - yy1240: + yy1244: ++p; yych = *p; if (yych == ' ') - goto yy1240; + goto yy1244; if (yych != '*') goto yy1211; - yy1242: + yy1246: ++p; yych = *p; - if (yybm[0 + yych] & 128) { - goto yy1242; - } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy1211; - if (yych >= '\n') - goto yy1246; + if (yych <= '\r') { + if (yych <= '\t') { + if (yych <= 0x08) + goto yy1211; + } else { + if (yych <= '\n') + goto yy1250; + if (yych <= '\f') + goto yy1211; + goto yy1250; + } } else { - if (yych == '\r') + if (yych <= ' ') { + if (yych <= 0x1F) + goto yy1211; goto yy1246; - goto yy1211; + } else { + if (yych == '*') + goto yy1252; + goto yy1211; + } } - yy1244: + yy1248: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) goto yy1211; if (yych <= '\t') - goto yy1244; + goto yy1248; if (yych >= '\v') goto yy1211; } else { if (yych <= '\r') - goto yy1246; + goto yy1250; if (yych == ' ') - goto yy1244; + goto yy1248; goto yy1211; } - yy1246: + yy1250: ++p; { return (bufsize_t)(p - start); } + yy1252: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy1252; + } + if (yych <= '\n') { + if (yych <= 0x08) + goto yy1211; + if (yych <= '\t') + goto yy1248; + goto yy1250; + } else { + if (yych == '\r') + goto yy1250; + goto yy1211; + } } } @@ -19238,374 +19049,374 @@ bufsize_t _scan_open_code_fence(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '`') { if (yych == '\n') - goto yy1250; + goto yy1256; if (yych <= '_') - goto yy1253; - goto yy1251; + goto yy1259; + goto yy1257; } else { if (yych == '~') - goto yy1252; + goto yy1258; if (yych <= 0x7F) - goto yy1253; + goto yy1259; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1254; + goto yy1260; if (yych <= 0xE0) - goto yy1256; + goto yy1262; if (yych <= 0xEC) - goto yy1257; - goto yy1261; + goto yy1263; + goto yy1267; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1257; - goto yy1258; + goto yy1263; + goto yy1264; } else { if (yych <= 0xF3) - goto yy1259; + goto yy1265; if (yych <= 0xF4) - goto yy1260; + goto yy1266; } } } - yy1250 : { return 0; } - yy1251: + yy1256 : { return 0; } + yy1257: yych = *(marker = ++p); if (yych == '`') - goto yy1276; - goto yy1250; - yy1252: + goto yy1282; + goto yy1256; + yy1258: yych = *(marker = ++p); if (yych == '~') - goto yy1262; - goto yy1250; - yy1253: + goto yy1268; + goto yy1256; + yy1259: yych = *++p; - goto yy1250; - yy1254: + goto yy1256; + yy1260: yych = *++p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1253; - yy1255: + goto yy1259; + yy1261: p = marker; - goto yy1250; - yy1256: + goto yy1256; + yy1262: yych = *++p; if (yych <= 0x9F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1254; - goto yy1255; - yy1257: + goto yy1260; + goto yy1261; + yy1263: yych = *++p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1254; - goto yy1255; - yy1258: + goto yy1260; + goto yy1261; + yy1264: yych = *++p; if (yych <= 0x8F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1257; - goto yy1255; - yy1259: + goto yy1263; + goto yy1261; + yy1265: yych = *++p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1257; - goto yy1255; - yy1260: + goto yy1263; + goto yy1261; + yy1266: yych = *++p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0x8F) - goto yy1257; - goto yy1255; - yy1261: + goto yy1263; + goto yy1261; + yy1267: yych = *++p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0x9F) - goto yy1254; - goto yy1255; - yy1262: + goto yy1260; + goto yy1261; + yy1268: yych = *++p; if (yybm[0 + yych] & 16) { - goto yy1263; + goto yy1269; } - goto yy1255; - yy1263: - marker = p + 1; + goto yy1261; + yy1269: ++p; yych = *p; + marker = p; if (yybm[0 + yych] & 32) { - goto yy1265; + goto yy1271; } if (yych <= 0xE0) { if (yych <= '~') { if (yych <= 0x00) - goto yy1255; + goto yy1261; if (yych <= '\r') - goto yy1274; - goto yy1263; + goto yy1280; + goto yy1269; } else { if (yych <= 0xC1) - goto yy1255; + goto yy1261; if (yych <= 0xDF) - goto yy1267; - goto yy1268; + goto yy1273; + goto yy1274; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1273; - goto yy1269; + goto yy1279; + goto yy1275; } else { if (yych <= 0xF0) - goto yy1270; + goto yy1276; if (yych <= 0xF3) - goto yy1271; + goto yy1277; if (yych <= 0xF4) - goto yy1272; - goto yy1255; + goto yy1278; + goto yy1261; } } - yy1265: + yy1271: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1265; + goto yy1271; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1255; + goto yy1261; if (yych <= '\r') - goto yy1274; - goto yy1255; + goto yy1280; + goto yy1261; } else { if (yych <= 0xDF) - goto yy1267; + goto yy1273; if (yych <= 0xE0) - goto yy1268; - goto yy1269; + goto yy1274; + goto yy1275; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1273; + goto yy1279; if (yych <= 0xEF) - goto yy1269; - goto yy1270; + goto yy1275; + goto yy1276; } else { if (yych <= 0xF3) - goto yy1271; + goto yy1277; if (yych <= 0xF4) - goto yy1272; - goto yy1255; + goto yy1278; + goto yy1261; } } - yy1267: + yy1273: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1265; - goto yy1255; - yy1268: + goto yy1271; + goto yy1261; + yy1274: ++p; yych = *p; if (yych <= 0x9F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1267; - goto yy1255; - yy1269: + goto yy1273; + goto yy1261; + yy1275: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1267; - goto yy1255; - yy1270: + goto yy1273; + goto yy1261; + yy1276: ++p; yych = *p; if (yych <= 0x8F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1269; - goto yy1255; - yy1271: + goto yy1275; + goto yy1261; + yy1277: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1269; - goto yy1255; - yy1272: + goto yy1275; + goto yy1261; + yy1278: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0x8F) - goto yy1269; - goto yy1255; - yy1273: + goto yy1275; + goto yy1261; + yy1279: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0x9F) - goto yy1267; - goto yy1255; - yy1274: + goto yy1273; + goto yy1261; + yy1280: ++p; p = marker; { return (bufsize_t)(p - start); } - yy1276: + yy1282: yych = *++p; if (yybm[0 + yych] & 64) { - goto yy1277; + goto yy1283; } - goto yy1255; - yy1277: - marker = p + 1; + goto yy1261; + yy1283: ++p; yych = *p; + marker = p; if (yybm[0 + yych] & 128) { - goto yy1279; + goto yy1285; } if (yych <= 0xE0) { if (yych <= '`') { if (yych <= 0x00) - goto yy1255; + goto yy1261; if (yych <= '\r') - goto yy1288; - goto yy1277; + goto yy1294; + goto yy1283; } else { if (yych <= 0xC1) - goto yy1255; + goto yy1261; if (yych <= 0xDF) - goto yy1281; - goto yy1282; + goto yy1287; + goto yy1288; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1287; - goto yy1283; + goto yy1293; + goto yy1289; } else { if (yych <= 0xF0) - goto yy1284; + goto yy1290; if (yych <= 0xF3) - goto yy1285; + goto yy1291; if (yych <= 0xF4) - goto yy1286; - goto yy1255; + goto yy1292; + goto yy1261; } } - yy1279: + yy1285: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1279; + goto yy1285; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1255; + goto yy1261; if (yych <= '\r') - goto yy1288; - goto yy1255; + goto yy1294; + goto yy1261; } else { if (yych <= 0xDF) - goto yy1281; + goto yy1287; if (yych <= 0xE0) - goto yy1282; - goto yy1283; + goto yy1288; + goto yy1289; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1287; + goto yy1293; if (yych <= 0xEF) - goto yy1283; - goto yy1284; + goto yy1289; + goto yy1290; } else { if (yych <= 0xF3) - goto yy1285; + goto yy1291; if (yych <= 0xF4) - goto yy1286; - goto yy1255; + goto yy1292; + goto yy1261; } } - yy1281: + yy1287: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1279; - goto yy1255; - yy1282: + goto yy1285; + goto yy1261; + yy1288: ++p; yych = *p; if (yych <= 0x9F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1281; - goto yy1255; - yy1283: + goto yy1287; + goto yy1261; + yy1289: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1281; - goto yy1255; - yy1284: + goto yy1287; + goto yy1261; + yy1290: ++p; yych = *p; if (yych <= 0x8F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1283; - goto yy1255; - yy1285: + goto yy1289; + goto yy1261; + yy1291: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0xBF) - goto yy1283; - goto yy1255; - yy1286: + goto yy1289; + goto yy1261; + yy1292: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0x8F) - goto yy1283; - goto yy1255; - yy1287: + goto yy1289; + goto yy1261; + yy1293: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1261; if (yych <= 0x9F) - goto yy1281; - goto yy1255; - yy1288: + goto yy1287; + goto yy1261; + yy1294: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -19637,190 +19448,190 @@ bufsize_t _scan_close_code_fence(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '`') { if (yych == '\n') - goto yy1292; + goto yy1298; if (yych <= '_') - goto yy1295; - goto yy1293; + goto yy1301; + goto yy1299; } else { if (yych == '~') - goto yy1294; + goto yy1300; if (yych <= 0x7F) - goto yy1295; + goto yy1301; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1296; + goto yy1302; if (yych <= 0xE0) - goto yy1298; + goto yy1304; if (yych <= 0xEC) - goto yy1299; - goto yy1303; + goto yy1305; + goto yy1309; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1299; - goto yy1300; + goto yy1305; + goto yy1306; } else { if (yych <= 0xF3) - goto yy1301; + goto yy1307; if (yych <= 0xF4) - goto yy1302; + goto yy1308; } } } - yy1292 : { return 0; } - yy1293: + yy1298 : { return 0; } + yy1299: yych = *(marker = ++p); if (yych == '`') - goto yy1311; - goto yy1292; - yy1294: + goto yy1317; + goto yy1298; + yy1300: yych = *(marker = ++p); if (yych == '~') - goto yy1304; - goto yy1292; - yy1295: + goto yy1310; + goto yy1298; + yy1301: yych = *++p; - goto yy1292; - yy1296: + goto yy1298; + yy1302: yych = *++p; if (yych <= 0x7F) - goto yy1297; + goto yy1303; if (yych <= 0xBF) - goto yy1295; - yy1297: + goto yy1301; + yy1303: p = marker; - goto yy1292; - yy1298: + goto yy1298; + yy1304: yych = *++p; if (yych <= 0x9F) - goto yy1297; + goto yy1303; if (yych <= 0xBF) - goto yy1296; - goto yy1297; - yy1299: + goto yy1302; + goto yy1303; + yy1305: yych = *++p; if (yych <= 0x7F) - goto yy1297; + goto yy1303; if (yych <= 0xBF) - goto yy1296; - goto yy1297; - yy1300: + goto yy1302; + goto yy1303; + yy1306: yych = *++p; if (yych <= 0x8F) - goto yy1297; + goto yy1303; if (yych <= 0xBF) - goto yy1299; - goto yy1297; - yy1301: + goto yy1305; + goto yy1303; + yy1307: yych = *++p; if (yych <= 0x7F) - goto yy1297; + goto yy1303; if (yych <= 0xBF) - goto yy1299; - goto yy1297; - yy1302: + goto yy1305; + goto yy1303; + yy1308: yych = *++p; if (yych <= 0x7F) - goto yy1297; + goto yy1303; if (yych <= 0x8F) - goto yy1299; - goto yy1297; - yy1303: + goto yy1305; + goto yy1303; + yy1309: yych = *++p; if (yych <= 0x7F) - goto yy1297; + goto yy1303; if (yych <= 0x9F) - goto yy1296; - goto yy1297; - yy1304: + goto yy1302; + goto yy1303; + yy1310: yych = *++p; if (yybm[0 + yych] & 32) { - goto yy1305; + goto yy1311; } - goto yy1297; - yy1305: - marker = p + 1; + goto yy1303; + yy1311: ++p; yych = *p; + marker = p; if (yybm[0 + yych] & 64) { - goto yy1307; + goto yy1313; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1297; + goto yy1303; if (yych <= '\n') - goto yy1309; - goto yy1297; + goto yy1315; + goto yy1303; } else { if (yych <= '\r') - goto yy1309; + goto yy1315; if (yych == '~') - goto yy1305; - goto yy1297; + goto yy1311; + goto yy1303; } - yy1307: + yy1313: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1307; + goto yy1313; } if (yych <= 0x08) - goto yy1297; + goto yy1303; if (yych <= '\n') - goto yy1309; + goto yy1315; if (yych != '\r') - goto yy1297; - yy1309: + goto yy1303; + yy1315: ++p; p = marker; { return (bufsize_t)(p - start); } - yy1311: + yy1317: yych = *++p; if (yybm[0 + yych] & 128) { - goto yy1312; + goto yy1318; } - goto yy1297; - yy1312: - marker = p + 1; + goto yy1303; + yy1318: ++p; yych = *p; + marker = p; if (yybm[0 + yych] & 128) { - goto yy1312; + goto yy1318; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1297; + goto yy1303; if (yych <= '\t') - goto yy1314; + goto yy1320; if (yych <= '\n') - goto yy1316; - goto yy1297; + goto yy1322; + goto yy1303; } else { if (yych <= '\r') - goto yy1316; + goto yy1322; if (yych != ' ') - goto yy1297; + goto yy1303; } - yy1314: + yy1320: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) - goto yy1297; + goto yy1303; if (yych <= '\t') - goto yy1314; + goto yy1320; if (yych >= '\v') - goto yy1297; + goto yy1303; } else { if (yych <= '\r') - goto yy1316; + goto yy1322; if (yych == ' ') - goto yy1314; - goto yy1297; + goto yy1320; + goto yy1303; } - yy1316: + yy1322: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -19839,997 +19650,997 @@ bufsize_t _scan_entity(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= '%') { if (yych != '\n') - goto yy1322; + goto yy1328; } else { if (yych <= '&') - goto yy1321; + goto yy1327; if (yych <= 0x7F) - goto yy1322; + goto yy1328; if (yych >= 0xC2) - goto yy1323; + goto yy1329; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1325; + goto yy1331; if (yych == 0xED) - goto yy1330; - goto yy1326; + goto yy1336; + goto yy1332; } else { if (yych <= 0xF0) - goto yy1327; + goto yy1333; if (yych <= 0xF3) - goto yy1328; + goto yy1334; if (yych <= 0xF4) - goto yy1329; + goto yy1335; } } - yy1320 : { return 0; } - yy1321: + yy1326 : { return 0; } + yy1327: yych = *(marker = ++p); if (yych <= '@') { if (yych == '#') - goto yy1331; - goto yy1320; + goto yy1337; + goto yy1326; } else { if (yych <= 'Z') - goto yy1332; + goto yy1338; if (yych <= '`') - goto yy1320; + goto yy1326; if (yych <= 'z') - goto yy1332; - goto yy1320; + goto yy1338; + goto yy1326; } - yy1322: + yy1328: yych = *++p; - goto yy1320; - yy1323: + goto yy1326; + yy1329: yych = *++p; if (yych <= 0x7F) - goto yy1324; + goto yy1330; if (yych <= 0xBF) - goto yy1322; - yy1324: + goto yy1328; + yy1330: p = marker; - goto yy1320; - yy1325: + goto yy1326; + yy1331: yych = *++p; if (yych <= 0x9F) - goto yy1324; + goto yy1330; if (yych <= 0xBF) - goto yy1323; - goto yy1324; - yy1326: + goto yy1329; + goto yy1330; + yy1332: yych = *++p; if (yych <= 0x7F) - goto yy1324; + goto yy1330; if (yych <= 0xBF) - goto yy1323; - goto yy1324; - yy1327: + goto yy1329; + goto yy1330; + yy1333: yych = *++p; if (yych <= 0x8F) - goto yy1324; + goto yy1330; if (yych <= 0xBF) - goto yy1326; - goto yy1324; - yy1328: + goto yy1332; + goto yy1330; + yy1334: yych = *++p; if (yych <= 0x7F) - goto yy1324; + goto yy1330; if (yych <= 0xBF) - goto yy1326; - goto yy1324; - yy1329: + goto yy1332; + goto yy1330; + yy1335: yych = *++p; if (yych <= 0x7F) - goto yy1324; + goto yy1330; if (yych <= 0x8F) - goto yy1326; - goto yy1324; - yy1330: + goto yy1332; + goto yy1330; + yy1336: yych = *++p; if (yych <= 0x7F) - goto yy1324; + goto yy1330; if (yych <= 0x9F) - goto yy1323; - goto yy1324; - yy1331: + goto yy1329; + goto yy1330; + yy1337: yych = *++p; if (yych <= 'W') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1367; - goto yy1324; + goto yy1373; + goto yy1330; } else { if (yych <= 'X') - goto yy1366; + goto yy1372; if (yych == 'x') - goto yy1366; - goto yy1324; + goto yy1372; + goto yy1330; } - yy1332: + yy1338: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych >= ':') - goto yy1324; + goto yy1330; } else { if (yych <= 'Z') - goto yy1333; + goto yy1339; if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } - yy1333: + yy1339: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1336; + goto yy1342; if (yych <= ':') - goto yy1324; + goto yy1330; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; - goto yy1336; + goto yy1330; + goto yy1342; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych <= 'z') - goto yy1336; - goto yy1324; + goto yy1342; + goto yy1330; } } - yy1334: + yy1340: ++p; { return (bufsize_t)(p - start); } - yy1336: + yy1342: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1337; + goto yy1343; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1337: + yy1343: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1338; + goto yy1344; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1338: + yy1344: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1339; + goto yy1345; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1339: + yy1345: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1340; + goto yy1346; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1340: + yy1346: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1341; + goto yy1347; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1341: + yy1347: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1342; + goto yy1348; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1342: + yy1348: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1343; + goto yy1349; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1343: + yy1349: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1344; + goto yy1350; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1344: + yy1350: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1345; + goto yy1351; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1345: + yy1351: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1346; + goto yy1352; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1346: + yy1352: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1347; + goto yy1353; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1347: + yy1353: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1348; + goto yy1354; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1348: + yy1354: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1349; + goto yy1355; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1349: + yy1355: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1350; + goto yy1356; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1350: + yy1356: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1351; + goto yy1357; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1351: + yy1357: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1352; + goto yy1358; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1352: + yy1358: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1353; + goto yy1359; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1353: + yy1359: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1354; + goto yy1360; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1354: + yy1360: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1355; + goto yy1361; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1355: + yy1361: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1356; + goto yy1362; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1356: + yy1362: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1357; + goto yy1363; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1357: + yy1363: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1358; + goto yy1364; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1358: + yy1364: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1359; + goto yy1365; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1359: + yy1365: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1360; + goto yy1366; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1360: + yy1366: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1361; + goto yy1367; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1361: + yy1367: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1362; + goto yy1368; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1362: + yy1368: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1363; + goto yy1369; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1363: + yy1369: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1364; + goto yy1370; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1364: + yy1370: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1365; + goto yy1371; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= '{') - goto yy1324; + goto yy1330; } } - yy1365: + yy1371: yych = *++p; if (yych == ';') - goto yy1334; - goto yy1324; - yy1366: + goto yy1340; + goto yy1330; + yy1372: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1374; - goto yy1324; + goto yy1380; + goto yy1330; } else { if (yych <= 'F') - goto yy1374; + goto yy1380; if (yych <= '`') - goto yy1324; + goto yy1330; if (yych <= 'f') - goto yy1374; - goto yy1324; + goto yy1380; + goto yy1330; } - yy1367: + yy1373: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1368; + goto yy1374; if (yych == ';') - goto yy1334; - goto yy1324; - yy1368: + goto yy1340; + goto yy1330; + yy1374: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1369; + goto yy1375; if (yych == ';') - goto yy1334; - goto yy1324; - yy1369: + goto yy1340; + goto yy1330; + yy1375: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1370; + goto yy1376; if (yych == ';') - goto yy1334; - goto yy1324; - yy1370: + goto yy1340; + goto yy1330; + yy1376: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1371; + goto yy1377; if (yych == ';') - goto yy1334; - goto yy1324; - yy1371: + goto yy1340; + goto yy1330; + yy1377: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1372; + goto yy1378; if (yych == ';') - goto yy1334; - goto yy1324; - yy1372: + goto yy1340; + goto yy1330; + yy1378: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1373; + goto yy1379; if (yych == ';') - goto yy1334; - goto yy1324; - yy1373: + goto yy1340; + goto yy1330; + yy1379: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1365; + goto yy1371; if (yych == ';') - goto yy1334; - goto yy1324; - yy1374: + goto yy1340; + goto yy1330; + yy1380: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1375; + goto yy1381; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= 'g') - goto yy1324; + goto yy1330; } } - yy1375: + yy1381: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1376; + goto yy1382; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= 'g') - goto yy1324; + goto yy1330; } } - yy1376: + yy1382: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1377; + goto yy1383; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= 'g') - goto yy1324; + goto yy1330; } } - yy1377: + yy1383: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1378; + goto yy1384; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= 'g') - goto yy1324; + goto yy1330; } } - yy1378: + yy1384: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1379; + goto yy1385; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= 'g') - goto yy1324; + goto yy1330; } } - yy1379: + yy1385: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1380; + goto yy1386; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1330; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych >= 'g') - goto yy1324; + goto yy1330; } } - yy1380: + yy1386: ++p; if ((yych = *p) <= ';') { if (yych <= '/') - goto yy1324; + goto yy1330; if (yych <= '9') - goto yy1365; + goto yy1371; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1330; + goto yy1340; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; - goto yy1365; + goto yy1330; + goto yy1371; } else { if (yych <= '`') - goto yy1324; + goto yy1330; if (yych <= 'f') - goto yy1365; - goto yy1324; + goto yy1371; + goto yy1330; } } } @@ -20849,415 +20660,415 @@ bufsize_t _scan_dangerous_url(const unsigned char *p) { if (yych <= 'I') { if (yych <= 'C') { if (yych != '\n') - goto yy1388; + goto yy1394; } else { if (yych <= 'D') - goto yy1384; + goto yy1390; if (yych == 'F') - goto yy1387; - goto yy1388; + goto yy1393; + goto yy1394; } } else { if (yych <= 'V') { if (yych <= 'J') - goto yy1385; + goto yy1391; if (yych <= 'U') - goto yy1388; - goto yy1386; + goto yy1394; + goto yy1392; } else { if (yych == 'd') - goto yy1384; + goto yy1390; if (yych <= 'e') - goto yy1388; - goto yy1387; + goto yy1394; + goto yy1393; } } } else { if (yych <= 0xDF) { if (yych <= 'u') { if (yych == 'j') - goto yy1385; - goto yy1388; + goto yy1391; + goto yy1394; } else { if (yych <= 'v') - goto yy1386; + goto yy1392; if (yych <= 0x7F) - goto yy1388; + goto yy1394; if (yych >= 0xC2) - goto yy1389; + goto yy1395; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1391; + goto yy1397; if (yych == 0xED) - goto yy1396; - goto yy1392; + goto yy1402; + goto yy1398; } else { if (yych <= 0xF0) - goto yy1393; + goto yy1399; if (yych <= 0xF3) - goto yy1394; + goto yy1400; if (yych <= 0xF4) - goto yy1395; + goto yy1401; } } } - yy1383 : { return 0; } - yy1384: + yy1389 : { return 0; } + yy1390: yyaccept = 0; yych = *(marker = ++p); if (yych == 'A') - goto yy1418; + goto yy1424; if (yych == 'a') - goto yy1418; - goto yy1383; - yy1385: + goto yy1424; + goto yy1389; + yy1391: yyaccept = 0; yych = *(marker = ++p); if (yych == 'A') - goto yy1409; + goto yy1415; if (yych == 'a') - goto yy1409; - goto yy1383; - yy1386: + goto yy1415; + goto yy1389; + yy1392: yyaccept = 0; yych = *(marker = ++p); if (yych == 'B') - goto yy1402; + goto yy1408; if (yych == 'b') - goto yy1402; - goto yy1383; - yy1387: + goto yy1408; + goto yy1389; + yy1393: yyaccept = 0; yych = *(marker = ++p); if (yych == 'I') - goto yy1397; + goto yy1403; if (yych == 'i') - goto yy1397; - goto yy1383; - yy1388: + goto yy1403; + goto yy1389; + yy1394: yych = *++p; - goto yy1383; - yy1389: + goto yy1389; + yy1395: yych = *++p; if (yych <= 0x7F) - goto yy1390; + goto yy1396; if (yych <= 0xBF) - goto yy1388; - yy1390: + goto yy1394; + yy1396: p = marker; if (yyaccept == 0) { - goto yy1383; + goto yy1389; } else { - goto yy1401; + goto yy1407; } - yy1391: + yy1397: yych = *++p; if (yych <= 0x9F) - goto yy1390; + goto yy1396; if (yych <= 0xBF) - goto yy1389; - goto yy1390; - yy1392: + goto yy1395; + goto yy1396; + yy1398: yych = *++p; if (yych <= 0x7F) - goto yy1390; + goto yy1396; if (yych <= 0xBF) - goto yy1389; - goto yy1390; - yy1393: + goto yy1395; + goto yy1396; + yy1399: yych = *++p; if (yych <= 0x8F) - goto yy1390; + goto yy1396; if (yych <= 0xBF) - goto yy1392; - goto yy1390; - yy1394: + goto yy1398; + goto yy1396; + yy1400: yych = *++p; if (yych <= 0x7F) - goto yy1390; + goto yy1396; if (yych <= 0xBF) - goto yy1392; - goto yy1390; - yy1395: + goto yy1398; + goto yy1396; + yy1401: yych = *++p; if (yych <= 0x7F) - goto yy1390; + goto yy1396; if (yych <= 0x8F) - goto yy1392; - goto yy1390; - yy1396: + goto yy1398; + goto yy1396; + yy1402: yych = *++p; if (yych <= 0x7F) - goto yy1390; + goto yy1396; if (yych <= 0x9F) - goto yy1389; - goto yy1390; - yy1397: + goto yy1395; + goto yy1396; + yy1403: yych = *++p; if (yych == 'L') - goto yy1398; + goto yy1404; if (yych != 'l') - goto yy1390; - yy1398: + goto yy1396; + yy1404: yych = *++p; if (yych == 'E') - goto yy1399; + goto yy1405; if (yych != 'e') - goto yy1390; - yy1399: + goto yy1396; + yy1405: yych = *++p; if (yych != ':') - goto yy1390; - yy1400: + goto yy1396; + yy1406: ++p; - yy1401 : { return (bufsize_t)(p - start); } - yy1402: + yy1407 : { return (bufsize_t)(p - start); } + yy1408: yych = *++p; if (yych == 'S') - goto yy1403; + goto yy1409; if (yych != 's') - goto yy1390; - yy1403: + goto yy1396; + yy1409: yych = *++p; if (yych == 'C') - goto yy1404; + goto yy1410; if (yych != 'c') - goto yy1390; - yy1404: + goto yy1396; + yy1410: yych = *++p; if (yych == 'R') - goto yy1405; + goto yy1411; if (yych != 'r') - goto yy1390; - yy1405: + goto yy1396; + yy1411: yych = *++p; if (yych == 'I') - goto yy1406; + goto yy1412; if (yych != 'i') - goto yy1390; - yy1406: + goto yy1396; + yy1412: yych = *++p; if (yych == 'P') - goto yy1407; + goto yy1413; if (yych != 'p') - goto yy1390; - yy1407: + goto yy1396; + yy1413: yych = *++p; if (yych == 'T') - goto yy1408; + goto yy1414; if (yych != 't') - goto yy1390; - yy1408: + goto yy1396; + yy1414: yych = *++p; if (yych == ':') - goto yy1400; - goto yy1390; - yy1409: + goto yy1406; + goto yy1396; + yy1415: yych = *++p; if (yych == 'V') - goto yy1410; + goto yy1416; if (yych != 'v') - goto yy1390; - yy1410: + goto yy1396; + yy1416: yych = *++p; if (yych == 'A') - goto yy1411; + goto yy1417; if (yych != 'a') - goto yy1390; - yy1411: + goto yy1396; + yy1417: yych = *++p; if (yych == 'S') - goto yy1412; + goto yy1418; if (yych != 's') - goto yy1390; - yy1412: + goto yy1396; + yy1418: yych = *++p; if (yych == 'C') - goto yy1413; + goto yy1419; if (yych != 'c') - goto yy1390; - yy1413: + goto yy1396; + yy1419: yych = *++p; if (yych == 'R') - goto yy1414; + goto yy1420; if (yych != 'r') - goto yy1390; - yy1414: + goto yy1396; + yy1420: yych = *++p; if (yych == 'I') - goto yy1415; + goto yy1421; if (yych != 'i') - goto yy1390; - yy1415: + goto yy1396; + yy1421: yych = *++p; if (yych == 'P') - goto yy1416; + goto yy1422; if (yych != 'p') - goto yy1390; - yy1416: + goto yy1396; + yy1422: yych = *++p; if (yych == 'T') - goto yy1417; + goto yy1423; if (yych != 't') - goto yy1390; - yy1417: + goto yy1396; + yy1423: yych = *++p; if (yych == ':') - goto yy1400; - goto yy1390; - yy1418: + goto yy1406; + goto yy1396; + yy1424: yych = *++p; if (yych == 'T') - goto yy1419; + goto yy1425; if (yych != 't') - goto yy1390; - yy1419: + goto yy1396; + yy1425: yych = *++p; if (yych == 'A') - goto yy1420; + goto yy1426; if (yych != 'a') - goto yy1390; - yy1420: + goto yy1396; + yy1426: yych = *++p; if (yych != ':') - goto yy1390; + goto yy1396; yyaccept = 1; yych = *(marker = ++p); if (yych == 'I') - goto yy1422; + goto yy1428; if (yych != 'i') - goto yy1401; - yy1422: + goto yy1407; + yy1428: yych = *++p; if (yych == 'M') - goto yy1423; + goto yy1429; if (yych != 'm') - goto yy1390; - yy1423: + goto yy1396; + yy1429: yych = *++p; if (yych == 'A') - goto yy1424; + goto yy1430; if (yych != 'a') - goto yy1390; - yy1424: + goto yy1396; + yy1430: yych = *++p; if (yych == 'G') - goto yy1425; + goto yy1431; if (yych != 'g') - goto yy1390; - yy1425: + goto yy1396; + yy1431: yych = *++p; if (yych == 'E') - goto yy1426; + goto yy1432; if (yych != 'e') - goto yy1390; - yy1426: + goto yy1396; + yy1432: yych = *++p; if (yych != '/') - goto yy1390; + goto yy1396; yych = *++p; if (yych <= 'W') { if (yych <= 'J') { if (yych == 'G') - goto yy1429; + goto yy1435; if (yych <= 'I') - goto yy1390; - goto yy1430; + goto yy1396; + goto yy1436; } else { if (yych == 'P') - goto yy1428; + goto yy1434; if (yych <= 'V') - goto yy1390; - goto yy1431; + goto yy1396; + goto yy1437; } } else { if (yych <= 'j') { if (yych == 'g') - goto yy1429; + goto yy1435; if (yych <= 'i') - goto yy1390; - goto yy1430; + goto yy1396; + goto yy1436; } else { if (yych <= 'p') { if (yych <= 'o') - goto yy1390; + goto yy1396; } else { if (yych == 'w') - goto yy1431; - goto yy1390; + goto yy1437; + goto yy1396; } } } - yy1428: + yy1434: yych = *++p; if (yych == 'N') - goto yy1439; + goto yy1445; if (yych == 'n') - goto yy1439; - goto yy1390; - yy1429: + goto yy1445; + goto yy1396; + yy1435: yych = *++p; if (yych == 'I') - goto yy1438; + goto yy1444; if (yych == 'i') - goto yy1438; - goto yy1390; - yy1430: + goto yy1444; + goto yy1396; + yy1436: yych = *++p; if (yych == 'P') - goto yy1436; + goto yy1442; if (yych == 'p') - goto yy1436; - goto yy1390; - yy1431: + goto yy1442; + goto yy1396; + yy1437: yych = *++p; if (yych == 'E') - goto yy1432; + goto yy1438; if (yych != 'e') - goto yy1390; - yy1432: + goto yy1396; + yy1438: yych = *++p; if (yych == 'B') - goto yy1433; + goto yy1439; if (yych != 'b') - goto yy1390; - yy1433: + goto yy1396; + yy1439: yych = *++p; if (yych == 'P') - goto yy1434; + goto yy1440; if (yych != 'p') - goto yy1390; - yy1434: + goto yy1396; + yy1440: ++p; { return 0; } - yy1436: + yy1442: yych = *++p; if (yych == 'E') - goto yy1437; + goto yy1443; if (yych != 'e') - goto yy1390; - yy1437: + goto yy1396; + yy1443: yych = *++p; if (yych == 'G') - goto yy1434; + goto yy1440; if (yych == 'g') - goto yy1434; - goto yy1390; - yy1438: + goto yy1440; + goto yy1396; + yy1444: yych = *++p; if (yych == 'F') - goto yy1434; + goto yy1440; if (yych == 'f') - goto yy1434; - goto yy1390; - yy1439: + goto yy1440; + goto yy1396; + yy1445: ++p; if ((yych = *p) == 'G') - goto yy1434; + goto yy1440; if (yych == 'g') - goto yy1434; - goto yy1390; + goto yy1440; + goto yy1396; } } diff --git a/xml.c b/xml.c index a06cdd3..12bd629 100644 --- a/xml.c +++ b/xml.c @@ -9,6 +9,8 @@ #include "buffer.h" #include "houdini.h" +#define BUFFER_SIZE 100 + // Functions to convert cmark_nodes to XML strings. static void escape_xml(cmark_strbuf *dest, const unsigned char *source, @@ -21,7 +23,7 @@ struct render_state { int indent; }; -static inline void indent(struct render_state *state) { +static CMARK_INLINE void indent(struct render_state *state) { int i; for (i = 0; i < state->indent; i++) { cmark_strbuf_putc(state->xml, ' '); @@ -34,7 +36,7 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, bool literal = false; cmark_delim_type delim; bool entering = (ev_type == CMARK_EVENT_ENTER); - char buffer[100]; + char buffer[BUFFER_SIZE]; if (entering) { indent(state); @@ -42,8 +44,9 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, cmark_strbuf_puts(xml, cmark_node_get_type_string(node)); if (options & CMARK_OPT_SOURCEPOS && node->start_line != 0) { - sprintf(buffer, " sourcepos=\"%d:%d-%d:%d\"", node->start_line, - node->start_column, node->end_line, node->end_column); + snprintf(buffer, BUFFER_SIZE, " sourcepos=\"%d:%d-%d:%d\"", + node->start_line, node->start_column, node->end_line, + node->end_column); cmark_strbuf_puts(xml, buffer); } @@ -67,7 +70,8 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, switch (cmark_node_get_list_type(node)) { case CMARK_ORDERED_LIST: cmark_strbuf_puts(xml, " type=\"ordered\""); - sprintf(buffer, " start=\"%d\"", cmark_node_get_list_start(node)); + snprintf(buffer, BUFFER_SIZE, " start=\"%d\"", + cmark_node_get_list_start(node)); cmark_strbuf_puts(xml, buffer); delim = cmark_node_get_list_delim(node); if (delim == CMARK_PAREN_DELIM) { @@ -82,12 +86,12 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, default: break; } - sprintf(buffer, " tight=\"%s\"", - (cmark_node_get_list_tight(node) ? "true" : "false")); + snprintf(buffer, BUFFER_SIZE, " tight=\"%s\"", + (cmark_node_get_list_tight(node) ? "true" : "false")); cmark_strbuf_puts(xml, buffer); break; case CMARK_NODE_HEADING: - sprintf(buffer, " level=\"%d\"", node->as.heading.level); + snprintf(buffer, BUFFER_SIZE, " level=\"%d\"", node->as.heading.level); cmark_strbuf_puts(xml, buffer); break; case CMARK_NODE_CODE_BLOCK: From baf45d40250496d71f6431a5361c52b6d1f63c5c Mon Sep 17 00:00:00 2001 From: James Adam Date: Sat, 16 Jul 2016 16:42:30 -0700 Subject: [PATCH 23/26] updated to cmark 0.26.1 --- blocks.c | 526 ++++++------ buffer.c | 77 +- buffer.h | 29 +- chunk.h | 45 +- cmark.c | 16 + cmark.h | 52 +- cmark_ctype.c | 2 + cmark_ctype.h | 2 + cmark_version.h | 4 +- commonmark.c | 71 +- html.c | 4 +- inlines.c | 383 ++++----- inlines.h | 10 +- iterator.c | 13 +- iterator.h | 2 + latex.c | 18 +- man.c | 14 +- node.c | 64 +- node.h | 26 +- parser.h | 6 +- references.c | 48 +- references.h | 4 +- render.c | 23 +- render.h | 4 +- scanners.c | 2093 ++++++++++++++++++++++++----------------------- scanners.re | 8 +- xml.c | 2 +- 27 files changed, 1813 insertions(+), 1733 deletions(-) diff --git a/blocks.c b/blocks.c index f49ad4e..8e8c4c2 100644 --- a/blocks.c +++ b/blocks.c @@ -30,6 +30,21 @@ #define peek_at(i, n) (i)->data[n] +static bool S_last_line_blank(const cmark_node *node) { + return (node->flags & CMARK_NODE__LAST_LINE_BLANK) != 0; +} + +static CMARK_INLINE cmark_node_type S_type(const cmark_node *node) { + return (cmark_node_type)node->type; +} + +static void S_set_last_line_blank(cmark_node *node, bool is_blank) { + if (is_blank) + node->flags |= CMARK_NODE__LAST_LINE_BLANK; + else + node->flags &= ~CMARK_NODE__LAST_LINE_BLANK; +} + static CMARK_INLINE bool S_is_line_end_char(char c) { return (c == '\n' || c == '\r'); } @@ -44,38 +59,37 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, static void S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t bytes); -static cmark_node *make_block(cmark_node_type tag, int start_line, - int start_column) { +static cmark_node *make_block(cmark_mem *mem, 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); - } + e = (cmark_node *)mem->calloc(1, sizeof(*e)); + cmark_strbuf_init(mem, &e->content, 32); + e->type = (uint16_t)tag; + e->flags = CMARK_NODE__OPEN; + e->start_line = start_line; + e->start_column = start_column; + e->end_line = start_line; return e; } // Create a root document node. -static cmark_node *make_document() { - cmark_node *e = make_block(CMARK_NODE_DOCUMENT, 1, 1); +static cmark_node *make_document(cmark_mem *mem) { + cmark_node *e = make_block(mem, CMARK_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(); +cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem) { + cmark_parser *parser = (cmark_parser *)mem->calloc(1, sizeof(cmark_parser)); + parser->mem = mem; + + cmark_node *document = make_document(mem); + + cmark_strbuf_init(mem, &parser->curline, 256); + cmark_strbuf_init(mem, &parser->linebuf, 0); + + parser->refmap = cmark_reference_map_new(mem); parser->root = document; parser->current = document; parser->line_number = 0; @@ -86,22 +100,24 @@ cmark_parser *cmark_parser_new(int options) { parser->indent = 0; parser->blank = false; parser->partially_consumed_tab = false; - parser->curline = line; parser->last_line_length = 0; - parser->linebuf = buf; parser->options = options; parser->last_buffer_ended_with_cr = false; return parser; } +cmark_parser *cmark_parser_new(int options) { + extern cmark_mem DEFAULT_MEM_ALLOCATOR; + return cmark_parser_new_with_mem(options, &DEFAULT_MEM_ALLOCATOR); +} + void cmark_parser_free(cmark_parser *parser) { - cmark_strbuf_free(parser->curline); - free(parser->curline); - cmark_strbuf_free(parser->linebuf); - free(parser->linebuf); + cmark_mem *mem = parser->mem; + cmark_strbuf_free(&parser->curline); + cmark_strbuf_free(&parser->linebuf); cmark_reference_map_free(parser->refmap); - free(parser); + mem->free(parser); } static cmark_node *finalize(cmark_parser *parser, cmark_node *b); @@ -128,7 +144,7 @@ static bool is_blank(cmark_strbuf *s, bufsize_t offset) { } static CMARK_INLINE bool can_contain(cmark_node_type parent_type, - cmark_node_type child_type) { + cmark_node_type child_type) { return (parent_type == CMARK_NODE_DOCUMENT || parent_type == CMARK_NODE_BLOCK_QUOTE || parent_type == CMARK_NODE_ITEM || @@ -149,18 +165,17 @@ static CMARK_INLINE bool contains_inlines(cmark_node_type block_type) { static void add_line(cmark_node *node, cmark_chunk *ch, cmark_parser *parser) { int chars_to_tab; int i; - assert(node->open); + assert(node->flags & CMARK_NODE__OPEN); if (parser->partially_consumed_tab) { parser->offset += 1; // skip over tab // add space characters: chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); for (i = 0; i < chars_to_tab; i++) { - cmark_strbuf_putc(&node->string_content, ' '); + cmark_strbuf_putc(&node->content, ' '); } } - cmark_strbuf_put(&node->string_content, - ch->data + parser->offset, - ch->len - parser->offset); + cmark_strbuf_put(&node->content, ch->data + parser->offset, + ch->len - parser->offset); } static void remove_trailing_blank_lines(cmark_strbuf *ln) { @@ -195,10 +210,10 @@ static void remove_trailing_blank_lines(cmark_strbuf *ln) { static bool ends_with_blank_line(cmark_node *node) { cmark_node *cur = node; while (cur != NULL) { - if (cur->last_line_blank) { + if (S_last_line_blank(cur)) { return true; } - if (cur->type == CMARK_NODE_LIST || cur->type == CMARK_NODE_ITEM) { + if (S_type(cur) == CMARK_NODE_LIST || S_type(cur) == CMARK_NODE_ITEM) { cur = cur->last_child; } else { cur = NULL; @@ -207,24 +222,6 @@ static bool ends_with_blank_line(cmark_node *node) { 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 != CMARK_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) { bufsize_t pos; cmark_node *item; @@ -232,37 +229,39 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { cmark_node *parent; parent = b->parent; + assert(b->flags & + CMARK_NODE__OPEN); // shouldn't call finalize on closed blocks + b->flags &= ~CMARK_NODE__OPEN; - assert(b->open); // shouldn't call finalize on closed blocks - b->open = false; - - if (parser->curline->size == 0) { + 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 == CMARK_NODE_DOCUMENT || - (b->type == CMARK_NODE_CODE_BLOCK && b->as.code.fenced) || - (b->type == CMARK_NODE_HEADING && b->as.heading.setext)) { + } else if (S_type(b) == CMARK_NODE_DOCUMENT || + (S_type(b) == CMARK_NODE_CODE_BLOCK && b->as.code.fenced) || + (S_type(b) == CMARK_NODE_HEADING && b->as.heading.setext)) { b->end_line = parser->line_number; - b->end_column = parser->curline->size; - if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\n') + b->end_column = parser->curline.size; + if (b->end_column && parser->curline.ptr[b->end_column - 1] == '\n') b->end_column -= 1; - if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\r') + if (b->end_column && parser->curline.ptr[b->end_column - 1] == '\r') b->end_column -= 1; } else { b->end_line = parser->line_number - 1; b->end_column = parser->last_line_length; } - switch (b->type) { + cmark_strbuf *node_content = &b->content; + + switch (S_type(b)) { case CMARK_NODE_PARAGRAPH: - while (cmark_strbuf_at(&b->string_content, 0) == '[' && - (pos = cmark_parse_reference_inline(&b->string_content, + while (cmark_strbuf_at(node_content, 0) == '[' && + (pos = cmark_parse_reference_inline(parser->mem, node_content, parser->refmap))) { - cmark_strbuf_drop(&b->string_content, pos); + cmark_strbuf_drop(node_content, pos); } - if (is_blank(&b->string_content, 0)) { + if (is_blank(node_content, 0)) { // remove blank node (former reference def) cmark_node_free(b); } @@ -270,34 +269,33 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { case CMARK_NODE_CODE_BLOCK: if (!b->as.code.fenced) { // indented code - remove_trailing_blank_lines(&b->string_content); - cmark_strbuf_putc(&b->string_content, '\n'); + remove_trailing_blank_lines(node_content); + cmark_strbuf_putc(node_content, '\n'); } else { - // first line of contents becomes info - for (pos = 0; pos < b->string_content.size; ++pos) { - if (S_is_line_end_char(b->string_content.ptr[pos])) + for (pos = 0; pos < node_content->size; ++pos) { + if (S_is_line_end_char(node_content->ptr[pos])) break; } - assert(pos < b->string_content.size); + assert(pos < node_content->size); - cmark_strbuf tmp = GH_BUF_INIT; - houdini_unescape_html_f(&tmp, b->string_content.ptr, pos); + cmark_strbuf tmp = CMARK_BUF_INIT(parser->mem); + houdini_unescape_html_f(&tmp, node_content->ptr, pos); cmark_strbuf_trim(&tmp); cmark_strbuf_unescape(&tmp); b->as.code.info = cmark_chunk_buf_detach(&tmp); - if (b->string_content.ptr[pos] == '\r') + if (node_content->ptr[pos] == '\r') pos += 1; - if (b->string_content.ptr[pos] == '\n') + if (node_content->ptr[pos] == '\n') pos += 1; - cmark_strbuf_drop(&b->string_content, pos); + cmark_strbuf_drop(node_content, pos); } - b->as.code.literal = cmark_chunk_buf_detach(&b->string_content); + b->as.code.literal = cmark_chunk_buf_detach(node_content); break; case CMARK_NODE_HTML_BLOCK: - b->as.literal = cmark_chunk_buf_detach(&b->string_content); + b->as.literal = cmark_chunk_buf_detach(node_content); break; case CMARK_NODE_LIST: // determine tight/loose status @@ -306,7 +304,7 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { while (item) { // check for non-final non-empty list item ending with blank line: - if (item->last_line_blank && item->next) { + if (S_last_line_blank(item) && item->next) { b->as.list.tight = false; break; } @@ -331,6 +329,7 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { default: break; } + return parent; } @@ -341,11 +340,12 @@ static cmark_node *add_child(cmark_parser *parser, cmark_node *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)) { + while (!can_contain(S_type(parent), block_type)) { parent = finalize(parser, parent); } - cmark_node *child = make_block(block_type, parser->line_number, start_column); + cmark_node *child = + make_block(parser->mem, block_type, parser->line_number, start_column); child->parent = parent; if (parent->last_child) { @@ -361,8 +361,8 @@ static cmark_node *add_child(cmark_parser *parser, cmark_node *parent, // 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) { +static void process_inlines(cmark_mem *mem, cmark_node *root, + cmark_reference_map *refmap, int options) { cmark_iter *iter = cmark_iter_new(root); cmark_node *cur; cmark_event_type ev_type; @@ -370,8 +370,8 @@ static void process_inlines(cmark_node *root, cmark_reference_map *refmap, while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { cur = cmark_iter_get_node(iter); if (ev_type == CMARK_EVENT_ENTER) { - if (contains_inlines(cur->type)) { - cmark_parse_inlines(cur, refmap, options); + if (contains_inlines(S_type(cur))) { + cmark_parse_inlines(mem, cur, refmap, options); } } } @@ -382,11 +382,13 @@ static void process_inlines(cmark_node *root, cmark_reference_map *refmap, // 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 bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos, +static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input, + bufsize_t pos, bool interrupts_paragraph, cmark_list **dataptr) { unsigned char c; bufsize_t startpos; cmark_list *data; + bufsize_t i; startpos = pos; c = peek_at(input, pos); @@ -396,17 +398,25 @@ static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t 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; + + if (interrupts_paragraph) { + i = pos; + // require non-blank content after list marker: + while (S_is_space_or_tab(peek_at(input, i))) { + i++; + } + if (peek_at(input, i) == '\n') { + return 0; + } } + + data = (cmark_list *)mem->calloc(1, sizeof(*data)); + 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; int digits = 0; @@ -420,27 +430,36 @@ static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos, // This also seems to be the limit for 'start' in some browsers. } while (digits < 9 && cmark_isdigit(peek_at(input, pos))); + if (interrupts_paragraph && start != 1) { + return 0; + } 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; + if (interrupts_paragraph) { + // require non-blank content after list marker: + i = pos; + while (S_is_space_or_tab(peek_at(input, i))) { + i++; + } + if (S_is_line_end_char(peek_at(input, i))) { + return 0; + } } + + data = (cmark_list *)mem->calloc(1, sizeof(*data)); + 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; } @@ -463,7 +482,7 @@ static cmark_node *finalize_document(cmark_parser *parser) { } finalize(parser, parser->root); - process_inlines(parser->root, parser->refmap, parser->options); + process_inlines(parser->mem, parser->root, parser->refmap, parser->options); return parser->root; } @@ -529,24 +548,24 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, process = true; } - chunk_len = cmark_strbuf_check_bufsize(eol - buffer); + chunk_len = (eol - buffer); if (process) { - if (parser->linebuf->size > 0) { - cmark_strbuf_put(parser->linebuf, buffer, chunk_len); - S_process_line(parser, parser->linebuf->ptr, parser->linebuf->size); - cmark_strbuf_clear(parser->linebuf); + if (parser->linebuf.size > 0) { + cmark_strbuf_put(&parser->linebuf, buffer, chunk_len); + S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size); + cmark_strbuf_clear(&parser->linebuf); } else { S_process_line(parser, buffer, chunk_len); } } else { if (eol < end && *eol == '\0') { // omit NULL byte - cmark_strbuf_put(parser->linebuf, buffer, chunk_len); + cmark_strbuf_put(&parser->linebuf, buffer, chunk_len); // add replacement character - cmark_strbuf_put(parser->linebuf, repl, 3); + cmark_strbuf_put(&parser->linebuf, repl, 3); chunk_len += 1; // so we advance the buffer past NULL } else { - cmark_strbuf_put(parser->linebuf, buffer, chunk_len); + cmark_strbuf_put(&parser->linebuf, buffer, chunk_len); } } @@ -555,7 +574,7 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, if (buffer < end && *buffer == '\r') { buffer++; if (buffer == end) - parser->last_buffer_ended_with_cr = true; + parser->last_buffer_ended_with_cr = true; } if (buffer < end && *buffer == '\n') buffer++; @@ -627,16 +646,16 @@ static void S_advance_offset(cmark_parser *parser, cmark_chunk *input, if (c == '\t') { chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); if (columns) { - parser->partially_consumed_tab = chars_to_tab > count; - chars_to_advance = MIN(count, chars_to_tab); - parser->column += chars_to_advance; + parser->partially_consumed_tab = chars_to_tab > count; + chars_to_advance = MIN(count, chars_to_tab); + parser->column += chars_to_advance; parser->offset += (parser->partially_consumed_tab ? 0 : 1); - count -= chars_to_advance; + count -= chars_to_advance; } else { - parser->partially_consumed_tab = false; - parser->column += chars_to_tab; - parser->offset += 1; - count -= 1; + parser->partially_consumed_tab = false; + parser->column += chars_to_tab; + parser->offset += 1; + count -= 1; } } else { parser->partially_consumed_tab = false; @@ -648,12 +667,11 @@ static void S_advance_offset(cmark_parser *parser, cmark_chunk *input, } static bool S_last_child_is_open(cmark_node *container) { - return container->last_child && container->last_child->open; + return container->last_child && + (container->last_child->flags & CMARK_NODE__OPEN); } -static bool parse_block_quote_prefix(cmark_parser *parser, - cmark_chunk *input) -{ +static bool parse_block_quote_prefix(cmark_parser *parser, cmark_chunk *input) { bool res = false; bufsize_t matched = 0; @@ -672,34 +690,30 @@ static bool parse_block_quote_prefix(cmark_parser *parser, return res; } -static bool parse_node_item_prefix(cmark_parser *parser, - cmark_chunk *input, - cmark_node *container) -{ +static bool parse_node_item_prefix(cmark_parser *parser, cmark_chunk *input, + cmark_node *container) { bool res = false; if (parser->indent >= container->as.list.marker_offset + container->as.list.padding) { S_advance_offset(parser, input, container->as.list.marker_offset + - container->as.list.padding, + container->as.list.padding, true); res = true; } else if (parser->blank && container->first_child != NULL) { // if container->first_child is NULL, then the opening line // of the list item was blank after the list marker; in this // case, we are done with the list item. - S_advance_offset(parser, input, - parser->first_nonspace - parser->offset, false); + S_advance_offset(parser, input, parser->first_nonspace - parser->offset, + false); res = true; } return res; } -static bool parse_code_block_prefix(cmark_parser *parser, - cmark_chunk *input, - cmark_node *container, - bool *should_continue) -{ +static bool parse_code_block_prefix(cmark_parser *parser, cmark_chunk *input, + cmark_node *container, + bool *should_continue) { bool res = false; if (!container->as.code.fenced) { // indented @@ -707,8 +721,8 @@ static bool parse_code_block_prefix(cmark_parser *parser, S_advance_offset(parser, input, CODE_INDENT, true); res = true; } else if (parser->blank) { - S_advance_offset(parser, input, - parser->first_nonspace - parser->offset, false); + S_advance_offset(parser, input, parser->first_nonspace - parser->offset, + false); res = true; } } else { // fenced @@ -741,25 +755,24 @@ static bool parse_code_block_prefix(cmark_parser *parser, } static bool parse_html_block_prefix(cmark_parser *parser, - cmark_node *container) -{ + cmark_node *container) { bool res = false; int html_block_type = container->as.html_block_type; assert(html_block_type >= 1 && html_block_type <= 7); switch (html_block_type) { - case 1: - case 2: - case 3: - case 4: - case 5: - // these types of blocks can accept blanks - res = true; - break; - case 6: - case 7: - res = !parser->blank; - break; + case 1: + case 2: + case 3: + case 4: + case 5: + // these types of blocks can accept blanks + res = true; + break; + case 6: + case 7: + res = !parser->blank; + break; } return res; @@ -773,10 +786,8 @@ static bool parse_html_block_prefix(cmark_parser *parser, * * Returns: The last matching node, or NULL */ -static cmark_node *check_open_blocks(cmark_parser *parser, - cmark_chunk *input, - bool *all_matched) -{ +static cmark_node *check_open_blocks(cmark_parser *parser, cmark_chunk *input, + bool *all_matched) { bool should_continue = true; *all_matched = false; cmark_node *container = parser->root; @@ -784,36 +795,36 @@ static cmark_node *check_open_blocks(cmark_parser *parser, while (S_last_child_is_open(container)) { container = container->last_child; - cont_type = container->type; + cont_type = S_type(container); S_find_first_nonspace(parser, input); switch (cont_type) { - case CMARK_NODE_BLOCK_QUOTE: - if (!parse_block_quote_prefix(parser, input)) - goto done; - break; - case CMARK_NODE_ITEM: - if (!parse_node_item_prefix(parser, input, container)) - goto done; - break; - case CMARK_NODE_CODE_BLOCK: - if (!parse_code_block_prefix(parser, input, container, &should_continue)) - goto done; - break; - case CMARK_NODE_HEADING: - // a heading can never contain more than one line + case CMARK_NODE_BLOCK_QUOTE: + if (!parse_block_quote_prefix(parser, input)) goto done; - case CMARK_NODE_HTML_BLOCK: - if (!parse_html_block_prefix(parser, container)) - goto done; - break; - case CMARK_NODE_PARAGRAPH: - if (parser->blank) - goto done; - break; - default: - break; + break; + case CMARK_NODE_ITEM: + if (!parse_node_item_prefix(parser, input, container)) + goto done; + break; + case CMARK_NODE_CODE_BLOCK: + if (!parse_code_block_prefix(parser, input, container, &should_continue)) + goto done; + break; + case CMARK_NODE_HEADING: + // a heading can never contain more than one line + goto done; + case CMARK_NODE_HTML_BLOCK: + if (!parse_html_block_prefix(parser, container)) + goto done; + break; + case CMARK_NODE_PARAGRAPH: + if (parser->blank) + goto done; + break; + default: + break; } } @@ -831,15 +842,12 @@ static cmark_node *check_open_blocks(cmark_parser *parser, return container; } -static void open_new_blocks(cmark_parser *parser, - cmark_node **container, - cmark_chunk *input, - bool all_matched) -{ +static void open_new_blocks(cmark_parser *parser, cmark_node **container, + cmark_chunk *input, bool all_matched) { bool indented; cmark_list *data = NULL; - bool maybe_lazy = parser->current->type == CMARK_NODE_PARAGRAPH; - cmark_node_type cont_type = (*container)->type; + bool maybe_lazy = S_type(parser->current) == CMARK_NODE_PARAGRAPH; + cmark_node_type cont_type = S_type(*container); bufsize_t matched = 0; int lev = 0; bool save_partially_consumed_tab; @@ -854,6 +862,8 @@ static void open_new_blocks(cmark_parser *parser, if (!indented && peek_at(input, parser->first_nonspace) == '>') { + bufsize_t blockquote_startpos = parser->first_nonspace; + S_advance_offset(parser, input, parser->first_nonspace + 1 - parser->offset, false); // optional following character @@ -861,18 +871,19 @@ static void open_new_blocks(cmark_parser *parser, S_advance_offset(parser, input, 1, true); } *container = add_child(parser, *container, CMARK_NODE_BLOCK_QUOTE, - parser->offset + 1); + blockquote_startpos + 1); } else if (!indented && (matched = scan_atx_heading_start( input, parser->first_nonspace))) { bufsize_t hashpos; int level = 0; + bufsize_t heading_startpos = parser->first_nonspace; S_advance_offset(parser, input, parser->first_nonspace + matched - parser->offset, false); - *container = - add_child(parser, *container, CMARK_NODE_HEADING, parser->offset + 1); + *container = add_child(parser, *container, CMARK_NODE_HEADING, + heading_startpos + 1); hashpos = cmark_chunk_strchr(input, '#', parser->first_nonspace); @@ -887,10 +898,10 @@ static void open_new_blocks(cmark_parser *parser, } else if (!indented && (matched = scan_open_code_fence( input, parser->first_nonspace))) { *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK, - parser->first_nonspace + 1); + parser->first_nonspace + 1); (*container)->as.code.fenced = true; (*container)->as.code.fence_char = peek_at(input, parser->first_nonspace); - (*container)->as.code.fence_length = matched; + (*container)->as.code.fence_length = (matched > 255) ? 255 : matched; (*container)->as.code.fence_offset = (int8_t)(parser->first_nonspace - parser->offset); (*container)->as.code.info = cmark_chunk_literal(""); @@ -904,28 +915,29 @@ static void open_new_blocks(cmark_parser *parser, (matched = scan_html_block_start_7( input, parser->first_nonspace))))) { *container = add_child(parser, *container, CMARK_NODE_HTML_BLOCK, - parser->first_nonspace + 1); + parser->first_nonspace + 1); (*container)->as.html_block_type = matched; // note, we don't adjust parser->offset because the tag is part of the // text } else if (!indented && cont_type == CMARK_NODE_PARAGRAPH && (lev = scan_setext_heading_line(input, parser->first_nonspace))) { - (*container)->type = CMARK_NODE_HEADING; + (*container)->type = (uint16_t)CMARK_NODE_HEADING; (*container)->as.heading.level = lev; (*container)->as.heading.setext = true; S_advance_offset(parser, input, input->len - 1 - parser->offset, false); } else if (!indented && !(cont_type == CMARK_NODE_PARAGRAPH && !all_matched) && - (matched = - scan_thematic_break(input, parser->first_nonspace))) { + (matched = scan_thematic_break(input, parser->first_nonspace))) { // it's only now that we know the line is not part of a setext heading: *container = add_child(parser, *container, CMARK_NODE_THEMATIC_BREAK, - parser->first_nonspace + 1); + parser->first_nonspace + 1); S_advance_offset(parser, input, input->len - 1 - parser->offset, false); - } else if ((matched = - parse_list_marker(input, parser->first_nonspace, &data)) && + } else if ((matched = parse_list_marker( + parser->mem, input, parser->first_nonspace, + (*container)->type == CMARK_NODE_PARAGRAPH, &data)) && (!indented || cont_type == CMARK_NODE_LIST)) { + // Note that we can have new list items starting with >= 4 // spaces indent, as long as the list container is still open. int i = 0; @@ -940,16 +952,18 @@ static void open_new_blocks(cmark_parser *parser, save_column = parser->column; while (parser->column - save_column <= 5 && - S_is_space_or_tab(peek_at(input, parser->offset))) { + S_is_space_or_tab(peek_at(input, parser->offset))) { S_advance_offset(parser, input, 1, true); } i = parser->column - save_column; - if (i >= 5 || i < 1) { + if (i >= 5 || i < 1 || + // only spaces after list marker: + S_is_line_end_char(peek_at(input, parser->offset))) { data->padding = matched + 1; - parser->offset = save_offset; - parser->column = save_column; - parser->partially_consumed_tab = save_partially_consumed_tab; + parser->offset = save_offset; + parser->column = save_column; + parser->partially_consumed_tab = save_partially_consumed_tab; if (i > 0) { S_advance_offset(parser, input, 1, true); } @@ -965,21 +979,21 @@ static void open_new_blocks(cmark_parser *parser, if (cont_type != CMARK_NODE_LIST || !lists_match(&((*container)->as.list), data)) { *container = add_child(parser, *container, CMARK_NODE_LIST, - parser->first_nonspace + 1); + parser->first_nonspace + 1); memcpy(&((*container)->as.list), data, sizeof(*data)); } // add the list item *container = add_child(parser, *container, CMARK_NODE_ITEM, - parser->first_nonspace + 1); + parser->first_nonspace + 1); /* TODO: static */ memcpy(&((*container)->as.list), data, sizeof(*data)); free(data); } else if (indented && !maybe_lazy && !parser->blank) { S_advance_offset(parser, input, CODE_INDENT, true); *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK, - parser->offset + 1); + parser->offset + 1); (*container)->as.code.fenced = false; (*container)->as.code.fence_char = 0; (*container)->as.code.fence_length = 0; @@ -990,21 +1004,19 @@ static void open_new_blocks(cmark_parser *parser, break; } - if (accepts_lines((*container)->type)) { + if (accepts_lines(S_type(*container))) { // if it's a line container, it can't contain other containers break; } - cont_type = (*container)->type; + cont_type = S_type(*container); maybe_lazy = false; } } -static void add_text_to_container (cmark_parser *parser, - cmark_node *container, - cmark_node *last_matched_container, - cmark_chunk *input) -{ +static void add_text_to_container(cmark_parser *parser, cmark_node *container, + cmark_node *last_matched_container, + cmark_chunk *input) { cmark_node *tmp; // what remains at parser->offset is a text line. add the text to the // appropriate container. @@ -1012,24 +1024,25 @@ static void add_text_to_container (cmark_parser *parser, S_find_first_nonspace(parser, input); if (parser->blank && container->last_child) - container->last_child->last_line_blank = true; + S_set_last_line_blank(container->last_child, 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 = - (parser->blank && container->type != CMARK_NODE_BLOCK_QUOTE && - container->type != CMARK_NODE_HEADING && - container->type != CMARK_NODE_THEMATIC_BREAK && - !(container->type == CMARK_NODE_CODE_BLOCK && - container->as.code.fenced) && - !(container->type == CMARK_NODE_ITEM && container->first_child == NULL && + const cmark_node_type ctype = S_type(container); + const bool last_line_blank = + (parser->blank && ctype != CMARK_NODE_BLOCK_QUOTE && + ctype != CMARK_NODE_HEADING && ctype != CMARK_NODE_THEMATIC_BREAK && + !(ctype == CMARK_NODE_CODE_BLOCK && container->as.code.fenced) && + !(ctype == CMARK_NODE_ITEM && container->first_child == NULL && container->start_line == parser->line_number)); + S_set_last_line_blank(container, last_line_blank); + tmp = container; while (tmp->parent) { - tmp->parent->last_line_blank = false; + S_set_last_line_blank(tmp->parent, false); tmp = tmp->parent; } @@ -1040,9 +1053,8 @@ static void add_text_to_container (cmark_parser *parser, // then treat this as a "lazy continuation line" and add it to // the open paragraph. if (parser->current != last_matched_container && - container == last_matched_container && - !parser->blank && - parser->current->type == CMARK_NODE_PARAGRAPH) { + container == last_matched_container && !parser->blank && + S_type(parser->current) == CMARK_NODE_PARAGRAPH) { add_line(parser->current, input, parser); } else { // not a lazy continuation // Finalize any blocks that were not matched and set cur to container: @@ -1051,9 +1063,9 @@ static void add_text_to_container (cmark_parser *parser, assert(parser->current != NULL); } - if (container->type == CMARK_NODE_CODE_BLOCK) { + if (S_type(container) == CMARK_NODE_CODE_BLOCK) { add_line(container, input, parser); - } else if (container->type == CMARK_NODE_HTML_BLOCK) { + } else if (S_type(container) == CMARK_NODE_HTML_BLOCK) { add_line(container, input, parser); int matches_end_condition; @@ -1094,18 +1106,20 @@ static void add_text_to_container (cmark_parser *parser, } } else if (parser->blank) { // ??? do nothing - } else if (accepts_lines(container->type)) { - if (container->type == CMARK_NODE_HEADING && + } else if (accepts_lines(S_type(container))) { + if (S_type(container) == CMARK_NODE_HEADING && container->as.heading.setext == false) { chop_trailing_hashtags(input); } - S_advance_offset(parser, input, parser->first_nonspace - parser->offset, false); + S_advance_offset(parser, input, parser->first_nonspace - parser->offset, + false); add_line(container, input, parser); } else { // create paragraph container for line container = add_child(parser, container, CMARK_NODE_PARAGRAPH, parser->first_nonspace + 1); - S_advance_offset(parser, input, parser->first_nonspace - parser->offset, false); + S_advance_offset(parser, input, parser->first_nonspace - parser->offset, + false); add_line(container, input, parser); } @@ -1122,21 +1136,21 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, cmark_chunk input; if (parser->options & CMARK_OPT_VALIDATE_UTF8) - cmark_utf8proc_check(parser->curline, buffer, bytes); + cmark_utf8proc_check(&parser->curline, buffer, bytes); else - cmark_strbuf_put(parser->curline, buffer, bytes); + cmark_strbuf_put(&parser->curline, buffer, bytes); // ensure line ends with a newline: - if (bytes == 0 || !S_is_line_end_char(parser->curline->ptr[bytes - 1])) - cmark_strbuf_putc(parser->curline, '\n'); + if (bytes == 0 || !S_is_line_end_char(parser->curline.ptr[bytes - 1])) + cmark_strbuf_putc(&parser->curline, '\n'); parser->offset = 0; parser->column = 0; parser->blank = false; parser->partially_consumed_tab = false; - input.data = parser->curline->ptr; - input.len = parser->curline->size; + input.data = parser->curline.ptr; + input.len = parser->curline.size; parser->line_number++; @@ -1147,10 +1161,6 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, container = last_matched_container; - // check to see if we've hit 2nd blank line, break out of list: - if (parser->blank && container->last_line_blank) - break_out_of_lists(parser, &container); - open_new_blocks(parser, &container, &input, all_matched); add_text_to_container(parser, container, last_matched_container, &input); @@ -1164,13 +1174,13 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, input.data[parser->last_line_length - 1] == '\r') parser->last_line_length -= 1; - cmark_strbuf_clear(parser->curline); + 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); + if (parser->linebuf.size) { + S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size); + cmark_strbuf_clear(&parser->linebuf); } finalize_document(parser); @@ -1179,7 +1189,7 @@ cmark_node *cmark_parser_finish(cmark_parser *parser) { cmark_consolidate_text_nodes(parser->root); } - cmark_strbuf_free(parser->curline); + cmark_strbuf_free(&parser->curline); #if CMARK_DEBUG_NODES if (cmark_node_check(parser->root, stderr)) { diff --git a/buffer.c b/buffer.c index 4efa97b..a6754b6 100644 --- a/buffer.c +++ b/buffer.c @@ -5,10 +5,12 @@ #include #include #include +#include #include "config.h" #include "cmark_ctype.h" #include "buffer.h" +#include "memory.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. @@ -19,7 +21,9 @@ unsigned char cmark_strbuf__initbuf[1]; #define MIN(x, y) ((x < y) ? x : y) #endif -void cmark_strbuf_init(cmark_strbuf *buf, bufsize_t initial_size) { +void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf, + bufsize_t initial_size) { + buf->mem = mem; buf->asize = 0; buf->size = 0; buf->ptr = cmark_strbuf__initbuf; @@ -28,68 +32,28 @@ void cmark_strbuf_init(cmark_strbuf *buf, bufsize_t initial_size) { cmark_strbuf_grow(buf, initial_size); } -void cmark_strbuf_overflow_err() { - fprintf(stderr, "String buffer overflow"); - abort(); -} - -static CMARK_INLINE void S_strbuf_grow_by(cmark_strbuf *buf, size_t add) { - size_t target_size = (size_t)buf->size + add; - - if (target_size < add /* Integer overflow. */ - || target_size > BUFSIZE_MAX /* Truncation overflow. */ - ) { - cmark_strbuf_overflow_err(); - return; /* unreachable */ - } - - if ((bufsize_t)target_size >= buf->asize) - cmark_strbuf_grow(buf, (bufsize_t)target_size); +static CMARK_INLINE void S_strbuf_grow_by(cmark_strbuf *buf, bufsize_t add) { + cmark_strbuf_grow(buf, buf->size + add); } void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) { - unsigned char *new_ptr; + assert(target_size > 0); if (target_size < buf->asize) return; - if (buf->asize == 0) { - new_ptr = NULL; - } else { - new_ptr = buf->ptr; - } + if (target_size > (bufsize_t)(INT32_MAX / 2)) + abort(); /* Oversize the buffer by 50% to guarantee amortized linear time * complexity on append operations. */ - size_t new_size = (size_t)target_size + (size_t)target_size / 2; - - /* Account for terminating null byte. */ + bufsize_t new_size = target_size + target_size / 2; new_size += 1; - - /* round allocation up to multiple of 8 */ new_size = (new_size + 7) & ~7; - if (new_size < (size_t)target_size /* Integer overflow. */ - || new_size > BUFSIZE_MAX /* Truncation overflow. */ - ) { - if (target_size >= BUFSIZE_MAX) { - /* No space for terminating null byte. */ - cmark_strbuf_overflow_err(); - return; /* unreachable */ - } - /* Oversize by the maximum possible amount. */ - new_size = BUFSIZE_MAX; - } - - new_ptr = (unsigned char *)realloc(new_ptr, new_size); - - if (!new_ptr) { - perror("realloc in cmark_strbuf_grow"); - abort(); - } - - buf->asize = (bufsize_t)new_size; - buf->ptr = new_ptr; + buf->ptr = (unsigned char *)buf->mem->realloc(buf->asize ? buf->ptr : NULL, + new_size); + buf->asize = new_size; } bufsize_t cmark_strbuf_len(const cmark_strbuf *buf) { return buf->size; } @@ -99,9 +63,9 @@ void cmark_strbuf_free(cmark_strbuf *buf) { return; if (buf->ptr != cmark_strbuf__initbuf) - free(buf->ptr); + buf->mem->free(buf->ptr); - cmark_strbuf_init(buf, 0); + cmark_strbuf_init(buf->mem, buf, 0); } void cmark_strbuf_clear(cmark_strbuf *buf) { @@ -128,7 +92,7 @@ void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, void cmark_strbuf_sets(cmark_strbuf *buf, const char *string) { cmark_strbuf_set(buf, (const unsigned char *)string, - string ? cmark_strbuf_safe_strlen(string) : 0); + string ? strlen(string) : 0); } void cmark_strbuf_putc(cmark_strbuf *buf, int c) { @@ -149,8 +113,7 @@ void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, } void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) { - cmark_strbuf_put(buf, (const unsigned char *)string, - cmark_strbuf_safe_strlen(string)); + cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string)); } void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, @@ -184,10 +147,10 @@ unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) { if (buf->asize == 0) { /* return an empty string */ - return (unsigned char *)calloc(1, 1); + return (unsigned char *)buf->mem->calloc(1, 1); } - cmark_strbuf_init(buf, 0); + cmark_strbuf_init(buf->mem, buf, 0); return data; } diff --git a/buffer.h b/buffer.h index 6fd0cae..e878075 100644 --- a/buffer.h +++ b/buffer.h @@ -5,32 +5,35 @@ #include #include #include +#include #include "config.h" +#include "cmark.h" #ifdef __cplusplus extern "C" { #endif -typedef int bufsize_t; +typedef int32_t bufsize_t; typedef struct { + cmark_mem *mem; unsigned char *ptr; bufsize_t asize, size; } cmark_strbuf; extern unsigned char cmark_strbuf__initbuf[]; -#define GH_BUF_INIT \ - { cmark_strbuf__initbuf, 0, 0 } -#define BUFSIZE_MAX INT_MAX +#define CMARK_BUF_INIT(mem) \ + { mem, cmark_strbuf__initbuf, 0, 0 } /** * Initialize a cmark_strbuf structure. * - * For the cases where GH_BUF_INIT cannot be used to do static + * For the cases where CMARK_BUF_INIT cannot be used to do static * initialization. */ -void cmark_strbuf_init(cmark_strbuf *buf, bufsize_t initial_size); +void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf, + bufsize_t initial_size); /** * Grow the buffer to hold at least `target_size` bytes. @@ -72,20 +75,6 @@ void cmark_strbuf_trim(cmark_strbuf *buf); void cmark_strbuf_normalize_whitespace(cmark_strbuf *s); void cmark_strbuf_unescape(cmark_strbuf *s); -/* Print error and abort. */ -void cmark_strbuf_overflow_err(void); - -static CMARK_INLINE bufsize_t cmark_strbuf_check_bufsize(size_t size) { - if (size > BUFSIZE_MAX) { - cmark_strbuf_overflow_err(); - } - return (bufsize_t)size; -} - -static CMARK_INLINE bufsize_t cmark_strbuf_safe_strlen(const char *str) { - return cmark_strbuf_check_bufsize(strlen(str)); -} - #ifdef __cplusplus } #endif diff --git a/chunk.h b/chunk.h index b25831b..a2248f5 100644 --- a/chunk.h +++ b/chunk.h @@ -4,8 +4,10 @@ #include #include #include -#include "cmark_ctype.h" +#include "cmark.h" #include "buffer.h" +#include "memory.h" +#include "cmark_ctype.h" #define CMARK_CHUNK_EMPTY \ { NULL, 0, 0 } @@ -16,9 +18,9 @@ typedef struct { bufsize_t alloc; // also implies a NULL-terminated string } cmark_chunk; -static CMARK_INLINE void cmark_chunk_free(cmark_chunk *c) { +static CMARK_INLINE void cmark_chunk_free(cmark_mem *mem, cmark_chunk *c) { if (c->alloc) - free(c->data); + mem->free(c->data); c->data = NULL; c->alloc = 0; @@ -48,56 +50,57 @@ static CMARK_INLINE void cmark_chunk_trim(cmark_chunk *c) { cmark_chunk_rtrim(c); } -static CMARK_INLINE bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c, - bufsize_t offset) { +static CMARK_INLINE bufsize_t + cmark_chunk_strchr(cmark_chunk *ch, int c, bufsize_t offset) { const unsigned char *p = (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); return p ? (bufsize_t)(p - ch->data) : ch->len; } -static CMARK_INLINE const char *cmark_chunk_to_cstr(cmark_chunk *c) { +static CMARK_INLINE const char *cmark_chunk_to_cstr(cmark_mem *mem, + cmark_chunk *c) { unsigned char *str; if (c->alloc) { return (char *)c->data; } - str = (unsigned char *)malloc(c->len + 1); - if (str != NULL) { - if (c->len > 0) { - memcpy(str, c->data, c->len); - } - str[c->len] = 0; + str = (unsigned char *)mem->calloc(c->len + 1, 1); + if (c->len > 0) { + memcpy(str, c->data, c->len); } + str[c->len] = 0; c->data = str; c->alloc = 1; return (char *)str; } -static CMARK_INLINE void cmark_chunk_set_cstr(cmark_chunk *c, const char *str) { - if (c->alloc) { - free(c->data); - } +static CMARK_INLINE void cmark_chunk_set_cstr(cmark_mem *mem, cmark_chunk *c, + const char *str) { + unsigned char *old = c->alloc ? c->data : NULL; if (str == NULL) { c->len = 0; c->data = NULL; c->alloc = 0; } else { - c->len = cmark_strbuf_safe_strlen(str); - c->data = (unsigned char *)malloc(c->len + 1); + c->len = (bufsize_t)strlen(str); + c->data = (unsigned char *)mem->calloc(c->len + 1, 1); c->alloc = 1; memcpy(c->data, str, c->len + 1); } + if (old != NULL) { + mem->free(old); + } } static CMARK_INLINE cmark_chunk cmark_chunk_literal(const char *data) { - bufsize_t len = data ? cmark_strbuf_safe_strlen(data) : 0; + bufsize_t len = data ? (bufsize_t)strlen(data) : 0; cmark_chunk c = {(unsigned char *)data, len, 0}; return c; } -static CMARK_INLINE cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, - bufsize_t pos, bufsize_t len) { +static CMARK_INLINE cmark_chunk + cmark_chunk_dup(const cmark_chunk *ch, bufsize_t pos, bufsize_t len) { cmark_chunk c = {ch->data + pos, len, 0}; return c; } diff --git a/cmark.c b/cmark.c index 3491199..0d3bc16 100644 --- a/cmark.c +++ b/cmark.c @@ -10,6 +10,22 @@ int cmark_version() { return CMARK_VERSION; } const char *cmark_version_string() { return CMARK_VERSION_STRING; } +static void *xcalloc(size_t nmem, size_t size) { + void *ptr = calloc(nmem, size); + if (!ptr) + abort(); + return ptr; +} + +static void *xrealloc(void *ptr, size_t size) { + void *new_ptr = realloc(ptr, size); + if (!new_ptr) + abort(); + return new_ptr; +} + +cmark_mem DEFAULT_MEM_ALLOCATOR = {xcalloc, xrealloc, free}; + char *cmark_markdown_to_html(const char *text, size_t len, int options) { cmark_node *doc; char *result; diff --git a/cmark.h b/cmark.h index 7deaf31..a26ecb4 100644 --- a/cmark.h +++ b/cmark.h @@ -21,7 +21,8 @@ extern "C" { /** 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. + * UTF-8-encoded string. It is the caller's responsibility + * to free the returned buffer. */ CMARK_EXPORT char *cmark_markdown_to_html(const char *text, size_t len, int options); @@ -86,6 +87,19 @@ typedef struct cmark_node cmark_node; typedef struct cmark_parser cmark_parser; typedef struct cmark_iter cmark_iter; +/** + * ## Custom memory allocator support + */ + +/** Defines the memory allocation functions to be used by CMark + * when parsing and allocating a document tree + */ +typedef struct cmark_mem { + void *(*calloc)(size_t, size_t); + void *(*realloc)(void *, size_t); + void (*free)(void *); +} cmark_mem; + /** * ## Creating and Destroying Nodes */ @@ -96,6 +110,13 @@ typedef struct cmark_iter cmark_iter; */ CMARK_EXPORT cmark_node *cmark_node_new(cmark_node_type type); +/** Same as `cmark_node_new`, but explicitly listing the memory + * allocator used to allocate the node. Note: be sure to use the same + * allocator for every node in a tree, or bad things can happen. + */ +CMARK_EXPORT cmark_node *cmark_node_new_with_mem(cmark_node_type type, + cmark_mem *mem); + /** Frees the memory allocated for a node and any children. */ CMARK_EXPORT void cmark_node_free(cmark_node *node); @@ -179,7 +200,9 @@ typedef enum { } cmark_event_type; /** 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. + * type are undefined until 'cmark_iter_next' is called for the first time. + * The memory allocated for the iterator should be released using + * 'cmark_iter_free' when it is no longer needed. */ CMARK_EXPORT cmark_iter *cmark_iter_new(cmark_node *root); @@ -434,6 +457,11 @@ CMARK_EXPORT void cmark_consolidate_text_nodes(cmark_node *root); CMARK_EXPORT cmark_parser *cmark_parser_new(int options); +/** Creates a new parser object with the given memory allocator + */ +CMARK_EXPORT +cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem); + /** Frees memory allocated for a parser object. */ CMARK_EXPORT @@ -450,13 +478,16 @@ 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. + * Returns a pointer to a tree of nodes. The memory allocated for + * the node tree should be released using 'cmark_node_free' + * when it is no longer needed. */ 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. + * a tree of nodes. The memory allocated for the node tree should be + * released using 'cmark_node_free' when it is no longer needed. */ CMARK_EXPORT cmark_node *cmark_parse_file(FILE *f, int options); @@ -465,28 +496,33 @@ cmark_node *cmark_parse_file(FILE *f, int options); * ## Rendering */ -/** Render a 'node' tree as XML. +/** Render a 'node' tree as XML. It is the caller's responsibility + * to free the returned buffer. */ 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. + * to add an appropriate header and footer. It is the caller's + * responsibility to free the returned buffer. */ CMARK_EXPORT char *cmark_render_html(cmark_node *root, int options); /** Render a 'node' tree as a groff man page, without the header. + * It is the caller's responsibility to free the returned buffer. */ CMARK_EXPORT char *cmark_render_man(cmark_node *root, int options, int width); /** Render a 'node' tree as a commonmark document. + * It is the caller's responsibility to free the returned buffer. */ CMARK_EXPORT char *cmark_render_commonmark(cmark_node *root, int options, int width); /** Render a 'node' tree as a LaTeX document. + * It is the caller's responsibility to free the returned buffer. */ CMARK_EXPORT char *cmark_render_latex(cmark_node *root, int options, int width); @@ -519,6 +555,10 @@ char *cmark_render_latex(cmark_node *root, int options, int width); */ #define CMARK_OPT_SAFE (1 << 3) +/** Render `softbreak` elements as spaces. + */ +#define CMARK_OPT_NOBREAKS (1 << 4) + /** * ### Options affecting parsing */ diff --git a/cmark_ctype.c b/cmark_ctype.c index c9a9b0e..c0c4d5b 100644 --- a/cmark_ctype.c +++ b/cmark_ctype.c @@ -40,3 +40,5 @@ int cmark_isalnum(char c) { } int cmark_isdigit(char c) { return cmark_ctype_class[(uint8_t)c] == 3; } + +int cmark_isalpha(char c) { return cmark_ctype_class[(uint8_t)c] == 4; } diff --git a/cmark_ctype.h b/cmark_ctype.h index f803946..9a07618 100644 --- a/cmark_ctype.h +++ b/cmark_ctype.h @@ -17,6 +17,8 @@ int cmark_isalnum(char c); int cmark_isdigit(char c); +int cmark_isalpha(char c); + #ifdef __cplusplus } #endif diff --git a/cmark_version.h b/cmark_version.h index 5e873b2..32cb2e2 100644 --- a/cmark_version.h +++ b/cmark_version.h @@ -1,7 +1,7 @@ #ifndef CMARK_VERSION_H #define CMARK_VERSION_H -#define CMARK_VERSION ((0 << 16) | (25 << 8) | 2) -#define CMARK_VERSION_STRING "0.25.2" +#define CMARK_VERSION ((0 << 16) | (26 << 8) | 1) +#define CMARK_VERSION_STRING "0.26.1" #endif diff --git a/commonmark.c b/commonmark.c index f5a352d..b8b1820 100644 --- a/commonmark.c +++ b/commonmark.c @@ -2,7 +2,6 @@ #include #include #include -#include #include "config.h" #include "cmark.h" @@ -12,7 +11,6 @@ #include "scanners.h" #include "render.h" -#define safe_strlen(s) cmark_strbuf_safe_strlen(s) #define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping) #define LIT(s) renderer->out(renderer, s, false, LITERAL) #define CR() renderer->cr(renderer) @@ -23,7 +21,7 @@ // Functions to convert cmark_nodes to commonmark strings. static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape, - int32_t c, unsigned char nextc) { + int32_t c, unsigned char nextc) { bool needs_escaping = false; bool follows_digit = renderer->buffer->size > 0 && @@ -31,24 +29,25 @@ static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape, char encoded[ENCODED_SIZE]; needs_escaping = - escape != LITERAL && + c < 0x80 && escape != LITERAL && ((escape == NORMAL && (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' || c == '>' || c == '\\' || c == '`' || c == '!' || - (c == '&' && isalpha(nextc)) || (c == '!' && nextc == '[') || + (c == '&' && cmark_isalpha(nextc)) || (c == '!' && nextc == '[') || (renderer->begin_content && (c == '-' || c == '+' || c == '=') && // begin_content doesn't get set to false til we've passed digits // at the beginning of line, so... !follows_digit) || (renderer->begin_content && (c == '.' || c == ')') && follows_digit && (nextc == 0 || cmark_isspace(nextc))))) || - (escape == URL && (c == '`' || c == '<' || c == '>' || isspace(c) || - c == '\\' || c == ')' || c == '(')) || + (escape == URL && + (c == '`' || c == '<' || c == '>' || cmark_isspace(c) || c == '\\' || + c == ')' || c == '(')) || (escape == TITLE && (c == '`' || c == '<' || c == '>' || c == '"' || c == '\\'))); if (needs_escaping) { - if (isspace(c)) { + if (cmark_isspace(c)) { // use percent encoding for spaces snprintf(encoded, ENCODED_SIZE, "%%%2x", c); cmark_strbuf_puts(renderer->buffer, encoded); @@ -66,7 +65,7 @@ static int longest_backtick_sequence(const char *code) { int longest = 0; int current = 0; size_t i = 0; - size_t code_len = safe_strlen(code); + size_t code_len = strlen(code); while (i <= code_len) { if (code[i] == '`') { current++; @@ -85,7 +84,7 @@ static int shortest_unused_backtick_sequence(const char *code) { int32_t used = 1; int current = 0; size_t i = 0; - size_t code_len = safe_strlen(code); + size_t code_len = strlen(code); while (i <= code_len) { if (code[i] == '`') { current++; @@ -171,7 +170,10 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, size_t info_len, code_len; char listmarker[LISTMARKER_SIZE]; char *emph_delim; + bool first_in_list_item; bufsize_t marker_width; + bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options) && + !(CMARK_OPT_HARDBREAKS & options); // Don't adjust tight list status til we've started the list. // Otherwise we loose the blank line between a paragraph and @@ -204,7 +206,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, case CMARK_NODE_LIST: if (!entering && node->next && (node->next->type == CMARK_NODE_CODE_BLOCK || node->next->type == CMARK_NODE_LIST)) { - // this ensures that a following code block or list will be + // this ensures that a following indented code block or list will be // inteprereted correctly. CR(); LIT(""); @@ -229,7 +231,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, snprintf(listmarker, LISTMARKER_SIZE, "%d%s%s", list_number, list_delim == CMARK_PAREN_DELIM ? ")" : ".", list_number < 10 ? " " : " "); - marker_width = safe_strlen(listmarker); + marker_width = strlen(listmarker); } if (entering) { if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { @@ -256,27 +258,31 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, } LIT(" "); renderer->begin_content = true; - renderer->no_wrap = true; + renderer->no_linebreaks = true; } else { - renderer->no_wrap = false; + renderer->no_linebreaks = false; BLANKLINE(); } break; case CMARK_NODE_CODE_BLOCK: - BLANKLINE(); + first_in_list_item = node->prev == NULL && node->parent && + node->parent->type == CMARK_NODE_ITEM; + + if (!first_in_list_item) { + BLANKLINE(); + } info = cmark_node_get_fence_info(node); - info_len = safe_strlen(info); + info_len = strlen(info); code = cmark_node_get_literal(node); - code_len = safe_strlen(code); + code_len = strlen(code); // use indented form if no info, and code doesn't // begin or end with a blank line, and code isn't // first thing in a list item - if (info_len == 0 && - (code_len > 2 && !isspace((unsigned char)code[0]) && - !(isspace((unsigned char)code[code_len - 1]) && isspace((unsigned char)code[code_len - 2]))) && - !(node->prev == NULL && node->parent && - node->parent->type == CMARK_NODE_ITEM)) { + if (info_len == 0 && (code_len > 2 && !cmark_isspace(code[0]) && + !(cmark_isspace(code[code_len - 1]) && + cmark_isspace(code[code_len - 2]))) && + !first_in_list_item) { LIT(" "); cmark_strbuf_puts(renderer->prefix, " "); OUT(cmark_node_get_literal(node), false, LITERAL); @@ -327,7 +333,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, break; case CMARK_NODE_TEXT: - OUT(cmark_node_get_literal(node), true, NORMAL); + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); break; case CMARK_NODE_LINEBREAK: @@ -338,16 +344,21 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, break; case CMARK_NODE_SOFTBREAK: - if (renderer->width == 0 && !(CMARK_OPT_HARDBREAKS & options)) { + if (CMARK_OPT_HARDBREAKS & options) { + LIT(" "); + CR(); + } else if (!renderer->no_linebreaks && renderer->width == 0 && + !(CMARK_OPT_HARDBREAKS & options) && + !(CMARK_OPT_NOBREAKS & options)) { CR(); } else { - OUT(" ", true, LITERAL); + OUT(" ", allow_wrap, LITERAL); } break; case CMARK_NODE_CODE: code = cmark_node_get_literal(node); - code_len = safe_strlen(code); + code_len = strlen(code); numticks = shortest_unused_backtick_sequence(code); for (i = 0; i < numticks; i++) { LIT("`"); @@ -355,7 +366,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, if (code_len == 0 || code[0] == '`') { LIT(" "); } - OUT(cmark_node_get_literal(node), true, LITERAL); + OUT(cmark_node_get_literal(node), allow_wrap, LITERAL); if (code_len == 0 || code[code_len - 1] == '`') { LIT(" "); } @@ -417,7 +428,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, LIT("]("); OUT(cmark_node_get_url(node), false, URL); title = cmark_node_get_title(node); - if (safe_strlen(title) > 0) { + if (strlen(title) > 0) { LIT(" \""); OUT(title, false, TITLE); LIT("\""); @@ -434,8 +445,8 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, LIT("]("); OUT(cmark_node_get_url(node), false, URL); title = cmark_node_get_title(node); - if (safe_strlen(title) > 0) { - OUT(" \"", true, LITERAL); + if (strlen(title) > 0) { + OUT(" \"", allow_wrap, LITERAL); OUT(title, false, TITLE); LIT("\""); } diff --git a/html.c b/html.c index 9ffa08a..a680e4a 100644 --- a/html.c +++ b/html.c @@ -228,6 +228,8 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, case CMARK_NODE_SOFTBREAK: if (options & CMARK_OPT_HARDBREAKS) { cmark_strbuf_puts(html, "
    \n"); + } else if (options & CMARK_OPT_NOBREAKS) { + cmark_strbuf_putc(html, ' '); } else { cmark_strbuf_putc(html, '\n'); } @@ -322,7 +324,7 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, char *cmark_render_html(cmark_node *root, int options) { char *result; - cmark_strbuf html = GH_BUF_INIT; + cmark_strbuf html = CMARK_BUF_INIT(cmark_node_mem(root)); cmark_event_type ev_type; cmark_node *cur; struct render_state state = {&html, NULL}; diff --git a/inlines.c b/inlines.c index 8ff8131..e5ca8e2 100644 --- a/inlines.c +++ b/inlines.c @@ -22,30 +22,40 @@ 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_HTML_INLINE, 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) +#define make_str(mem, s) make_literal(mem, CMARK_NODE_TEXT, s) +#define make_code(mem, s) make_literal(mem, CMARK_NODE_CODE, s) +#define make_raw_html(mem, s) make_literal(mem, CMARK_NODE_HTML_INLINE, s) +#define make_linebreak(mem) make_simple(mem, CMARK_NODE_LINEBREAK) +#define make_softbreak(mem) make_simple(mem, CMARK_NODE_SOFTBREAK) +#define make_emph(mem) make_simple(mem, CMARK_NODE_EMPH) +#define make_strong(mem) make_simple(mem, CMARK_NODE_STRONG) typedef struct delimiter { struct delimiter *previous; struct delimiter *next; cmark_node *inl_text; - bufsize_t position; unsigned char delim_char; bool can_open; bool can_close; - bool active; } delimiter; +typedef struct bracket { + struct bracket *previous; + struct delimiter *previous_delimiter; + cmark_node *inl_text; + bufsize_t position; + bool image; + bool active; + bool bracket_after; +} bracket; + typedef struct { + cmark_mem *mem; cmark_chunk input; bufsize_t pos; cmark_reference_map *refmap; delimiter *last_delim; + bracket *last_bracket; } subject; static CMARK_INLINE bool S_is_line_end_char(char c) { @@ -57,66 +67,48 @@ static delimiter *S_insert_emph(subject *subj, delimiter *opener, static int parse_inline(subject *subj, cmark_node *parent, int options); -static void subject_from_buf(subject *e, cmark_strbuf *buffer, +static void subject_from_buf(cmark_mem *mem, subject *e, cmark_strbuf *buffer, cmark_reference_map *refmap); static bufsize_t subject_find_special_char(subject *subj, int options); // Create an inline with a literal string value. -static CMARK_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; - } +static CMARK_INLINE cmark_node *make_literal(cmark_mem *mem, cmark_node_type t, + cmark_chunk s) { + cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e)); + cmark_strbuf_init(mem, &e->content, 0); + e->type = t; + e->as.literal = s; return e; } // Create an inline with no value. -static CMARK_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; - } +static CMARK_INLINE cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) { + cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e)); + cmark_strbuf_init(mem, &e->content, 0); + e->type = t; return e; } // Like make_str, but parses entities. -static cmark_node *make_str_with_entities(cmark_chunk *content) { - cmark_strbuf unescaped = GH_BUF_INIT; +static cmark_node *make_str_with_entities(cmark_mem *mem, + cmark_chunk *content) { + cmark_strbuf unescaped = CMARK_BUF_INIT(mem); if (houdini_unescape_html(&unescaped, content->data, content->len)) { - return make_str(cmark_chunk_buf_detach(&unescaped)); + return make_str(mem, cmark_chunk_buf_detach(&unescaped)); } else { - return make_str(*content); + return make_str(mem, *content); } } // Duplicate a chunk by creating a copy of the buffer not by reusing the // buffer like cmark_chunk_dup does. -static cmark_chunk chunk_clone(cmark_chunk *src) { +static cmark_chunk chunk_clone(cmark_mem *mem, cmark_chunk *src) { cmark_chunk c; bufsize_t len = src->len; c.len = len; - c.data = (unsigned char *)malloc(len + 1); + c.data = (unsigned char *)mem->calloc(len + 1, 1); c.alloc = 1; memcpy(c.data, src->data, len); c.data[len] = '\0'; @@ -124,8 +116,9 @@ static cmark_chunk chunk_clone(cmark_chunk *src) { return c; } -static cmark_chunk cmark_clean_autolink(cmark_chunk *url, int is_email) { - cmark_strbuf buf = GH_BUF_INIT; +static cmark_chunk cmark_clean_autolink(cmark_mem *mem, cmark_chunk *url, + int is_email) { + cmark_strbuf buf = CMARK_BUF_INIT(mem); cmark_chunk_trim(url); @@ -141,22 +134,25 @@ static cmark_chunk cmark_clean_autolink(cmark_chunk *url, int is_email) { return cmark_chunk_buf_detach(&buf); } -static CMARK_INLINE cmark_node *make_autolink(cmark_chunk url, int is_email) { - cmark_node *link = make_simple(CMARK_NODE_LINK); - link->as.link.url = cmark_clean_autolink(&url, is_email); +static CMARK_INLINE cmark_node *make_autolink(cmark_mem *mem, cmark_chunk url, + int is_email) { + cmark_node *link = make_simple(mem, CMARK_NODE_LINK); + link->as.link.url = cmark_clean_autolink(mem, &url, is_email); link->as.link.title = cmark_chunk_literal(""); - cmark_node_append_child(link, make_str_with_entities(&url)); + cmark_node_append_child(link, make_str_with_entities(mem, &url)); return link; } -static void subject_from_buf(subject *e, cmark_strbuf *buffer, +static void subject_from_buf(cmark_mem *mem, subject *e, cmark_strbuf *buffer, cmark_reference_map *refmap) { + e->mem = mem; e->input.data = buffer->ptr; e->input.len = buffer->size; e->input.alloc = 0; e->pos = 0; e->refmap = refmap; e->last_delim = NULL; + e->last_bracket = NULL; } static CMARK_INLINE int isbacktick(int c) { return (c == '`'); } @@ -251,16 +247,16 @@ static cmark_node *handle_backticks(subject *subj) { if (endpos == 0) { // not found subj->pos = startpos; // rewind - return make_str(openticks); + return make_str(subj->mem, openticks); } else { - cmark_strbuf buf = GH_BUF_INIT; + cmark_strbuf buf = CMARK_BUF_INIT(subj->mem); 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)); + return make_code(subj->mem, cmark_chunk_buf_detach(&buf)); } } @@ -360,12 +356,18 @@ static void remove_delimiter(subject *subj, delimiter *delim) { free(delim); } +static void pop_bracket(subject *subj) { + bracket *b; + if (subj->last_bracket == NULL) + return; + b = subj->last_bracket; + subj->last_bracket = subj->last_bracket->previous; + free(b); +} + 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; - } + delimiter *delim = (delimiter *)subj->mem->calloc(1, sizeof(delimiter)); delim->delim_char = c; delim->can_open = can_open; delim->can_close = can_close; @@ -375,11 +377,24 @@ static void push_delimiter(subject *subj, unsigned char c, bool can_open, if (delim->previous != NULL) { delim->previous->next = delim; } - delim->position = subj->pos; - delim->active = true; subj->last_delim = delim; } +static void push_bracket(subject *subj, bool image, cmark_node *inl_text) { + bracket *b = (bracket *)subj->mem->calloc(1, sizeof(bracket)); + if (subj->last_bracket != NULL) { + subj->last_bracket->bracket_after = true; + } + b->image = image; + b->active = true; + b->inl_text = inl_text; + b->previous = subj->last_bracket; + b->previous_delimiter = subj->last_delim; + b->position = subj->pos; + b->bracket_after = false; + subj->last_bracket = b; +} + // Assumes the subject has a c at the current position. static cmark_node *handle_delim(subject *subj, unsigned char c, bool smart) { bufsize_t numdelims; @@ -398,7 +413,7 @@ static cmark_node *handle_delim(subject *subj, unsigned char c, bool smart) { contents = cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims); } - inl_text = make_str(contents); + inl_text = make_str(subj->mem, contents); if ((can_open || can_close) && (!(c == '\'' || c == '"') || smart)) { push_delimiter(subj, c, can_open, can_close, inl_text); @@ -414,7 +429,7 @@ static cmark_node *handle_hyphen(subject *subj, bool smart) { advance(subj); if (!smart || peek_char(subj) != '-') { - return make_str(cmark_chunk_literal("-")); + return make_str(subj->mem, cmark_chunk_literal("-")); } while (smart && peek_char(subj) == '-') { @@ -425,7 +440,7 @@ static cmark_node *handle_hyphen(subject *subj, bool smart) { int en_count = 0; int em_count = 0; int i; - cmark_strbuf buf = GH_BUF_INIT; + cmark_strbuf buf = CMARK_BUF_INIT(subj->mem); if (numhyphens % 3 == 0) { // if divisible by 3, use all em dashes em_count = numhyphens / 3; @@ -447,7 +462,7 @@ static cmark_node *handle_hyphen(subject *subj, bool smart) { cmark_strbuf_puts(&buf, ENDASH); } - return make_str(cmark_chunk_buf_detach(&buf)); + return make_str(subj->mem, cmark_chunk_buf_detach(&buf)); } // Assumes we have a period at the current position. @@ -457,12 +472,12 @@ static cmark_node *handle_period(subject *subj, bool smart) { advance(subj); if (peek_char(subj) == '.') { advance(subj); - return make_str(cmark_chunk_literal(ELLIPSES)); + return make_str(subj->mem, cmark_chunk_literal(ELLIPSES)); } else { - return make_str(cmark_chunk_literal("..")); + return make_str(subj->mem, cmark_chunk_literal("..")); } } else { - return make_str(cmark_chunk_literal(".")); + return make_str(subj->mem, cmark_chunk_literal(".")); } } @@ -471,6 +486,7 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) { delimiter *opener; delimiter *old_closer; bool opener_found; + bool odd_match; delimiter *openers_bottom[128]; // initialize openers_bottom: @@ -486,15 +502,22 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) { // 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 == '\'')) { + if (closer->can_close) { // Now look backwards for first matching opener: opener = closer->previous; opener_found = false; + odd_match = false; while (opener != NULL && opener != stack_bottom && opener != openers_bottom[closer->delim_char]) { - if (opener->delim_char == closer->delim_char && opener->can_open) { + // interior closer of size 2 can't match opener of size 1 + // or of size 1 can't match 2 + odd_match = (closer->can_open || opener->can_close) && + ((opener->inl_text->as.literal.len + + closer->inl_text->as.literal.len) % + 3 == + 0); + if (opener->delim_char == closer->delim_char && opener->can_open && + !odd_match) { opener_found = true; break; } @@ -508,24 +531,28 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) { closer = closer->next; } } else if (closer->delim_char == '\'') { - cmark_chunk_free(&closer->inl_text->as.literal); + cmark_chunk_free(subj->mem, &closer->inl_text->as.literal); closer->inl_text->as.literal = cmark_chunk_literal(RIGHTSINGLEQUOTE); if (opener_found) { - cmark_chunk_free(&opener->inl_text->as.literal); + cmark_chunk_free(subj->mem, &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); + cmark_chunk_free(subj->mem, &closer->inl_text->as.literal); closer->inl_text->as.literal = cmark_chunk_literal(RIGHTDOUBLEQUOTE); if (opener_found) { - cmark_chunk_free(&opener->inl_text->as.literal); + cmark_chunk_free(subj->mem, &opener->inl_text->as.literal); opener->inl_text->as.literal = cmark_chunk_literal(LEFTDOUBLEQUOTE); } closer = closer->next; } - if (!opener_found) { - // set lower bound for future searches for openers: + if (!opener_found && !odd_match) { + // set lower bound for future searches for openers + // (we don't do this with 'odd_match' set because + // a ** that didn't match an earlier * might turn into + // an opener, and the * might be matched by something + // else. openers_bottom[old_closer->delim_char] = old_closer->previous; if (!old_closer->can_open) { // we can remove a closer that can't be an @@ -552,7 +579,7 @@ static delimiter *S_insert_emph(subject *subj, delimiter *opener, cmark_node *closer_inl = closer->inl_text; bufsize_t opener_num_chars = opener_inl->as.literal.len; bufsize_t closer_num_chars = closer_inl->as.literal.len; - cmark_node *tmp, *emph, *first_child, *last_child; + cmark_node *tmp, *tmpnext, *emph; // calculate the actual number of characters used from this closer if (closer_num_chars < 3 || opener_num_chars < 3) { @@ -576,37 +603,22 @@ static delimiter *S_insert_emph(subject *subj, delimiter *opener, delim = tmp_delim; } - first_child = opener_inl->next; - last_child = closer_inl->prev; + // create new emph or strong, and splice it in to our inlines + // between the opener and closer + emph = use_delims == 1 ? make_emph(subj->mem) : make_strong(subj->mem); + + tmp = opener_inl->next; + while (tmp && tmp != closer_inl) { + tmpnext = tmp->next; + cmark_node_append_child(emph, tmp); + tmp = tmpnext; + } + cmark_node_insert_after(opener_inl, emph); // 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 ? CMARK_NODE_EMPH : CMARK_NODE_STRONG; - // remove opener from list + cmark_node_free(opener_inl); 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 @@ -629,18 +641,18 @@ static cmark_node *handle_backslash(subject *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)); + return make_str(subj->mem, cmark_chunk_dup(&subj->input, subj->pos - 1, 1)); } else if (!is_eof(subj) && skip_line_end(subj)) { - return make_linebreak(); + return make_linebreak(subj->mem); } else { - return make_str(cmark_chunk_literal("\\")); + return make_str(subj->mem, 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; + cmark_strbuf ent = CMARK_BUF_INIT(subj->mem); bufsize_t len; advance(subj); @@ -649,16 +661,16 @@ static cmark_node *handle_entity(subject *subj) { subj->input.len - subj->pos); if (len == 0) - return make_str(cmark_chunk_literal("&")); + return make_str(subj->mem, cmark_chunk_literal("&")); subj->pos += len; - return make_str(cmark_chunk_buf_detach(&ent)); + return make_str(subj->mem, cmark_chunk_buf_detach(&ent)); } // Clean a URL: remove surrounding whitespace and surrounding <>, // and remove \ that escape punctuation. -cmark_chunk cmark_clean_url(cmark_chunk *url) { - cmark_strbuf buf = GH_BUF_INIT; +cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url) { + cmark_strbuf buf = CMARK_BUF_INIT(mem); cmark_chunk_trim(url); @@ -677,8 +689,8 @@ cmark_chunk cmark_clean_url(cmark_chunk *url) { return cmark_chunk_buf_detach(&buf); } -cmark_chunk cmark_clean_title(cmark_chunk *title) { - cmark_strbuf buf = GH_BUF_INIT; +cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title) { + cmark_strbuf buf = CMARK_BUF_INIT(mem); unsigned char first, last; if (title->len == 0) { @@ -715,7 +727,7 @@ static cmark_node *handle_pointy_brace(subject *subj) { contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1); subj->pos += matchlen; - return make_autolink(contents, 0); + return make_autolink(subj->mem, contents, 0); } // next try to match an email autolink @@ -724,7 +736,7 @@ static cmark_node *handle_pointy_brace(subject *subj) { contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1); subj->pos += matchlen; - return make_autolink(contents, 1); + return make_autolink(subj->mem, contents, 1); } // finally, try to match an html tag @@ -732,11 +744,11 @@ static cmark_node *handle_pointy_brace(subject *subj) { if (matchlen > 0) { contents = cmark_chunk_dup(&subj->input, subj->pos - 1, matchlen + 1); subj->pos += matchlen; - return make_raw_html(contents); + return make_raw_html(subj->mem, contents); } // if nothing matches, just return the opening <: - return make_str(cmark_chunk_literal("<")); + return make_str(subj->mem, cmark_chunk_literal("<")); } // Parse a link label. Returns 1 if successful. @@ -786,48 +798,40 @@ static int link_label(subject *subj, cmark_chunk *raw_label) { } // Return a link, an image, or a literal close bracket. -static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) { +static cmark_node *handle_close_bracket(subject *subj) { bufsize_t initial_pos; bufsize_t starturl, endurl, starttitle, endtitle, endall; bufsize_t n; bufsize_t sps; - cmark_reference *ref; - bool is_image = false; + cmark_reference *ref = NULL; cmark_chunk url_chunk, title_chunk; cmark_chunk url, title; - delimiter *opener; - cmark_node *link_text; + bracket *opener; cmark_node *inl; cmark_chunk raw_label; int found_label; + cmark_node *tmp, *tmpnext; + bool is_image; 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; - } + // get last [ or ![ + opener = subj->last_bracket; if (opener == NULL) { - return make_str(cmark_chunk_literal("]")); + return make_str(subj->mem, cmark_chunk_literal("]")); } if (!opener->active) { // take delimiter off stack - remove_delimiter(subj, opener); - return make_str(cmark_chunk_literal("]")); + pop_bracket(subj); + return make_str(subj->mem, 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. + is_image = opener->image; // First, look for an inline link. if (peek_char(subj) == '(' && @@ -852,10 +856,10 @@ static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) { 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); + url = cmark_clean_url(subj->mem, &url_chunk); + title = cmark_clean_title(subj->mem, &title_chunk); + cmark_chunk_free(subj->mem, &url_chunk); + cmark_chunk_free(subj->mem, &title_chunk); goto match; } else { @@ -867,24 +871,27 @@ static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) { // skip spaces 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 ((!found_label || raw_label.len == 0) && !opener->bracket_after) { + cmark_chunk_free(subj->mem, &raw_label); + raw_label = cmark_chunk_dup(&subj->input, opener->position, + initial_pos - opener->position - 1); + found_label = true; + } + + if (found_label) { + ref = cmark_reference_lookup(subj->refmap, &raw_label); + cmark_chunk_free(subj->mem, &raw_label); + } if (ref != NULL) { // found - url = chunk_clone(&ref->url); - title = chunk_clone(&ref->title); + url = chunk_clone(subj->mem, &ref->url); + title = chunk_clone(subj->mem, &ref->title); goto match; } else { goto noMatch; @@ -892,38 +899,36 @@ static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) { 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 + pop_bracket(subj); // remove this opener from delimiter list subj->pos = initial_pos; - return make_str(cmark_chunk_literal("]")); + return make_str(subj->mem, cmark_chunk_literal("]")); match: - inl = opener->inl_text; - inl->type = is_image ? CMARK_NODE_IMAGE : CMARK_NODE_LINK; - cmark_chunk_free(&inl->as.literal); - inl->first_child = link_text; - process_emphasis(subj, opener); + inl = make_simple(subj->mem, is_image ? CMARK_NODE_IMAGE : CMARK_NODE_LINK); 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; + cmark_node_insert_before(opener->inl_text, inl); + // Add link text: + tmp = opener->inl_text->next; + while (tmp) { + tmpnext = tmp->next; + cmark_node_append_child(inl, tmp); + tmp = tmpnext; } - parent->last_child = inl; + + // Free the bracket [: + cmark_node_free(opener->inl_text); + + process_emphasis(subj, opener->previous_delimiter); + pop_bracket(subj); // 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.) - remove_delimiter(subj, opener); if (!is_image) { - opener = subj->last_delim; + opener = subj->last_bracket; while (opener != NULL) { - if (opener->delim_char == '[') { + if (!opener->image) { if (!opener->active) { break; } else { @@ -952,9 +957,9 @@ static cmark_node *handle_newline(subject *subj) { skip_spaces(subj); if (nlpos > 1 && peek_at(subj, nlpos - 1) == ' ' && peek_at(subj, nlpos - 2) == ' ') { - return make_linebreak(); + return make_linebreak(subj->mem); } else { - return make_softbreak(); + return make_softbreak(subj->mem); } } @@ -1043,20 +1048,20 @@ static int parse_inline(subject *subj, cmark_node *parent, int options) { break; case '[': advance(subj); - new_inl = make_str(cmark_chunk_literal("[")); - push_delimiter(subj, '[', true, false, new_inl); + new_inl = make_str(subj->mem, cmark_chunk_literal("[")); + push_bracket(subj, false, new_inl); break; case ']': - new_inl = handle_close_bracket(subj, parent); + new_inl = handle_close_bracket(subj); break; case '!': advance(subj); if (peek_char(subj) == '[') { advance(subj); - new_inl = make_str(cmark_chunk_literal("![")); - push_delimiter(subj, '!', false, true, new_inl); + new_inl = make_str(subj->mem, cmark_chunk_literal("![")); + push_bracket(subj, true, new_inl); } else { - new_inl = make_str(cmark_chunk_literal("!")); + new_inl = make_str(subj->mem, cmark_chunk_literal("!")); } break; default: @@ -1069,7 +1074,7 @@ static int parse_inline(subject *subj, cmark_node *parent, int options) { cmark_chunk_rtrim(&contents); } - new_inl = make_str(contents); + new_inl = make_str(subj->mem, contents); } if (new_inl != NULL) { cmark_node_append_child(parent, new_inl); @@ -1079,16 +1084,20 @@ static int parse_inline(subject *subj, cmark_node *parent, int options) { } // 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) { +extern void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent, + cmark_reference_map *refmap, int options) { subject subj; - subject_from_buf(&subj, &parent->string_content, refmap); + subject_from_buf(mem, &subj, &parent->content, refmap); cmark_chunk_rtrim(&subj.input); while (!is_eof(&subj) && parse_inline(&subj, parent, options)) ; process_emphasis(&subj, NULL); + // free bracket stack + while (subj.last_bracket) { + pop_bracket(&subj); + } } // Parse zero or more space characters, including at most one newline. @@ -1103,7 +1112,7 @@ static void spnl(subject *subj) { // Modify refmap if a reference is encountered. // Return 0 if no reference found, otherwise position of subject // after reference is parsed. -bufsize_t cmark_parse_reference_inline(cmark_strbuf *input, +bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_strbuf *input, cmark_reference_map *refmap) { subject subj; @@ -1114,7 +1123,7 @@ bufsize_t cmark_parse_reference_inline(cmark_strbuf *input, bufsize_t matchlen = 0; bufsize_t beforetitle; - subject_from_buf(&subj, input, NULL); + subject_from_buf(mem, &subj, input, NULL); // parse label: if (!link_label(&subj, &lab) || lab.len == 0) diff --git a/inlines.h b/inlines.h index 7e7ee45..52be768 100644 --- a/inlines.h +++ b/inlines.h @@ -5,13 +5,13 @@ extern "C" { #endif -cmark_chunk cmark_clean_url(cmark_chunk *url); -cmark_chunk cmark_clean_title(cmark_chunk *title); +cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url); +cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title); -void cmark_parse_inlines(cmark_node *parent, cmark_reference_map *refmap, - int options); +void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent, + cmark_reference_map *refmap, int options); -bufsize_t cmark_parse_reference_inline(cmark_strbuf *input, +bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_strbuf *input, cmark_reference_map *refmap); #ifdef __cplusplus diff --git a/iterator.c b/iterator.c index 351b81f..24423a2 100644 --- a/iterator.c +++ b/iterator.c @@ -16,10 +16,9 @@ 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; - } + cmark_mem *mem = root->content.mem; + cmark_iter *iter = (cmark_iter *)mem->calloc(1, sizeof(cmark_iter)); + iter->mem = mem; iter->root = root; iter->cur.ev_type = CMARK_EVENT_NONE; iter->cur.node = NULL; @@ -28,7 +27,7 @@ cmark_iter *cmark_iter_new(cmark_node *root) { return iter; } -void cmark_iter_free(cmark_iter *iter) { free(iter); } +void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter); } static bool S_is_leaf(cmark_node *node) { return ((1 << node->type) & S_leaf_mask) != 0; @@ -93,7 +92,7 @@ void cmark_consolidate_text_nodes(cmark_node *root) { return; } cmark_iter *iter = cmark_iter_new(root); - cmark_strbuf buf = GH_BUF_INIT; + cmark_strbuf buf = CMARK_BUF_INIT(iter->mem); cmark_event_type ev_type; cmark_node *cur, *tmp, *next; @@ -111,7 +110,7 @@ void cmark_consolidate_text_nodes(cmark_node *root) { cmark_node_free(tmp); tmp = next; } - cmark_chunk_free(&cur->as.literal); + cmark_chunk_free(iter->mem, &cur->as.literal); cur->as.literal = cmark_chunk_buf_detach(&buf); } } diff --git a/iterator.h b/iterator.h index 9c6bca6..fc745df 100644 --- a/iterator.h +++ b/iterator.h @@ -6,6 +6,7 @@ extern "C" { #endif #include "cmark.h" +#include "memory.h" typedef struct { cmark_event_type ev_type; @@ -13,6 +14,7 @@ typedef struct { } cmark_iter_state; struct cmark_iter { + cmark_mem *mem; cmark_node *root; cmark_iter_state cur; cmark_iter_state next; diff --git a/latex.c b/latex.c index cd2f6f3..7c3decd 100644 --- a/latex.c +++ b/latex.c @@ -2,7 +2,6 @@ #include #include #include -#include #include "config.h" #include "cmark.h" @@ -12,7 +11,6 @@ #include "scanners.h" #include "render.h" -#define safe_strlen(s) cmark_strbuf_safe_strlen(s) #define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping) #define LIT(s) renderer->out(renderer, s, false, LITERAL) #define CR() renderer->cr(renderer) @@ -20,7 +18,7 @@ #define LIST_NUMBER_STRING_SIZE 20 static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape, - int32_t c, unsigned char nextc) { + int32_t c, unsigned char nextc) { if (escape == LITERAL) { cmark_render_code_point(renderer, c); return; @@ -169,13 +167,13 @@ static link_type get_link_type(cmark_node *node) { return INTERNAL_LINK; } - url_len = safe_strlen(url); + url_len = strlen(url); if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) { return NO_LINK; } const char *title = cmark_node_get_title(node); - title_len = safe_strlen(title); + title_len = strlen(title); // if it has a title, we can't treat it as an autolink: if (title_len == 0) { @@ -223,6 +221,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, cmark_list_type list_type; const char *roman_numerals[] = {"", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix", "x"}; + bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options); // avoid warning about unused parameter: (void)(options); @@ -334,7 +333,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, break; case CMARK_NODE_TEXT: - OUT(cmark_node_get_literal(node), true, NORMAL); + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); break; case CMARK_NODE_LINEBREAK: @@ -343,10 +342,13 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, break; case CMARK_NODE_SOFTBREAK: - if (renderer->width == 0) { + if (options & CMARK_OPT_HARDBREAKS) { + LIT("\\\\"); + CR(); + } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) { CR(); } else { - OUT(" ", true, NORMAL); + OUT(" ", allow_wrap, NORMAL); } break; diff --git a/man.c b/man.c index 3d8bc20..1c76f68 100644 --- a/man.c +++ b/man.c @@ -75,6 +75,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, cmark_node *tmp; int list_number; bool entering = (ev_type == CMARK_EVENT_ENTER); + bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options); // avoid unused parameter error: (void)(options); @@ -173,7 +174,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, break; case CMARK_NODE_TEXT: - OUT(cmark_node_get_literal(node), true, NORMAL); + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); break; case CMARK_NODE_LINEBREAK: @@ -182,16 +183,19 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, break; case CMARK_NODE_SOFTBREAK: - if (renderer->width == 0) { + if (options & CMARK_OPT_HARDBREAKS) { + LIT(".PD 0\n.P\n.PD"); + CR(); + } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) { CR(); } else { - OUT(" ", true, LITERAL); + OUT(" ", allow_wrap, LITERAL); } break; case CMARK_NODE_CODE: LIT("\\f[C]"); - OUT(cmark_node_get_literal(node), true, NORMAL); + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); LIT("\\f[]"); break; @@ -222,7 +226,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, case CMARK_NODE_LINK: if (!entering) { LIT(" ("); - OUT(cmark_node_get_url(node), true, URL); + OUT(cmark_node_get_url(node), allow_wrap, URL); LIT(")"); } break; diff --git a/node.c b/node.c index 00edbb1..e722acf 100644 --- a/node.c +++ b/node.c @@ -6,6 +6,8 @@ static void S_node_unlink(cmark_node *node); +#define NODE_MEM(node) cmark_node_mem(node) + static CMARK_INLINE bool S_is_block(cmark_node *node) { if (node == NULL) { return false; @@ -70,9 +72,10 @@ static bool S_can_contain(cmark_node *node, cmark_node *child) { return false; } -cmark_node *cmark_node_new(cmark_node_type type) { - cmark_node *node = (cmark_node *)calloc(1, sizeof(*node)); - node->type = type; +cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) { + cmark_node *node = (cmark_node *)mem->calloc(1, sizeof(*node)); + cmark_strbuf_init(mem, &node->content, 0); + node->type = (uint16_t)type; switch (node->type) { case CMARK_NODE_HEADING: @@ -94,33 +97,36 @@ cmark_node *cmark_node_new(cmark_node_type type) { return node; } +cmark_node *cmark_node_new(cmark_node_type type) { + extern cmark_mem DEFAULT_MEM_ALLOCATOR; + return cmark_node_new_with_mem(type, &DEFAULT_MEM_ALLOCATOR); +} + // 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); - } + cmark_strbuf_free(&e->content); switch (e->type) { case CMARK_NODE_CODE_BLOCK: - cmark_chunk_free(&e->as.code.info); - cmark_chunk_free(&e->as.code.literal); + cmark_chunk_free(NODE_MEM(e), &e->as.code.info); + cmark_chunk_free(NODE_MEM(e), &e->as.code.literal); break; case CMARK_NODE_TEXT: case CMARK_NODE_HTML_INLINE: case CMARK_NODE_CODE: case CMARK_NODE_HTML_BLOCK: - cmark_chunk_free(&e->as.literal); + cmark_chunk_free(NODE_MEM(e), &e->as.literal); break; case CMARK_NODE_LINK: case CMARK_NODE_IMAGE: - cmark_chunk_free(&e->as.link.url); - cmark_chunk_free(&e->as.link.title); + cmark_chunk_free(NODE_MEM(e), &e->as.link.url); + cmark_chunk_free(NODE_MEM(e), &e->as.link.title); break; case CMARK_NODE_CUSTOM_BLOCK: case CMARK_NODE_CUSTOM_INLINE: - cmark_chunk_free(&e->as.custom.on_enter); - cmark_chunk_free(&e->as.custom.on_exit); + cmark_chunk_free(NODE_MEM(e), &e->as.custom.on_enter); + cmark_chunk_free(NODE_MEM(e), &e->as.custom.on_exit); break; default: break; @@ -131,7 +137,7 @@ static void S_free_nodes(cmark_node *e) { e->next = e->first_child; } next = e->next; - free(e); + NODE_MEM(e)->free(e); e = next; } } @@ -146,7 +152,7 @@ cmark_node_type cmark_node_get_type(cmark_node *node) { if (node == NULL) { return CMARK_NODE_NONE; } else { - return node->type; + return (cmark_node_type)node->type; } } @@ -269,10 +275,10 @@ const char *cmark_node_get_literal(cmark_node *node) { case CMARK_NODE_TEXT: case CMARK_NODE_HTML_INLINE: case CMARK_NODE_CODE: - return cmark_chunk_to_cstr(&node->as.literal); + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.literal); case CMARK_NODE_CODE_BLOCK: - return cmark_chunk_to_cstr(&node->as.code.literal); + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.code.literal); default: break; @@ -291,11 +297,11 @@ int cmark_node_set_literal(cmark_node *node, const char *content) { case CMARK_NODE_TEXT: case CMARK_NODE_HTML_INLINE: case CMARK_NODE_CODE: - cmark_chunk_set_cstr(&node->as.literal, content); + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.literal, content); return 1; case CMARK_NODE_CODE_BLOCK: - cmark_chunk_set_cstr(&node->as.code.literal, content); + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.code.literal, content); return 1; default: @@ -452,7 +458,7 @@ const char *cmark_node_get_fence_info(cmark_node *node) { } if (node->type == CMARK_NODE_CODE_BLOCK) { - return cmark_chunk_to_cstr(&node->as.code.info); + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.code.info); } else { return NULL; } @@ -464,7 +470,7 @@ int cmark_node_set_fence_info(cmark_node *node, const char *info) { } if (node->type == CMARK_NODE_CODE_BLOCK) { - cmark_chunk_set_cstr(&node->as.code.info, info); + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.code.info, info); return 1; } else { return 0; @@ -479,7 +485,7 @@ const char *cmark_node_get_url(cmark_node *node) { switch (node->type) { case CMARK_NODE_LINK: case CMARK_NODE_IMAGE: - return cmark_chunk_to_cstr(&node->as.link.url); + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.link.url); default: break; } @@ -495,7 +501,7 @@ int cmark_node_set_url(cmark_node *node, const char *url) { switch (node->type) { case CMARK_NODE_LINK: case CMARK_NODE_IMAGE: - cmark_chunk_set_cstr(&node->as.link.url, url); + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.link.url, url); return 1; default: break; @@ -512,7 +518,7 @@ const char *cmark_node_get_title(cmark_node *node) { switch (node->type) { case CMARK_NODE_LINK: case CMARK_NODE_IMAGE: - return cmark_chunk_to_cstr(&node->as.link.title); + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.link.title); default: break; } @@ -528,7 +534,7 @@ int cmark_node_set_title(cmark_node *node, const char *title) { switch (node->type) { case CMARK_NODE_LINK: case CMARK_NODE_IMAGE: - cmark_chunk_set_cstr(&node->as.link.title, title); + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.link.title, title); return 1; default: break; @@ -545,7 +551,7 @@ const char *cmark_node_get_on_enter(cmark_node *node) { switch (node->type) { case CMARK_NODE_CUSTOM_INLINE: case CMARK_NODE_CUSTOM_BLOCK: - return cmark_chunk_to_cstr(&node->as.custom.on_enter); + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.custom.on_enter); default: break; } @@ -561,7 +567,7 @@ int cmark_node_set_on_enter(cmark_node *node, const char *on_enter) { switch (node->type) { case CMARK_NODE_CUSTOM_INLINE: case CMARK_NODE_CUSTOM_BLOCK: - cmark_chunk_set_cstr(&node->as.custom.on_enter, on_enter); + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.custom.on_enter, on_enter); return 1; default: break; @@ -578,7 +584,7 @@ const char *cmark_node_get_on_exit(cmark_node *node) { switch (node->type) { case CMARK_NODE_CUSTOM_INLINE: case CMARK_NODE_CUSTOM_BLOCK: - return cmark_chunk_to_cstr(&node->as.custom.on_exit); + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.custom.on_exit); default: break; } @@ -594,7 +600,7 @@ int cmark_node_set_on_exit(cmark_node *node, const char *on_exit) { switch (node->type) { case CMARK_NODE_CUSTOM_INLINE: case CMARK_NODE_CUSTOM_BLOCK: - cmark_chunk_set_cstr(&node->as.custom.on_exit, on_exit); + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.custom.on_exit, on_exit); return 1; default: break; diff --git a/node.h b/node.h index 397d8e3..65d857f 100644 --- a/node.h +++ b/node.h @@ -25,11 +25,10 @@ typedef struct { 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; + uint8_t fence_length; + uint8_t fence_offset; unsigned char fence_char; - bool fenced; + int8_t fenced; } cmark_code; typedef struct { @@ -47,7 +46,14 @@ typedef struct { cmark_chunk on_exit; } cmark_custom; +enum cmark_node__internal_flags { + CMARK_NODE__OPEN = (1 << 0), + CMARK_NODE__LAST_LINE_BLANK = (1 << 1), +}; + struct cmark_node { + cmark_strbuf content; + struct cmark_node *next; struct cmark_node *prev; struct cmark_node *parent; @@ -60,13 +66,8 @@ struct cmark_node { int start_column; int end_line; int end_column; - - cmark_node_type type; - - bool open; - bool last_line_blank; - - cmark_strbuf string_content; + uint16_t type; + uint16_t flags; union { cmark_chunk literal; @@ -79,6 +80,9 @@ struct cmark_node { } as; }; +static CMARK_INLINE cmark_mem *cmark_node_mem(cmark_node *node) { + return node->content.mem; +} CMARK_EXPORT int cmark_node_check(cmark_node *node, FILE *out); #ifdef __cplusplus diff --git a/parser.h b/parser.h index ab21d0f..0c5033b 100644 --- a/parser.h +++ b/parser.h @@ -4,6 +4,7 @@ #include #include "node.h" #include "buffer.h" +#include "memory.h" #ifdef __cplusplus extern "C" { @@ -12,6 +13,7 @@ extern "C" { #define MAX_LINK_LABEL_LENGTH 1000 struct cmark_parser { + struct cmark_mem *mem; struct cmark_reference_map *refmap; struct cmark_node *root; struct cmark_node *current; @@ -23,9 +25,9 @@ struct cmark_parser { int indent; bool blank; bool partially_consumed_tab; - cmark_strbuf *curline; + cmark_strbuf curline; bufsize_t last_line_length; - cmark_strbuf *linebuf; + cmark_strbuf linebuf; int options; bool last_buffer_ended_with_cr; }; diff --git a/references.c b/references.c index 6cb2b20..e141213 100644 --- a/references.c +++ b/references.c @@ -14,12 +14,13 @@ static unsigned int refhash(const unsigned char *link_ref) { return hash; } -static void reference_free(cmark_reference *ref) { +static void reference_free(cmark_reference_map *map, cmark_reference *ref) { + cmark_mem *mem = map->mem; if (ref != NULL) { - free(ref->label); - cmark_chunk_free(&ref->url); - cmark_chunk_free(&ref->title); - free(ref); + mem->free(ref->label); + cmark_chunk_free(mem, &ref->url); + cmark_chunk_free(mem, &ref->title); + mem->free(ref); } } @@ -27,8 +28,8 @@ static void reference_free(cmark_reference *ref) { // 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; +static unsigned char *normalize_reference(cmark_mem *mem, cmark_chunk *ref) { + cmark_strbuf normalized = CMARK_BUF_INIT(mem); unsigned char *result; if (ref == NULL) @@ -57,7 +58,7 @@ static void add_reference(cmark_reference_map *map, cmark_reference *ref) { while (t) { if (t->hash == ref->hash && !strcmp((char *)t->label, (char *)ref->label)) { - reference_free(ref); + reference_free(map, ref); return; } @@ -70,22 +71,20 @@ static void add_reference(cmark_reference_map *map, cmark_reference *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); + unsigned char *reflabel = normalize_reference(map->mem, 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; + ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref)); + ref->label = reflabel; + ref->hash = refhash(ref->label); + ref->url = cmark_clean_url(map->mem, url); + ref->title = cmark_clean_title(map->mem, title); + ref->next = NULL; - add_reference(map, ref); - } + add_reference(map, ref); } // Returns reference if refmap contains a reference with matching @@ -96,13 +95,13 @@ cmark_reference *cmark_reference_lookup(cmark_reference_map *map, unsigned char *norm; unsigned int hash; - if (label->len > MAX_LINK_LABEL_LENGTH) + if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH) return NULL; if (map == NULL) return NULL; - norm = normalize_reference(label); + norm = normalize_reference(map->mem, label); if (norm == NULL) return NULL; @@ -131,7 +130,7 @@ void cmark_reference_map_free(cmark_reference_map *map) { while (ref) { next = ref->next; - reference_free(ref); + reference_free(map, ref); ref = next; } } @@ -139,6 +138,9 @@ void cmark_reference_map_free(cmark_reference_map *map) { free(map); } -cmark_reference_map *cmark_reference_map_new(void) { - return (cmark_reference_map *)calloc(1, sizeof(cmark_reference_map)); +cmark_reference_map *cmark_reference_map_new(cmark_mem *mem) { + cmark_reference_map *map = + (cmark_reference_map *)mem->calloc(1, sizeof(cmark_reference_map)); + map->mem = mem; + return map; } diff --git a/references.h b/references.h index 310ff9f..f075bbb 100644 --- a/references.h +++ b/references.h @@ -1,6 +1,7 @@ #ifndef CMARK_REFERENCES_H #define CMARK_REFERENCES_H +#include "memory.h" #include "chunk.h" #ifdef __cplusplus @@ -20,12 +21,13 @@ struct cmark_reference { typedef struct cmark_reference cmark_reference; struct cmark_reference_map { + cmark_mem *mem; cmark_reference *table[REFMAP_SIZE]; }; typedef struct cmark_reference_map cmark_reference_map; -cmark_reference_map *cmark_reference_map_new(void); +cmark_reference_map *cmark_reference_map_new(cmark_mem *mem); void cmark_reference_map_free(cmark_reference_map *map); cmark_reference *cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label); diff --git a/render.c b/render.c index 50f03e6..20dca5f 100644 --- a/render.c +++ b/render.c @@ -4,6 +4,7 @@ #include "cmark.h" #include "utf8.h" #include "render.h" +#include "node.h" static CMARK_INLINE void S_cr(cmark_renderer *renderer) { if (renderer->need_cr < 1) { @@ -19,7 +20,7 @@ static CMARK_INLINE void S_blankline(cmark_renderer *renderer) { static void S_out(cmark_renderer *renderer, const char *source, bool wrap, cmark_escaping escape) { - int length = cmark_strbuf_safe_strlen(source); + int length = strlen(source); unsigned char nextc; int32_t c; int i = 0; @@ -28,7 +29,7 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, cmark_chunk remainder = cmark_chunk_literal(""); int k = renderer->buffer->size - 1; - wrap = wrap && !renderer->no_wrap; + wrap = wrap && !renderer->no_linebreaks; if (renderer->in_tight_list_item && renderer->need_cr > 1) { renderer->need_cr = 1; @@ -108,8 +109,9 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, !renderer->begin_line && renderer->last_breakable > 0) { // copy from last_breakable to remainder - cmark_chunk_set_cstr(&remainder, (char *)renderer->buffer->ptr + - renderer->last_breakable + 1); + cmark_chunk_set_cstr(renderer->mem, &remainder, + (char *)renderer->buffer->ptr + + renderer->last_breakable + 1); // truncate at last_breakable cmark_strbuf_truncate(renderer->buffer, renderer->last_breakable); // add newline, prefix, and remainder @@ -118,7 +120,7 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap, renderer->prefix->size); cmark_strbuf_put(renderer->buffer, remainder.data, remainder.len); renderer->column = renderer->prefix->size + remainder.len; - cmark_chunk_free(&remainder); + cmark_chunk_free(renderer->mem, &remainder); renderer->last_breakable = 0; renderer->begin_line = false; renderer->begin_content = false; @@ -146,16 +148,17 @@ char *cmark_render(cmark_node *root, int options, int width, int (*render_node)(cmark_renderer *renderer, cmark_node *node, cmark_event_type ev_type, int options)) { - cmark_strbuf pref = GH_BUF_INIT; - cmark_strbuf buf = GH_BUF_INIT; + cmark_mem *mem = cmark_node_mem(root); + cmark_strbuf pref = CMARK_BUF_INIT(mem); + cmark_strbuf buf = CMARK_BUF_INIT(mem); cmark_node *cur; cmark_event_type ev_type; char *result; cmark_iter *iter = cmark_iter_new(root); - cmark_renderer renderer = {&buf, &pref, 0, width, 0, - 0, true, true, false, false, - outc, S_cr, S_blankline, S_out}; + cmark_renderer renderer = {mem, &buf, &pref, 0, width, + 0, 0, true, true, false, + false, outc, S_cr, S_blankline, S_out}; while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { cur = cmark_iter_get_node(iter); diff --git a/render.h b/render.h index 479936a..35eb0a6 100644 --- a/render.h +++ b/render.h @@ -8,10 +8,12 @@ extern "C" { #include #include "buffer.h" #include "chunk.h" +#include "memory.h" typedef enum { LITERAL, NORMAL, TITLE, URL } cmark_escaping; struct cmark_renderer { + cmark_mem *mem; cmark_strbuf *buffer; cmark_strbuf *prefix; int column; @@ -20,7 +22,7 @@ struct cmark_renderer { bufsize_t last_breakable; bool begin_line; bool begin_content; - bool no_wrap; + bool no_linebreaks; bool in_tight_list_item; void (*outc)(struct cmark_renderer *, cmark_escaping, int32_t, unsigned char); void (*cr)(struct cmark_renderer *); diff --git a/scanners.c b/scanners.c index 712093c..709a74e 100644 --- a/scanners.c +++ b/scanners.c @@ -8258,37 +8258,45 @@ bufsize_t _scan_html_tag(const unsigned char *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, + 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, 199, 230, 70, 230, 230, 230, 230, 134, 230, 230, 230, - 230, 230, 254, 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, + 230, 230, 230, 230, 199, 230, 70, 230, 230, 230, 230, 134, 230, 230, + 230, 230, 230, 254, 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, 230, 230, 226, 230, 246, 198, 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, 230, 230, 230, 230, - 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 230, 230, 230, + 230, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, /* table 9 .. 11: 256 */ - 0, 160, 160, 160, 160, 160, 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, 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, + 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, 160, 160, 160, 160, 160, 160, 160, 160, + 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 160, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); if (yych <= '`') { @@ -18244,18 +18252,18 @@ bufsize_t _scan_atx_heading_start(const unsigned char *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, + 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, 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 = *(marker = p); if (yych <= 0xDF) { @@ -18293,7 +18301,9 @@ bufsize_t _scan_atx_heading_start(const unsigned char *p) { goto yy1170; } if (yych <= '\f') { - if (yych == '\n') + if (yych <= 0x08) + goto yy1157; + if (yych <= '\n') goto yy1168; goto yy1157; } else { @@ -18373,7 +18383,9 @@ bufsize_t _scan_atx_heading_start(const unsigned char *p) { goto yy1170; } if (yych <= '\f') { - if (yych == '\n') + if (yych <= 0x08) + goto yy1161; + if (yych <= '\n') goto yy1168; goto yy1161; } else { @@ -18387,7 +18399,9 @@ bufsize_t _scan_atx_heading_start(const unsigned char *p) { goto yy1170; } if (yych <= '\f') { - if (yych == '\n') + if (yych <= 0x08) + goto yy1161; + if (yych <= '\n') goto yy1168; goto yy1161; } else { @@ -18401,7 +18415,9 @@ bufsize_t _scan_atx_heading_start(const unsigned char *p) { goto yy1170; } if (yych <= '\f') { - if (yych == '\n') + if (yych <= 0x08) + goto yy1161; + if (yych <= '\n') goto yy1168; goto yy1161; } else { @@ -18415,7 +18431,9 @@ bufsize_t _scan_atx_heading_start(const unsigned char *p) { goto yy1170; } if (yych <= '\f') { - if (yych == '\n') + if (yych <= 0x08) + goto yy1161; + if (yych <= '\n') goto yy1168; goto yy1161; } else { @@ -18428,7 +18446,9 @@ bufsize_t _scan_atx_heading_start(const unsigned char *p) { if (yybm[0 + (yych = *p)] & 128) { goto yy1170; } - if (yych == '\n') + if (yych <= 0x08) + goto yy1161; + if (yych <= '\n') goto yy1168; if (yych == '\r') goto yy1168; @@ -18656,18 +18676,19 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { { unsigned char yych; static const unsigned char yybm[] = { - 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, 248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 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, 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, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 128, 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, 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 = *(marker = p); if (yych <= 0x7F) { @@ -18716,21 +18737,33 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { yy1205 : { return 0; } yy1206: yych = *(marker = ++p); - if (yych == ' ') - goto yy1242; - if (yych == '*') - goto yy1244; - goto yy1205; + if (yych <= 0x1F) { + if (yych == '\t') + goto yy1238; + goto yy1205; + } else { + if (yych <= ' ') + goto yy1238; + if (yych == '*') + goto yy1240; + goto yy1205; + } yy1207: yych = *(marker = ++p); - if (yych == ' ') - goto yy1230; - if (yych == '_') - goto yy1232; - goto yy1205; + if (yych <= 0x1F) { + if (yych == '\t') + goto yy1228; + goto yy1205; + } else { + if (yych <= ' ') + goto yy1228; + if (yych == '_') + goto yy1230; + goto yy1205; + } yy1208: yych = *(marker = ++p); - if (yybm[0 + yych] & 8) { + if (yybm[0 + yych] & 16) { goto yy1218; } if (yych == '-') @@ -18793,7 +18826,7 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { yy1218: ++p; yych = *p; - if (yybm[0 + yych] & 8) { + if (yybm[0 + yych] & 16) { goto yy1218; } if (yych != '-') @@ -18801,10 +18834,16 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { yy1220: ++p; yych = *p; - if (yych == ' ') - goto yy1220; - if (yych != '-') + if (yych <= 0x1F) { + if (yych == '\t') + goto yy1220; goto yy1211; + } else { + if (yych <= ' ') + goto yy1220; + if (yych != '-') + goto yy1211; + } yy1222: ++p; yych = *p; @@ -18812,12 +18851,12 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { if (yych <= '\t') { if (yych <= 0x08) goto yy1211; + goto yy1222; } else { if (yych <= '\n') - goto yy1226; + goto yy1224; if (yych <= '\f') goto yy1211; - goto yy1226; } } else { if (yych <= ' ') { @@ -18826,194 +18865,160 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { goto yy1222; } else { if (yych == '-') - goto yy1228; + goto yy1226; goto yy1211; } } yy1224: + ++p; + { return (bufsize_t)(p - start); } + yy1226: ++p; yych = *p; - if (yybm[0 + yych] & 16) { - goto yy1224; + if (yybm[0 + yych] & 32) { + goto yy1226; } if (yych <= 0x08) goto yy1211; if (yych <= '\n') - goto yy1226; - if (yych != '\r') - goto yy1211; - yy1226: - ++p; - { return (bufsize_t)(p - start); } + goto yy1224; + if (yych == '\r') + goto yy1224; + goto yy1211; yy1228: ++p; yych = *p; - if (yybm[0 + yych] & 32) { - goto yy1228; - } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy1211; - if (yych <= '\t') - goto yy1224; - goto yy1226; - } else { - if (yych == '\r') - goto yy1226; + if (yych <= 0x1F) { + if (yych == '\t') + goto yy1228; goto yy1211; + } else { + if (yych <= ' ') + goto yy1228; + if (yych != '_') + goto yy1211; } yy1230: ++p; yych = *p; - if (yych == ' ') - goto yy1230; - if (yych != '_') + if (yych <= 0x1F) { + if (yych == '\t') + goto yy1230; goto yy1211; + } else { + if (yych <= ' ') + goto yy1230; + if (yych != '_') + goto yy1211; + } yy1232: - ++p; - yych = *p; - if (yych == ' ') - goto yy1232; - if (yych != '_') - goto yy1211; - yy1234: ++p; yych = *p; if (yych <= '\r') { if (yych <= '\t') { if (yych <= 0x08) goto yy1211; + goto yy1232; } else { if (yych <= '\n') - goto yy1238; + goto yy1234; if (yych <= '\f') goto yy1211; - goto yy1238; } } else { if (yych <= ' ') { if (yych <= 0x1F) goto yy1211; - goto yy1234; + goto yy1232; } else { if (yych == '_') - goto yy1240; + goto yy1236; goto yy1211; } } - yy1236: - ++p; - yych = *p; - if (yych <= '\f') { - if (yych <= 0x08) - goto yy1211; - if (yych <= '\t') - goto yy1236; - if (yych >= '\v') - goto yy1211; - } else { - if (yych <= '\r') - goto yy1238; - if (yych == ' ') - goto yy1236; - goto yy1211; - } - yy1238: + yy1234: ++p; { return (bufsize_t)(p - start); } - yy1240: + yy1236: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1240; + goto yy1236; } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy1211; - if (yych <= '\t') - goto yy1236; - goto yy1238; - } else { - if (yych == '\r') - goto yy1238; + if (yych <= 0x08) goto yy1211; - } - yy1242: + if (yych <= '\n') + goto yy1234; + if (yych == '\r') + goto yy1234; + goto yy1211; + yy1238: ++p; yych = *p; - if (yych == ' ') - goto yy1242; - if (yych != '*') + if (yych <= 0x1F) { + if (yych == '\t') + goto yy1238; goto yy1211; - yy1244: + } else { + if (yych <= ' ') + goto yy1238; + if (yych != '*') + goto yy1211; + } + yy1240: ++p; yych = *p; - if (yych == ' ') - goto yy1244; - if (yych != '*') + if (yych <= 0x1F) { + if (yych == '\t') + goto yy1240; goto yy1211; - yy1246: + } else { + if (yych <= ' ') + goto yy1240; + if (yych != '*') + goto yy1211; + } + yy1242: ++p; yych = *p; if (yych <= '\r') { if (yych <= '\t') { if (yych <= 0x08) goto yy1211; + goto yy1242; } else { if (yych <= '\n') - goto yy1250; + goto yy1244; if (yych <= '\f') goto yy1211; - goto yy1250; } } else { if (yych <= ' ') { if (yych <= 0x1F) goto yy1211; - goto yy1246; + goto yy1242; } else { if (yych == '*') - goto yy1252; + goto yy1246; goto yy1211; } } - yy1248: - ++p; - yych = *p; - if (yych <= '\f') { - if (yych <= 0x08) - goto yy1211; - if (yych <= '\t') - goto yy1248; - if (yych >= '\v') - goto yy1211; - } else { - if (yych <= '\r') - goto yy1250; - if (yych == ' ') - goto yy1248; - goto yy1211; - } - yy1250: + yy1244: ++p; { return (bufsize_t)(p - start); } - yy1252: + yy1246: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1252; + goto yy1246; } - if (yych <= '\n') { - if (yych <= 0x08) - goto yy1211; - if (yych <= '\t') - goto yy1248; - goto yy1250; - } else { - if (yych == '\r') - goto yy1250; + if (yych <= 0x08) goto yy1211; - } + if (yych <= '\n') + goto yy1244; + if (yych == '\r') + goto yy1244; + goto yy1211; } } @@ -19049,374 +19054,374 @@ bufsize_t _scan_open_code_fence(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '`') { if (yych == '\n') - goto yy1256; + goto yy1250; if (yych <= '_') - goto yy1259; - goto yy1257; + goto yy1253; + goto yy1251; } else { if (yych == '~') - goto yy1258; + goto yy1252; if (yych <= 0x7F) - goto yy1259; + goto yy1253; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1260; + goto yy1254; if (yych <= 0xE0) - goto yy1262; + goto yy1256; if (yych <= 0xEC) - goto yy1263; - goto yy1267; + goto yy1257; + goto yy1261; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1263; - goto yy1264; + goto yy1257; + goto yy1258; } else { if (yych <= 0xF3) - goto yy1265; + goto yy1259; if (yych <= 0xF4) - goto yy1266; + goto yy1260; } } } - yy1256 : { return 0; } - yy1257: + yy1250 : { return 0; } + yy1251: yych = *(marker = ++p); if (yych == '`') - goto yy1282; - goto yy1256; - yy1258: + goto yy1276; + goto yy1250; + yy1252: yych = *(marker = ++p); if (yych == '~') - goto yy1268; - goto yy1256; - yy1259: + goto yy1262; + goto yy1250; + yy1253: yych = *++p; - goto yy1256; - yy1260: + goto yy1250; + yy1254: yych = *++p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1259; - yy1261: + goto yy1253; + yy1255: p = marker; - goto yy1256; - yy1262: + goto yy1250; + yy1256: yych = *++p; if (yych <= 0x9F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1260; - goto yy1261; - yy1263: + goto yy1254; + goto yy1255; + yy1257: yych = *++p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1260; - goto yy1261; - yy1264: + goto yy1254; + goto yy1255; + yy1258: yych = *++p; if (yych <= 0x8F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1263; - goto yy1261; - yy1265: + goto yy1257; + goto yy1255; + yy1259: yych = *++p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1263; - goto yy1261; - yy1266: + goto yy1257; + goto yy1255; + yy1260: yych = *++p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0x8F) - goto yy1263; - goto yy1261; - yy1267: + goto yy1257; + goto yy1255; + yy1261: yych = *++p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0x9F) - goto yy1260; - goto yy1261; - yy1268: + goto yy1254; + goto yy1255; + yy1262: yych = *++p; if (yybm[0 + yych] & 16) { - goto yy1269; + goto yy1263; } - goto yy1261; - yy1269: + goto yy1255; + yy1263: ++p; yych = *p; marker = p; if (yybm[0 + yych] & 32) { - goto yy1271; + goto yy1265; } if (yych <= 0xE0) { if (yych <= '~') { if (yych <= 0x00) - goto yy1261; + goto yy1255; if (yych <= '\r') - goto yy1280; - goto yy1269; + goto yy1274; + goto yy1263; } else { if (yych <= 0xC1) - goto yy1261; + goto yy1255; if (yych <= 0xDF) - goto yy1273; - goto yy1274; + goto yy1267; + goto yy1268; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1279; - goto yy1275; + goto yy1273; + goto yy1269; } else { if (yych <= 0xF0) - goto yy1276; + goto yy1270; if (yych <= 0xF3) - goto yy1277; + goto yy1271; if (yych <= 0xF4) - goto yy1278; - goto yy1261; + goto yy1272; + goto yy1255; } } - yy1271: + yy1265: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1271; + goto yy1265; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1261; + goto yy1255; if (yych <= '\r') - goto yy1280; - goto yy1261; + goto yy1274; + goto yy1255; } else { if (yych <= 0xDF) - goto yy1273; + goto yy1267; if (yych <= 0xE0) - goto yy1274; - goto yy1275; + goto yy1268; + goto yy1269; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1279; + goto yy1273; if (yych <= 0xEF) - goto yy1275; - goto yy1276; + goto yy1269; + goto yy1270; } else { if (yych <= 0xF3) - goto yy1277; + goto yy1271; if (yych <= 0xF4) - goto yy1278; - goto yy1261; + goto yy1272; + goto yy1255; } } - yy1273: + yy1267: ++p; yych = *p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1271; - goto yy1261; - yy1274: + goto yy1265; + goto yy1255; + yy1268: ++p; yych = *p; if (yych <= 0x9F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1273; - goto yy1261; - yy1275: + goto yy1267; + goto yy1255; + yy1269: ++p; yych = *p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1273; - goto yy1261; - yy1276: + goto yy1267; + goto yy1255; + yy1270: ++p; yych = *p; if (yych <= 0x8F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1275; - goto yy1261; - yy1277: + goto yy1269; + goto yy1255; + yy1271: ++p; yych = *p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1275; - goto yy1261; - yy1278: + goto yy1269; + goto yy1255; + yy1272: ++p; yych = *p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0x8F) - goto yy1275; - goto yy1261; - yy1279: + goto yy1269; + goto yy1255; + yy1273: ++p; yych = *p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0x9F) - goto yy1273; - goto yy1261; - yy1280: + goto yy1267; + goto yy1255; + yy1274: ++p; p = marker; { return (bufsize_t)(p - start); } - yy1282: + yy1276: yych = *++p; if (yybm[0 + yych] & 64) { - goto yy1283; + goto yy1277; } - goto yy1261; - yy1283: + goto yy1255; + yy1277: ++p; yych = *p; marker = p; if (yybm[0 + yych] & 128) { - goto yy1285; + goto yy1279; } if (yych <= 0xE0) { if (yych <= '`') { if (yych <= 0x00) - goto yy1261; + goto yy1255; if (yych <= '\r') - goto yy1294; - goto yy1283; + goto yy1288; + goto yy1277; } else { if (yych <= 0xC1) - goto yy1261; + goto yy1255; if (yych <= 0xDF) - goto yy1287; - goto yy1288; + goto yy1281; + goto yy1282; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1293; - goto yy1289; + goto yy1287; + goto yy1283; } else { if (yych <= 0xF0) - goto yy1290; + goto yy1284; if (yych <= 0xF3) - goto yy1291; + goto yy1285; if (yych <= 0xF4) - goto yy1292; - goto yy1261; + goto yy1286; + goto yy1255; } } - yy1285: + yy1279: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1285; + goto yy1279; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1261; + goto yy1255; if (yych <= '\r') - goto yy1294; - goto yy1261; + goto yy1288; + goto yy1255; } else { if (yych <= 0xDF) - goto yy1287; + goto yy1281; if (yych <= 0xE0) - goto yy1288; - goto yy1289; + goto yy1282; + goto yy1283; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1293; + goto yy1287; if (yych <= 0xEF) - goto yy1289; - goto yy1290; + goto yy1283; + goto yy1284; } else { if (yych <= 0xF3) - goto yy1291; + goto yy1285; if (yych <= 0xF4) - goto yy1292; - goto yy1261; + goto yy1286; + goto yy1255; } } - yy1287: + yy1281: ++p; yych = *p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1285; - goto yy1261; - yy1288: + goto yy1279; + goto yy1255; + yy1282: ++p; yych = *p; if (yych <= 0x9F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1287; - goto yy1261; - yy1289: + goto yy1281; + goto yy1255; + yy1283: ++p; yych = *p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1287; - goto yy1261; - yy1290: + goto yy1281; + goto yy1255; + yy1284: ++p; yych = *p; if (yych <= 0x8F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1289; - goto yy1261; - yy1291: + goto yy1283; + goto yy1255; + yy1285: ++p; yych = *p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0xBF) - goto yy1289; - goto yy1261; - yy1292: + goto yy1283; + goto yy1255; + yy1286: ++p; yych = *p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0x8F) - goto yy1289; - goto yy1261; - yy1293: + goto yy1283; + goto yy1255; + yy1287: ++p; yych = *p; if (yych <= 0x7F) - goto yy1261; + goto yy1255; if (yych <= 0x9F) - goto yy1287; - goto yy1261; - yy1294: + goto yy1281; + goto yy1255; + yy1288: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -19448,190 +19453,190 @@ bufsize_t _scan_close_code_fence(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '`') { if (yych == '\n') - goto yy1298; + goto yy1292; if (yych <= '_') - goto yy1301; - goto yy1299; + goto yy1295; + goto yy1293; } else { if (yych == '~') - goto yy1300; + goto yy1294; if (yych <= 0x7F) - goto yy1301; + goto yy1295; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1302; + goto yy1296; if (yych <= 0xE0) - goto yy1304; + goto yy1298; if (yych <= 0xEC) - goto yy1305; - goto yy1309; + goto yy1299; + goto yy1303; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy1305; - goto yy1306; + goto yy1299; + goto yy1300; } else { if (yych <= 0xF3) - goto yy1307; + goto yy1301; if (yych <= 0xF4) - goto yy1308; + goto yy1302; } } } - yy1298 : { return 0; } - yy1299: + yy1292 : { return 0; } + yy1293: yych = *(marker = ++p); if (yych == '`') - goto yy1317; - goto yy1298; - yy1300: + goto yy1311; + goto yy1292; + yy1294: yych = *(marker = ++p); if (yych == '~') - goto yy1310; - goto yy1298; - yy1301: + goto yy1304; + goto yy1292; + yy1295: yych = *++p; - goto yy1298; - yy1302: + goto yy1292; + yy1296: yych = *++p; if (yych <= 0x7F) - goto yy1303; + goto yy1297; if (yych <= 0xBF) - goto yy1301; - yy1303: + goto yy1295; + yy1297: p = marker; - goto yy1298; - yy1304: + goto yy1292; + yy1298: yych = *++p; if (yych <= 0x9F) - goto yy1303; + goto yy1297; if (yych <= 0xBF) - goto yy1302; - goto yy1303; - yy1305: + goto yy1296; + goto yy1297; + yy1299: yych = *++p; if (yych <= 0x7F) - goto yy1303; + goto yy1297; if (yych <= 0xBF) - goto yy1302; - goto yy1303; - yy1306: + goto yy1296; + goto yy1297; + yy1300: yych = *++p; if (yych <= 0x8F) - goto yy1303; + goto yy1297; if (yych <= 0xBF) - goto yy1305; - goto yy1303; - yy1307: + goto yy1299; + goto yy1297; + yy1301: yych = *++p; if (yych <= 0x7F) - goto yy1303; + goto yy1297; if (yych <= 0xBF) - goto yy1305; - goto yy1303; - yy1308: + goto yy1299; + goto yy1297; + yy1302: yych = *++p; if (yych <= 0x7F) - goto yy1303; + goto yy1297; if (yych <= 0x8F) - goto yy1305; - goto yy1303; - yy1309: + goto yy1299; + goto yy1297; + yy1303: yych = *++p; if (yych <= 0x7F) - goto yy1303; + goto yy1297; if (yych <= 0x9F) - goto yy1302; - goto yy1303; - yy1310: + goto yy1296; + goto yy1297; + yy1304: yych = *++p; if (yybm[0 + yych] & 32) { - goto yy1311; + goto yy1305; } - goto yy1303; - yy1311: + goto yy1297; + yy1305: ++p; yych = *p; marker = p; if (yybm[0 + yych] & 64) { - goto yy1313; + goto yy1307; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1303; + goto yy1297; if (yych <= '\n') - goto yy1315; - goto yy1303; + goto yy1309; + goto yy1297; } else { if (yych <= '\r') - goto yy1315; + goto yy1309; if (yych == '~') - goto yy1311; - goto yy1303; + goto yy1305; + goto yy1297; } - yy1313: + yy1307: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1313; + goto yy1307; } if (yych <= 0x08) - goto yy1303; + goto yy1297; if (yych <= '\n') - goto yy1315; + goto yy1309; if (yych != '\r') - goto yy1303; - yy1315: + goto yy1297; + yy1309: ++p; p = marker; { return (bufsize_t)(p - start); } - yy1317: + yy1311: yych = *++p; if (yybm[0 + yych] & 128) { - goto yy1318; + goto yy1312; } - goto yy1303; - yy1318: + goto yy1297; + yy1312: ++p; yych = *p; marker = p; if (yybm[0 + yych] & 128) { - goto yy1318; + goto yy1312; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1303; + goto yy1297; if (yych <= '\t') - goto yy1320; + goto yy1314; if (yych <= '\n') - goto yy1322; - goto yy1303; + goto yy1316; + goto yy1297; } else { if (yych <= '\r') - goto yy1322; + goto yy1316; if (yych != ' ') - goto yy1303; + goto yy1297; } - yy1320: + yy1314: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) - goto yy1303; + goto yy1297; if (yych <= '\t') - goto yy1320; + goto yy1314; if (yych >= '\v') - goto yy1303; + goto yy1297; } else { if (yych <= '\r') - goto yy1322; + goto yy1316; if (yych == ' ') - goto yy1320; - goto yy1303; + goto yy1314; + goto yy1297; } - yy1322: + yy1316: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -19650,997 +19655,997 @@ bufsize_t _scan_entity(const unsigned char *p) { if (yych <= 0xDF) { if (yych <= '%') { if (yych != '\n') - goto yy1328; + goto yy1322; } else { if (yych <= '&') - goto yy1327; + goto yy1321; if (yych <= 0x7F) - goto yy1328; + goto yy1322; if (yych >= 0xC2) - goto yy1329; + goto yy1323; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1331; + goto yy1325; if (yych == 0xED) - goto yy1336; - goto yy1332; + goto yy1330; + goto yy1326; } else { if (yych <= 0xF0) - goto yy1333; + goto yy1327; if (yych <= 0xF3) - goto yy1334; + goto yy1328; if (yych <= 0xF4) - goto yy1335; + goto yy1329; } } - yy1326 : { return 0; } - yy1327: + yy1320 : { return 0; } + yy1321: yych = *(marker = ++p); if (yych <= '@') { if (yych == '#') - goto yy1337; - goto yy1326; + goto yy1331; + goto yy1320; } else { if (yych <= 'Z') - goto yy1338; + goto yy1332; if (yych <= '`') - goto yy1326; + goto yy1320; if (yych <= 'z') - goto yy1338; - goto yy1326; + goto yy1332; + goto yy1320; } - yy1328: + yy1322: yych = *++p; - goto yy1326; - yy1329: + goto yy1320; + yy1323: yych = *++p; if (yych <= 0x7F) - goto yy1330; + goto yy1324; if (yych <= 0xBF) - goto yy1328; - yy1330: + goto yy1322; + yy1324: p = marker; - goto yy1326; - yy1331: + goto yy1320; + yy1325: yych = *++p; if (yych <= 0x9F) - goto yy1330; + goto yy1324; if (yych <= 0xBF) - goto yy1329; - goto yy1330; - yy1332: + goto yy1323; + goto yy1324; + yy1326: yych = *++p; if (yych <= 0x7F) - goto yy1330; + goto yy1324; if (yych <= 0xBF) - goto yy1329; - goto yy1330; - yy1333: + goto yy1323; + goto yy1324; + yy1327: yych = *++p; if (yych <= 0x8F) - goto yy1330; + goto yy1324; if (yych <= 0xBF) - goto yy1332; - goto yy1330; - yy1334: + goto yy1326; + goto yy1324; + yy1328: yych = *++p; if (yych <= 0x7F) - goto yy1330; + goto yy1324; if (yych <= 0xBF) - goto yy1332; - goto yy1330; - yy1335: + goto yy1326; + goto yy1324; + yy1329: yych = *++p; if (yych <= 0x7F) - goto yy1330; + goto yy1324; if (yych <= 0x8F) - goto yy1332; - goto yy1330; - yy1336: + goto yy1326; + goto yy1324; + yy1330: yych = *++p; if (yych <= 0x7F) - goto yy1330; + goto yy1324; if (yych <= 0x9F) - goto yy1329; - goto yy1330; - yy1337: + goto yy1323; + goto yy1324; + yy1331: yych = *++p; if (yych <= 'W') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1373; - goto yy1330; + goto yy1367; + goto yy1324; } else { if (yych <= 'X') - goto yy1372; + goto yy1366; if (yych == 'x') - goto yy1372; - goto yy1330; + goto yy1366; + goto yy1324; } - yy1338: + yy1332: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych >= ':') - goto yy1330; + goto yy1324; } else { if (yych <= 'Z') - goto yy1339; + goto yy1333; if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } - yy1339: + yy1333: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1342; + goto yy1336; if (yych <= ':') - goto yy1330; + goto yy1324; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; - goto yy1342; + goto yy1324; + goto yy1336; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych <= 'z') - goto yy1342; - goto yy1330; + goto yy1336; + goto yy1324; } } - yy1340: + yy1334: ++p; { return (bufsize_t)(p - start); } - yy1342: + yy1336: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1343; + goto yy1337; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1343: + yy1337: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1344; + goto yy1338; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1344: + yy1338: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1345; + goto yy1339; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1345: + yy1339: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1346; + goto yy1340; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1346: + yy1340: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1347; + goto yy1341; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1347: + yy1341: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1348; + goto yy1342; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1348: + yy1342: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1349; + goto yy1343; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1349: + yy1343: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1350; + goto yy1344; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1350: + yy1344: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1351; + goto yy1345; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1351: + yy1345: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1352; + goto yy1346; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1352: + yy1346: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1353; + goto yy1347; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1353: + yy1347: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1354; + goto yy1348; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1354: + yy1348: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1355; + goto yy1349; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1355: + yy1349: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1356; + goto yy1350; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1356: + yy1350: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1357; + goto yy1351; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1357: + yy1351: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1358; + goto yy1352; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1358: + yy1352: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1359; + goto yy1353; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1359: + yy1353: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1360; + goto yy1354; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1360: + yy1354: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1361; + goto yy1355; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1361: + yy1355: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1362; + goto yy1356; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1362: + yy1356: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1363; + goto yy1357; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1363: + yy1357: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1364; + goto yy1358; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1364: + yy1358: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1365; + goto yy1359; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1365: + yy1359: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1366; + goto yy1360; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1366: + yy1360: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1367; + goto yy1361; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1367: + yy1361: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1368; + goto yy1362; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1368: + yy1362: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1369; + goto yy1363; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1369: + yy1363: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1370; + goto yy1364; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1370: + yy1364: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1371; + goto yy1365; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= '{') - goto yy1330; + goto yy1324; } } - yy1371: + yy1365: yych = *++p; if (yych == ';') - goto yy1340; - goto yy1330; - yy1372: + goto yy1334; + goto yy1324; + yy1366: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1380; - goto yy1330; + goto yy1374; + goto yy1324; } else { if (yych <= 'F') - goto yy1380; + goto yy1374; if (yych <= '`') - goto yy1330; + goto yy1324; if (yych <= 'f') - goto yy1380; - goto yy1330; + goto yy1374; + goto yy1324; } - yy1373: + yy1367: yych = *++p; if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1374; + goto yy1368; if (yych == ';') - goto yy1340; - goto yy1330; - yy1374: + goto yy1334; + goto yy1324; + yy1368: yych = *++p; if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1375; + goto yy1369; if (yych == ';') - goto yy1340; - goto yy1330; - yy1375: + goto yy1334; + goto yy1324; + yy1369: yych = *++p; if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1376; + goto yy1370; if (yych == ';') - goto yy1340; - goto yy1330; - yy1376: + goto yy1334; + goto yy1324; + yy1370: yych = *++p; if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1377; + goto yy1371; if (yych == ';') - goto yy1340; - goto yy1330; - yy1377: + goto yy1334; + goto yy1324; + yy1371: yych = *++p; if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1378; + goto yy1372; if (yych == ';') - goto yy1340; - goto yy1330; - yy1378: + goto yy1334; + goto yy1324; + yy1372: yych = *++p; if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1379; + goto yy1373; if (yych == ';') - goto yy1340; - goto yy1330; - yy1379: + goto yy1334; + goto yy1324; + yy1373: yych = *++p; if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1371; + goto yy1365; if (yych == ';') - goto yy1340; - goto yy1330; - yy1380: + goto yy1334; + goto yy1324; + yy1374: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1381; + goto yy1375; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= 'g') - goto yy1330; + goto yy1324; } } - yy1381: + yy1375: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1382; + goto yy1376; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= 'g') - goto yy1330; + goto yy1324; } } - yy1382: + yy1376: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1383; + goto yy1377; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= 'g') - goto yy1330; + goto yy1324; } } - yy1383: + yy1377: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1384; + goto yy1378; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= 'g') - goto yy1330; + goto yy1324; } } - yy1384: + yy1378: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1385; + goto yy1379; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= 'g') - goto yy1330; + goto yy1324; } } - yy1385: + yy1379: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1386; + goto yy1380; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1330; + goto yy1324; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych >= 'g') - goto yy1330; + goto yy1324; } } - yy1386: + yy1380: ++p; if ((yych = *p) <= ';') { if (yych <= '/') - goto yy1330; + goto yy1324; if (yych <= '9') - goto yy1371; + goto yy1365; if (yych <= ':') - goto yy1330; - goto yy1340; + goto yy1324; + goto yy1334; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1330; - goto yy1371; + goto yy1324; + goto yy1365; } else { if (yych <= '`') - goto yy1330; + goto yy1324; if (yych <= 'f') - goto yy1371; - goto yy1330; + goto yy1365; + goto yy1324; } } } @@ -20660,415 +20665,415 @@ bufsize_t _scan_dangerous_url(const unsigned char *p) { if (yych <= 'I') { if (yych <= 'C') { if (yych != '\n') - goto yy1394; + goto yy1388; } else { if (yych <= 'D') - goto yy1390; + goto yy1384; if (yych == 'F') - goto yy1393; - goto yy1394; + goto yy1387; + goto yy1388; } } else { if (yych <= 'V') { if (yych <= 'J') - goto yy1391; + goto yy1385; if (yych <= 'U') - goto yy1394; - goto yy1392; + goto yy1388; + goto yy1386; } else { if (yych == 'd') - goto yy1390; + goto yy1384; if (yych <= 'e') - goto yy1394; - goto yy1393; + goto yy1388; + goto yy1387; } } } else { if (yych <= 0xDF) { if (yych <= 'u') { if (yych == 'j') - goto yy1391; - goto yy1394; + goto yy1385; + goto yy1388; } else { if (yych <= 'v') - goto yy1392; + goto yy1386; if (yych <= 0x7F) - goto yy1394; + goto yy1388; if (yych >= 0xC2) - goto yy1395; + goto yy1389; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1397; + goto yy1391; if (yych == 0xED) - goto yy1402; - goto yy1398; + goto yy1396; + goto yy1392; } else { if (yych <= 0xF0) - goto yy1399; + goto yy1393; if (yych <= 0xF3) - goto yy1400; + goto yy1394; if (yych <= 0xF4) - goto yy1401; + goto yy1395; } } } - yy1389 : { return 0; } - yy1390: + yy1383 : { return 0; } + yy1384: yyaccept = 0; yych = *(marker = ++p); if (yych == 'A') - goto yy1424; + goto yy1418; if (yych == 'a') - goto yy1424; - goto yy1389; - yy1391: + goto yy1418; + goto yy1383; + yy1385: yyaccept = 0; yych = *(marker = ++p); if (yych == 'A') - goto yy1415; + goto yy1409; if (yych == 'a') - goto yy1415; - goto yy1389; - yy1392: + goto yy1409; + goto yy1383; + yy1386: yyaccept = 0; yych = *(marker = ++p); if (yych == 'B') - goto yy1408; + goto yy1402; if (yych == 'b') - goto yy1408; - goto yy1389; - yy1393: + goto yy1402; + goto yy1383; + yy1387: yyaccept = 0; yych = *(marker = ++p); if (yych == 'I') - goto yy1403; + goto yy1397; if (yych == 'i') - goto yy1403; - goto yy1389; - yy1394: + goto yy1397; + goto yy1383; + yy1388: yych = *++p; - goto yy1389; - yy1395: + goto yy1383; + yy1389: yych = *++p; if (yych <= 0x7F) - goto yy1396; + goto yy1390; if (yych <= 0xBF) - goto yy1394; - yy1396: + goto yy1388; + yy1390: p = marker; if (yyaccept == 0) { - goto yy1389; + goto yy1383; } else { - goto yy1407; + goto yy1401; } - yy1397: + yy1391: yych = *++p; if (yych <= 0x9F) - goto yy1396; + goto yy1390; if (yych <= 0xBF) - goto yy1395; - goto yy1396; - yy1398: + goto yy1389; + goto yy1390; + yy1392: yych = *++p; if (yych <= 0x7F) - goto yy1396; + goto yy1390; if (yych <= 0xBF) - goto yy1395; - goto yy1396; - yy1399: + goto yy1389; + goto yy1390; + yy1393: yych = *++p; if (yych <= 0x8F) - goto yy1396; + goto yy1390; if (yych <= 0xBF) - goto yy1398; - goto yy1396; - yy1400: + goto yy1392; + goto yy1390; + yy1394: yych = *++p; if (yych <= 0x7F) - goto yy1396; + goto yy1390; if (yych <= 0xBF) - goto yy1398; - goto yy1396; - yy1401: + goto yy1392; + goto yy1390; + yy1395: yych = *++p; if (yych <= 0x7F) - goto yy1396; + goto yy1390; if (yych <= 0x8F) - goto yy1398; - goto yy1396; - yy1402: + goto yy1392; + goto yy1390; + yy1396: yych = *++p; if (yych <= 0x7F) - goto yy1396; + goto yy1390; if (yych <= 0x9F) - goto yy1395; - goto yy1396; - yy1403: + goto yy1389; + goto yy1390; + yy1397: yych = *++p; if (yych == 'L') - goto yy1404; + goto yy1398; if (yych != 'l') - goto yy1396; - yy1404: + goto yy1390; + yy1398: yych = *++p; if (yych == 'E') - goto yy1405; + goto yy1399; if (yych != 'e') - goto yy1396; - yy1405: + goto yy1390; + yy1399: yych = *++p; if (yych != ':') - goto yy1396; - yy1406: + goto yy1390; + yy1400: ++p; - yy1407 : { return (bufsize_t)(p - start); } - yy1408: + yy1401 : { return (bufsize_t)(p - start); } + yy1402: yych = *++p; if (yych == 'S') - goto yy1409; + goto yy1403; if (yych != 's') - goto yy1396; - yy1409: + goto yy1390; + yy1403: yych = *++p; if (yych == 'C') - goto yy1410; + goto yy1404; if (yych != 'c') - goto yy1396; - yy1410: + goto yy1390; + yy1404: yych = *++p; if (yych == 'R') - goto yy1411; + goto yy1405; if (yych != 'r') - goto yy1396; - yy1411: + goto yy1390; + yy1405: yych = *++p; if (yych == 'I') - goto yy1412; + goto yy1406; if (yych != 'i') - goto yy1396; - yy1412: + goto yy1390; + yy1406: yych = *++p; if (yych == 'P') - goto yy1413; + goto yy1407; if (yych != 'p') - goto yy1396; - yy1413: + goto yy1390; + yy1407: yych = *++p; if (yych == 'T') - goto yy1414; + goto yy1408; if (yych != 't') - goto yy1396; - yy1414: + goto yy1390; + yy1408: yych = *++p; if (yych == ':') - goto yy1406; - goto yy1396; - yy1415: + goto yy1400; + goto yy1390; + yy1409: yych = *++p; if (yych == 'V') - goto yy1416; + goto yy1410; if (yych != 'v') - goto yy1396; - yy1416: + goto yy1390; + yy1410: yych = *++p; if (yych == 'A') - goto yy1417; + goto yy1411; if (yych != 'a') - goto yy1396; - yy1417: + goto yy1390; + yy1411: yych = *++p; if (yych == 'S') - goto yy1418; + goto yy1412; if (yych != 's') - goto yy1396; - yy1418: + goto yy1390; + yy1412: yych = *++p; if (yych == 'C') - goto yy1419; + goto yy1413; if (yych != 'c') - goto yy1396; - yy1419: + goto yy1390; + yy1413: yych = *++p; if (yych == 'R') - goto yy1420; + goto yy1414; if (yych != 'r') - goto yy1396; - yy1420: + goto yy1390; + yy1414: yych = *++p; if (yych == 'I') - goto yy1421; + goto yy1415; if (yych != 'i') - goto yy1396; - yy1421: + goto yy1390; + yy1415: yych = *++p; if (yych == 'P') - goto yy1422; + goto yy1416; if (yych != 'p') - goto yy1396; - yy1422: + goto yy1390; + yy1416: yych = *++p; if (yych == 'T') - goto yy1423; + goto yy1417; if (yych != 't') - goto yy1396; - yy1423: + goto yy1390; + yy1417: yych = *++p; if (yych == ':') - goto yy1406; - goto yy1396; - yy1424: + goto yy1400; + goto yy1390; + yy1418: yych = *++p; if (yych == 'T') - goto yy1425; + goto yy1419; if (yych != 't') - goto yy1396; - yy1425: + goto yy1390; + yy1419: yych = *++p; if (yych == 'A') - goto yy1426; + goto yy1420; if (yych != 'a') - goto yy1396; - yy1426: + goto yy1390; + yy1420: yych = *++p; if (yych != ':') - goto yy1396; + goto yy1390; yyaccept = 1; yych = *(marker = ++p); if (yych == 'I') - goto yy1428; + goto yy1422; if (yych != 'i') - goto yy1407; - yy1428: + goto yy1401; + yy1422: yych = *++p; if (yych == 'M') - goto yy1429; + goto yy1423; if (yych != 'm') - goto yy1396; - yy1429: + goto yy1390; + yy1423: yych = *++p; if (yych == 'A') - goto yy1430; + goto yy1424; if (yych != 'a') - goto yy1396; - yy1430: + goto yy1390; + yy1424: yych = *++p; if (yych == 'G') - goto yy1431; + goto yy1425; if (yych != 'g') - goto yy1396; - yy1431: + goto yy1390; + yy1425: yych = *++p; if (yych == 'E') - goto yy1432; + goto yy1426; if (yych != 'e') - goto yy1396; - yy1432: + goto yy1390; + yy1426: yych = *++p; if (yych != '/') - goto yy1396; + goto yy1390; yych = *++p; if (yych <= 'W') { if (yych <= 'J') { if (yych == 'G') - goto yy1435; + goto yy1429; if (yych <= 'I') - goto yy1396; - goto yy1436; + goto yy1390; + goto yy1430; } else { if (yych == 'P') - goto yy1434; + goto yy1428; if (yych <= 'V') - goto yy1396; - goto yy1437; + goto yy1390; + goto yy1431; } } else { if (yych <= 'j') { if (yych == 'g') - goto yy1435; + goto yy1429; if (yych <= 'i') - goto yy1396; - goto yy1436; + goto yy1390; + goto yy1430; } else { if (yych <= 'p') { if (yych <= 'o') - goto yy1396; + goto yy1390; } else { if (yych == 'w') - goto yy1437; - goto yy1396; + goto yy1431; + goto yy1390; } } } - yy1434: + yy1428: yych = *++p; if (yych == 'N') - goto yy1445; + goto yy1439; if (yych == 'n') - goto yy1445; - goto yy1396; - yy1435: + goto yy1439; + goto yy1390; + yy1429: yych = *++p; if (yych == 'I') - goto yy1444; + goto yy1438; if (yych == 'i') - goto yy1444; - goto yy1396; - yy1436: + goto yy1438; + goto yy1390; + yy1430: yych = *++p; if (yych == 'P') - goto yy1442; + goto yy1436; if (yych == 'p') - goto yy1442; - goto yy1396; - yy1437: + goto yy1436; + goto yy1390; + yy1431: yych = *++p; if (yych == 'E') - goto yy1438; + goto yy1432; if (yych != 'e') - goto yy1396; - yy1438: + goto yy1390; + yy1432: yych = *++p; if (yych == 'B') - goto yy1439; + goto yy1433; if (yych != 'b') - goto yy1396; - yy1439: + goto yy1390; + yy1433: yych = *++p; if (yych == 'P') - goto yy1440; + goto yy1434; if (yych != 'p') - goto yy1396; - yy1440: + goto yy1390; + yy1434: ++p; { return 0; } - yy1442: + yy1436: yych = *++p; if (yych == 'E') - goto yy1443; + goto yy1437; if (yych != 'e') - goto yy1396; - yy1443: + goto yy1390; + yy1437: yych = *++p; if (yych == 'G') - goto yy1440; + goto yy1434; if (yych == 'g') - goto yy1440; - goto yy1396; - yy1444: + goto yy1434; + goto yy1390; + yy1438: yych = *++p; if (yych == 'F') - goto yy1440; + goto yy1434; if (yych == 'f') - goto yy1440; - goto yy1396; - yy1445: + goto yy1434; + goto yy1390; + yy1439: ++p; if ((yych = *p) == 'G') - goto yy1440; + goto yy1434; if (yych == 'g') - goto yy1440; - goto yy1396; + goto yy1434; + goto yy1390; } } diff --git a/scanners.re b/scanners.re index 8b1c91e..52bf5aa 100644 --- a/scanners.re +++ b/scanners.re @@ -252,7 +252,7 @@ bufsize_t _scan_atx_heading_start(const unsigned char *p) const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - [#]{1,6} ([ ]+|[\r\n]) { return (bufsize_t)(p - start); } + [#]{1,6} ([ \t]+|[\r\n]) { return (bufsize_t)(p - start); } .? { return 0; } */ } @@ -277,9 +277,9 @@ bufsize_t _scan_thematic_break(const unsigned char *p) const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - ([*][ ]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } - ([_][ ]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } - ([-][ ]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } + ([*][ \t]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } + ([_][ \t]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } + ([-][ \t]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } .? { return 0; } */ } diff --git a/xml.c b/xml.c index 12bd629..4898cd2 100644 --- a/xml.c +++ b/xml.c @@ -149,7 +149,7 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type, char *cmark_render_xml(cmark_node *root, int options) { char *result; - cmark_strbuf xml = GH_BUF_INIT; + cmark_strbuf xml = CMARK_BUF_INIT(cmark_node_mem(root)); cmark_event_type ev_type; cmark_node *cur; struct render_state state = {&xml, 0}; From 599e57a489df3b186ebda7520ce42803b0c459bc Mon Sep 17 00:00:00 2001 From: Adrian Nowicki Date: Sun, 20 Aug 2017 22:06:28 +0200 Subject: [PATCH 24/26] updated to cmark 0.28.0 Signed-off-by: Adrian Nowicki --- blocks.c | 41 +- buffer.c | 6 +- case_fold_switch.inc | 1972 +++- chunk.h | 10 +- cmark.c | 8 +- cmark.h | 25 +- commonmark.c | 11 +- commonmark_test.go | 2 +- entities.inc | 2 +- houdini_html_u.c | 2 +- inlines.c | 257 +- latex.c | 39 +- node.c | 2 +- references.c | 6 +- scanners.c | 20534 +++++++++++++++++------------------------ scanners.h | 2 - scanners.re | 80 +- 17 files changed, 10759 insertions(+), 12240 deletions(-) diff --git a/blocks.c b/blocks.c index 8e8c4c2..5a293b2 100644 --- a/blocks.c +++ b/blocks.c @@ -414,8 +414,8 @@ static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input, 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->start = 0; + data->delimiter = CMARK_NO_DELIM; data->tight = false; } else if (cmark_isdigit(c)) { int start = 0; @@ -563,21 +563,27 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, cmark_strbuf_put(&parser->linebuf, buffer, chunk_len); // add replacement character cmark_strbuf_put(&parser->linebuf, repl, 3); - chunk_len += 1; // so we advance the buffer past NULL } else { cmark_strbuf_put(&parser->linebuf, buffer, chunk_len); } } buffer += chunk_len; - // skip over line ending characters: - if (buffer < end && *buffer == '\r') { - buffer++; - if (buffer == end) - parser->last_buffer_ended_with_cr = true; + if (buffer < end) { + if (*buffer == '\0') { + // skip over NULL + buffer++; + } else { + // skip over line ending characters + if (*buffer == '\r') { + buffer++; + if (buffer == end) + parser->last_buffer_ended_with_cr = true; + } + if (buffer < end && *buffer == '\n') + buffer++; + } } - if (buffer < end && *buffer == '\n') - buffer++; } } @@ -933,10 +939,10 @@ static void open_new_blocks(cmark_parser *parser, cmark_node **container, *container = add_child(parser, *container, CMARK_NODE_THEMATIC_BREAK, parser->first_nonspace + 1); S_advance_offset(parser, input, input->len - 1 - parser->offset, false); - } else if ((matched = parse_list_marker( + } else if ((!indented || cont_type == CMARK_NODE_LIST) && + (matched = parse_list_marker( parser->mem, input, parser->first_nonspace, - (*container)->type == CMARK_NODE_PARAGRAPH, &data)) && - (!indented || cont_type == CMARK_NODE_LIST)) { + (*container)->type == CMARK_NODE_PARAGRAPH, &data))) { // Note that we can have new list items starting with >= 4 // spaces indent, as long as the list container is still open. @@ -989,7 +995,7 @@ static void open_new_blocks(cmark_parser *parser, cmark_node **container, parser->first_nonspace + 1); /* TODO: static */ memcpy(&((*container)->as.list), data, sizeof(*data)); - free(data); + parser->mem->free(data); } else if (indented && !maybe_lazy && !parser->blank) { S_advance_offset(parser, input, CODE_INDENT, true); *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK, @@ -1140,6 +1146,8 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, else cmark_strbuf_put(&parser->curline, buffer, bytes); + bytes = parser->curline.size; + // ensure line ends with a newline: if (bytes == 0 || !S_is_line_end_char(parser->curline.ptr[bytes - 1])) cmark_strbuf_putc(&parser->curline, '\n'); @@ -1151,6 +1159,7 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer, input.data = parser->curline.ptr; input.len = parser->curline.size; + input.alloc = 0; parser->line_number++; @@ -1185,9 +1194,7 @@ cmark_node *cmark_parser_finish(cmark_parser *parser) { finalize_document(parser); - if (parser->options & CMARK_OPT_NORMALIZE) { - cmark_consolidate_text_nodes(parser->root); - } + cmark_consolidate_text_nodes(parser->root); cmark_strbuf_free(&parser->curline); diff --git a/buffer.c b/buffer.c index a6754b6..a237b11 100644 --- a/buffer.c +++ b/buffer.c @@ -42,8 +42,12 @@ void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) { if (target_size < buf->asize) return; - if (target_size > (bufsize_t)(INT32_MAX / 2)) + if (target_size > (bufsize_t)(INT32_MAX / 2)) { + fprintf(stderr, + "[cmark] cmark_strbuf_grow requests buffer with size > %d, aborting\n", + (INT32_MAX / 2)); abort(); + } /* Oversize the buffer by 50% to guarantee amortized linear time * complexity on append operations. */ diff --git a/case_fold_switch.inc b/case_fold_switch.inc index 70fdd75..28e223e 100644 --- a/case_fold_switch.inc +++ b/case_fold_switch.inc @@ -657,9 +657,60 @@ case 0x0232: bufpush(0x0233); break; + case 0x023A: + bufpush(0x2C65); + break; + case 0x023B: + bufpush(0x023C); + break; + case 0x023D: + bufpush(0x019A); + break; + case 0x023E: + bufpush(0x2C66); + break; + case 0x0241: + bufpush(0x0242); + break; + case 0x0243: + bufpush(0x0180); + break; + case 0x0244: + bufpush(0x0289); + break; + case 0x0245: + bufpush(0x028C); + break; + case 0x0246: + bufpush(0x0247); + break; + case 0x0248: + bufpush(0x0249); + break; + case 0x024A: + bufpush(0x024B); + break; + case 0x024C: + bufpush(0x024D); + break; + case 0x024E: + bufpush(0x024F); + break; case 0x0345: bufpush(0x03B9); break; + case 0x0370: + bufpush(0x0371); + break; + case 0x0372: + bufpush(0x0373); + break; + case 0x0376: + bufpush(0x0377); + break; + case 0x037F: + bufpush(0x03F3); + break; case 0x0386: bufpush(0x03AC); break; @@ -772,6 +823,9 @@ case 0x03C2: bufpush(0x03C3); break; + case 0x03CF: + bufpush(0x03D7); + break; case 0x03D0: bufpush(0x03B2); break; @@ -826,15 +880,30 @@ case 0x03F1: bufpush(0x03C1); break; - case 0x03F2: - bufpush(0x03C3); - break; case 0x03F4: bufpush(0x03B8); break; case 0x03F5: bufpush(0x03B5); break; + case 0x03F7: + bufpush(0x03F8); + break; + case 0x03F9: + bufpush(0x03F2); + break; + case 0x03FA: + bufpush(0x03FB); + break; + case 0x03FD: + bufpush(0x037B); + break; + case 0x03FE: + bufpush(0x037C); + break; + case 0x03FF: + bufpush(0x037D); + break; case 0x0400: bufpush(0x0450); break; @@ -1111,6 +1180,9 @@ case 0x04BE: bufpush(0x04BF); break; + case 0x04C0: + bufpush(0x04CF); + break; case 0x04C1: bufpush(0x04C2); break; @@ -1189,9 +1261,21 @@ case 0x04F4: bufpush(0x04F5); break; + case 0x04F6: + bufpush(0x04F7); + break; case 0x04F8: bufpush(0x04F9); break; + case 0x04FA: + bufpush(0x04FB); + break; + case 0x04FC: + bufpush(0x04FD); + break; + case 0x04FE: + bufpush(0x04FF); + break; case 0x0500: bufpush(0x0501); break; @@ -1216,6 +1300,54 @@ case 0x050E: bufpush(0x050F); break; + case 0x0510: + bufpush(0x0511); + break; + case 0x0512: + bufpush(0x0513); + break; + case 0x0514: + bufpush(0x0515); + break; + case 0x0516: + bufpush(0x0517); + break; + case 0x0518: + bufpush(0x0519); + break; + case 0x051A: + bufpush(0x051B); + break; + case 0x051C: + bufpush(0x051D); + break; + case 0x051E: + bufpush(0x051F); + break; + case 0x0520: + bufpush(0x0521); + break; + case 0x0522: + bufpush(0x0523); + break; + case 0x0524: + bufpush(0x0525); + break; + case 0x0526: + bufpush(0x0527); + break; + case 0x0528: + bufpush(0x0529); + break; + case 0x052A: + bufpush(0x052B); + break; + case 0x052C: + bufpush(0x052D); + break; + case 0x052E: + bufpush(0x052F); + break; case 0x0531: bufpush(0x0561); break; @@ -1334,6 +1466,171 @@ bufpush(0x0565); bufpush(0x0582); break; + case 0x10A0: + bufpush(0x2D00); + break; + case 0x10A1: + bufpush(0x2D01); + break; + case 0x10A2: + bufpush(0x2D02); + break; + case 0x10A3: + bufpush(0x2D03); + break; + case 0x10A4: + bufpush(0x2D04); + break; + case 0x10A5: + bufpush(0x2D05); + break; + case 0x10A6: + bufpush(0x2D06); + break; + case 0x10A7: + bufpush(0x2D07); + break; + case 0x10A8: + bufpush(0x2D08); + break; + case 0x10A9: + bufpush(0x2D09); + break; + case 0x10AA: + bufpush(0x2D0A); + break; + case 0x10AB: + bufpush(0x2D0B); + break; + case 0x10AC: + bufpush(0x2D0C); + break; + case 0x10AD: + bufpush(0x2D0D); + break; + case 0x10AE: + bufpush(0x2D0E); + break; + case 0x10AF: + bufpush(0x2D0F); + break; + case 0x10B0: + bufpush(0x2D10); + break; + case 0x10B1: + bufpush(0x2D11); + break; + case 0x10B2: + bufpush(0x2D12); + break; + case 0x10B3: + bufpush(0x2D13); + break; + case 0x10B4: + bufpush(0x2D14); + break; + case 0x10B5: + bufpush(0x2D15); + break; + case 0x10B6: + bufpush(0x2D16); + break; + case 0x10B7: + bufpush(0x2D17); + break; + case 0x10B8: + bufpush(0x2D18); + break; + case 0x10B9: + bufpush(0x2D19); + break; + case 0x10BA: + bufpush(0x2D1A); + break; + case 0x10BB: + bufpush(0x2D1B); + break; + case 0x10BC: + bufpush(0x2D1C); + break; + case 0x10BD: + bufpush(0x2D1D); + break; + case 0x10BE: + bufpush(0x2D1E); + break; + case 0x10BF: + bufpush(0x2D1F); + break; + case 0x10C0: + bufpush(0x2D20); + break; + case 0x10C1: + bufpush(0x2D21); + break; + case 0x10C2: + bufpush(0x2D22); + break; + case 0x10C3: + bufpush(0x2D23); + break; + case 0x10C4: + bufpush(0x2D24); + break; + case 0x10C5: + bufpush(0x2D25); + break; + case 0x10C7: + bufpush(0x2D27); + break; + case 0x10CD: + bufpush(0x2D2D); + break; + case 0x13F8: + bufpush(0x13F0); + break; + case 0x13F9: + bufpush(0x13F1); + break; + case 0x13FA: + bufpush(0x13F2); + break; + case 0x13FB: + bufpush(0x13F3); + break; + case 0x13FC: + bufpush(0x13F4); + break; + case 0x13FD: + bufpush(0x13F5); + break; + case 0x1C80: + bufpush(0x0432); + break; + case 0x1C81: + bufpush(0x0434); + break; + case 0x1C82: + bufpush(0x043E); + break; + case 0x1C83: + bufpush(0x0441); + break; + case 0x1C84: + bufpush(0x0442); + break; + case 0x1C85: + bufpush(0x0442); + break; + case 0x1C86: + bufpush(0x044A); + break; + case 0x1C87: + bufpush(0x0463); + break; + case 0x1C88: + bufpush(0xA64B); + break; case 0x1E00: bufpush(0x1E01); break; @@ -1582,6 +1879,10 @@ case 0x1E9B: bufpush(0x1E61); break; + case 0x1E9E: + bufpush(0x0073); + bufpush(0x0073); + break; case 0x1EA0: bufpush(0x1EA1); break; @@ -1717,6 +2018,15 @@ case 0x1EF8: bufpush(0x1EF9); break; + case 0x1EFA: + bufpush(0x1EFB); + break; + case 0x1EFC: + bufpush(0x1EFD); + break; + case 0x1EFE: + bufpush(0x1EFF); + break; case 0x1F08: bufpush(0x1F00); break; @@ -2264,6 +2574,9 @@ case 0x212B: bufpush(0x00E5); break; + case 0x2132: + bufpush(0x214E); + break; case 0x2160: bufpush(0x2170); break; @@ -2312,6 +2625,9 @@ case 0x216F: bufpush(0x217F); break; + case 0x2183: + bufpush(0x2184); + break; case 0x24B6: bufpush(0x24D0); break; @@ -2390,205 +2706,1114 @@ case 0x24CF: bufpush(0x24E9); break; - case 0xFB00: - bufpush(0x0066); - bufpush(0x0066); + case 0x2C00: + bufpush(0x2C30); break; - case 0xFB01: - bufpush(0x0066); - bufpush(0x0069); + case 0x2C01: + bufpush(0x2C31); break; - case 0xFB02: - bufpush(0x0066); - bufpush(0x006C); + case 0x2C02: + bufpush(0x2C32); break; - case 0xFB03: - bufpush(0x0066); - bufpush(0x0066); - bufpush(0x0069); + case 0x2C03: + bufpush(0x2C33); break; - case 0xFB04: - bufpush(0x0066); - bufpush(0x0066); - bufpush(0x006C); + case 0x2C04: + bufpush(0x2C34); break; - case 0xFB05: - bufpush(0x0073); - bufpush(0x0074); + case 0x2C05: + bufpush(0x2C35); break; - case 0xFB06: - bufpush(0x0073); - bufpush(0x0074); + case 0x2C06: + bufpush(0x2C36); break; - case 0xFB13: - bufpush(0x0574); - bufpush(0x0576); + case 0x2C07: + bufpush(0x2C37); break; - case 0xFB14: - bufpush(0x0574); - bufpush(0x0565); + case 0x2C08: + bufpush(0x2C38); break; - case 0xFB15: - bufpush(0x0574); - bufpush(0x056B); + case 0x2C09: + bufpush(0x2C39); break; - case 0xFB16: - bufpush(0x057E); - bufpush(0x0576); + case 0x2C0A: + bufpush(0x2C3A); break; - case 0xFB17: - bufpush(0x0574); - bufpush(0x056D); + case 0x2C0B: + bufpush(0x2C3B); break; - case 0xFF21: - bufpush(0xFF41); + case 0x2C0C: + bufpush(0x2C3C); break; - case 0xFF22: - bufpush(0xFF42); + case 0x2C0D: + bufpush(0x2C3D); break; - case 0xFF23: - bufpush(0xFF43); + case 0x2C0E: + bufpush(0x2C3E); break; - case 0xFF24: - bufpush(0xFF44); + case 0x2C0F: + bufpush(0x2C3F); break; - case 0xFF25: - bufpush(0xFF45); + case 0x2C10: + bufpush(0x2C40); break; - case 0xFF26: - bufpush(0xFF46); + case 0x2C11: + bufpush(0x2C41); break; - case 0xFF27: - bufpush(0xFF47); + case 0x2C12: + bufpush(0x2C42); break; - case 0xFF28: - bufpush(0xFF48); + case 0x2C13: + bufpush(0x2C43); break; - case 0xFF29: - bufpush(0xFF49); + case 0x2C14: + bufpush(0x2C44); break; - case 0xFF2A: - bufpush(0xFF4A); + case 0x2C15: + bufpush(0x2C45); break; - case 0xFF2B: - bufpush(0xFF4B); + case 0x2C16: + bufpush(0x2C46); break; - case 0xFF2C: - bufpush(0xFF4C); + case 0x2C17: + bufpush(0x2C47); break; - case 0xFF2D: - bufpush(0xFF4D); + case 0x2C18: + bufpush(0x2C48); break; - case 0xFF2E: - bufpush(0xFF4E); + case 0x2C19: + bufpush(0x2C49); break; - case 0xFF2F: - bufpush(0xFF4F); + case 0x2C1A: + bufpush(0x2C4A); break; - case 0xFF30: - bufpush(0xFF50); + case 0x2C1B: + bufpush(0x2C4B); break; - case 0xFF31: - bufpush(0xFF51); + case 0x2C1C: + bufpush(0x2C4C); break; - case 0xFF32: - bufpush(0xFF52); + case 0x2C1D: + bufpush(0x2C4D); break; - case 0xFF33: - bufpush(0xFF53); + case 0x2C1E: + bufpush(0x2C4E); break; - case 0xFF34: - bufpush(0xFF54); + case 0x2C1F: + bufpush(0x2C4F); break; - case 0xFF35: - bufpush(0xFF55); + case 0x2C20: + bufpush(0x2C50); break; - case 0xFF36: - bufpush(0xFF56); + case 0x2C21: + bufpush(0x2C51); break; - case 0xFF37: - bufpush(0xFF57); + case 0x2C22: + bufpush(0x2C52); break; - case 0xFF38: - bufpush(0xFF58); + case 0x2C23: + bufpush(0x2C53); break; - case 0xFF39: - bufpush(0xFF59); + case 0x2C24: + bufpush(0x2C54); break; - case 0xFF3A: - bufpush(0xFF5A); + case 0x2C25: + bufpush(0x2C55); break; - case 0x10400: - bufpush(0x10428); + case 0x2C26: + bufpush(0x2C56); break; - case 0x10401: - bufpush(0x10429); + case 0x2C27: + bufpush(0x2C57); break; - case 0x10402: - bufpush(0x1042A); + case 0x2C28: + bufpush(0x2C58); break; - case 0x10403: - bufpush(0x1042B); + case 0x2C29: + bufpush(0x2C59); break; - case 0x10404: - bufpush(0x1042C); + case 0x2C2A: + bufpush(0x2C5A); break; - case 0x10405: - bufpush(0x1042D); + case 0x2C2B: + bufpush(0x2C5B); break; - case 0x10406: - bufpush(0x1042E); + case 0x2C2C: + bufpush(0x2C5C); break; - case 0x10407: - bufpush(0x1042F); + case 0x2C2D: + bufpush(0x2C5D); break; - case 0x10408: - bufpush(0x10430); + case 0x2C2E: + bufpush(0x2C5E); break; - case 0x10409: - bufpush(0x10431); + case 0x2C60: + bufpush(0x2C61); break; - case 0x1040A: - bufpush(0x10432); + case 0x2C62: + bufpush(0x026B); break; - case 0x1040B: - bufpush(0x10433); + case 0x2C63: + bufpush(0x1D7D); break; - case 0x1040C: - bufpush(0x10434); + case 0x2C64: + bufpush(0x027D); break; - case 0x1040D: - bufpush(0x10435); + case 0x2C67: + bufpush(0x2C68); break; - case 0x1040E: - bufpush(0x10436); + case 0x2C69: + bufpush(0x2C6A); break; - case 0x1040F: - bufpush(0x10437); + case 0x2C6B: + bufpush(0x2C6C); break; - case 0x10410: - bufpush(0x10438); + case 0x2C6D: + bufpush(0x0251); break; - case 0x10411: - bufpush(0x10439); + case 0x2C6E: + bufpush(0x0271); break; - case 0x10412: - bufpush(0x1043A); + case 0x2C6F: + bufpush(0x0250); break; - case 0x10413: - bufpush(0x1043B); + case 0x2C70: + bufpush(0x0252); break; - case 0x10414: - bufpush(0x1043C); + case 0x2C72: + bufpush(0x2C73); break; - case 0x10415: - bufpush(0x1043D); + case 0x2C75: + bufpush(0x2C76); break; - case 0x10416: - bufpush(0x1043E); + case 0x2C7E: + bufpush(0x023F); break; - case 0x10417: - bufpush(0x1043F); + case 0x2C7F: + bufpush(0x0240); + break; + case 0x2C80: + bufpush(0x2C81); + break; + case 0x2C82: + bufpush(0x2C83); + break; + case 0x2C84: + bufpush(0x2C85); + break; + case 0x2C86: + bufpush(0x2C87); + break; + case 0x2C88: + bufpush(0x2C89); + break; + case 0x2C8A: + bufpush(0x2C8B); + break; + case 0x2C8C: + bufpush(0x2C8D); + break; + case 0x2C8E: + bufpush(0x2C8F); + break; + case 0x2C90: + bufpush(0x2C91); + break; + case 0x2C92: + bufpush(0x2C93); + break; + case 0x2C94: + bufpush(0x2C95); + break; + case 0x2C96: + bufpush(0x2C97); + break; + case 0x2C98: + bufpush(0x2C99); + break; + case 0x2C9A: + bufpush(0x2C9B); + break; + case 0x2C9C: + bufpush(0x2C9D); + break; + case 0x2C9E: + bufpush(0x2C9F); + break; + case 0x2CA0: + bufpush(0x2CA1); + break; + case 0x2CA2: + bufpush(0x2CA3); + break; + case 0x2CA4: + bufpush(0x2CA5); + break; + case 0x2CA6: + bufpush(0x2CA7); + break; + case 0x2CA8: + bufpush(0x2CA9); + break; + case 0x2CAA: + bufpush(0x2CAB); + break; + case 0x2CAC: + bufpush(0x2CAD); + break; + case 0x2CAE: + bufpush(0x2CAF); + break; + case 0x2CB0: + bufpush(0x2CB1); + break; + case 0x2CB2: + bufpush(0x2CB3); + break; + case 0x2CB4: + bufpush(0x2CB5); + break; + case 0x2CB6: + bufpush(0x2CB7); + break; + case 0x2CB8: + bufpush(0x2CB9); + break; + case 0x2CBA: + bufpush(0x2CBB); + break; + case 0x2CBC: + bufpush(0x2CBD); + break; + case 0x2CBE: + bufpush(0x2CBF); + break; + case 0x2CC0: + bufpush(0x2CC1); + break; + case 0x2CC2: + bufpush(0x2CC3); + break; + case 0x2CC4: + bufpush(0x2CC5); + break; + case 0x2CC6: + bufpush(0x2CC7); + break; + case 0x2CC8: + bufpush(0x2CC9); + break; + case 0x2CCA: + bufpush(0x2CCB); + break; + case 0x2CCC: + bufpush(0x2CCD); + break; + case 0x2CCE: + bufpush(0x2CCF); + break; + case 0x2CD0: + bufpush(0x2CD1); + break; + case 0x2CD2: + bufpush(0x2CD3); + break; + case 0x2CD4: + bufpush(0x2CD5); + break; + case 0x2CD6: + bufpush(0x2CD7); + break; + case 0x2CD8: + bufpush(0x2CD9); + break; + case 0x2CDA: + bufpush(0x2CDB); + break; + case 0x2CDC: + bufpush(0x2CDD); + break; + case 0x2CDE: + bufpush(0x2CDF); + break; + case 0x2CE0: + bufpush(0x2CE1); + break; + case 0x2CE2: + bufpush(0x2CE3); + break; + case 0x2CEB: + bufpush(0x2CEC); + break; + case 0x2CED: + bufpush(0x2CEE); + break; + case 0x2CF2: + bufpush(0x2CF3); + break; + case 0xA640: + bufpush(0xA641); + break; + case 0xA642: + bufpush(0xA643); + break; + case 0xA644: + bufpush(0xA645); + break; + case 0xA646: + bufpush(0xA647); + break; + case 0xA648: + bufpush(0xA649); + break; + case 0xA64A: + bufpush(0xA64B); + break; + case 0xA64C: + bufpush(0xA64D); + break; + case 0xA64E: + bufpush(0xA64F); + break; + case 0xA650: + bufpush(0xA651); + break; + case 0xA652: + bufpush(0xA653); + break; + case 0xA654: + bufpush(0xA655); + break; + case 0xA656: + bufpush(0xA657); + break; + case 0xA658: + bufpush(0xA659); + break; + case 0xA65A: + bufpush(0xA65B); + break; + case 0xA65C: + bufpush(0xA65D); + break; + case 0xA65E: + bufpush(0xA65F); + break; + case 0xA660: + bufpush(0xA661); + break; + case 0xA662: + bufpush(0xA663); + break; + case 0xA664: + bufpush(0xA665); + break; + case 0xA666: + bufpush(0xA667); + break; + case 0xA668: + bufpush(0xA669); + break; + case 0xA66A: + bufpush(0xA66B); + break; + case 0xA66C: + bufpush(0xA66D); + break; + case 0xA680: + bufpush(0xA681); + break; + case 0xA682: + bufpush(0xA683); + break; + case 0xA684: + bufpush(0xA685); + break; + case 0xA686: + bufpush(0xA687); + break; + case 0xA688: + bufpush(0xA689); + break; + case 0xA68A: + bufpush(0xA68B); + break; + case 0xA68C: + bufpush(0xA68D); + break; + case 0xA68E: + bufpush(0xA68F); + break; + case 0xA690: + bufpush(0xA691); + break; + case 0xA692: + bufpush(0xA693); + break; + case 0xA694: + bufpush(0xA695); + break; + case 0xA696: + bufpush(0xA697); + break; + case 0xA698: + bufpush(0xA699); + break; + case 0xA69A: + bufpush(0xA69B); + break; + case 0xA722: + bufpush(0xA723); + break; + case 0xA724: + bufpush(0xA725); + break; + case 0xA726: + bufpush(0xA727); + break; + case 0xA728: + bufpush(0xA729); + break; + case 0xA72A: + bufpush(0xA72B); + break; + case 0xA72C: + bufpush(0xA72D); + break; + case 0xA72E: + bufpush(0xA72F); + break; + case 0xA732: + bufpush(0xA733); + break; + case 0xA734: + bufpush(0xA735); + break; + case 0xA736: + bufpush(0xA737); + break; + case 0xA738: + bufpush(0xA739); + break; + case 0xA73A: + bufpush(0xA73B); + break; + case 0xA73C: + bufpush(0xA73D); + break; + case 0xA73E: + bufpush(0xA73F); + break; + case 0xA740: + bufpush(0xA741); + break; + case 0xA742: + bufpush(0xA743); + break; + case 0xA744: + bufpush(0xA745); + break; + case 0xA746: + bufpush(0xA747); + break; + case 0xA748: + bufpush(0xA749); + break; + case 0xA74A: + bufpush(0xA74B); + break; + case 0xA74C: + bufpush(0xA74D); + break; + case 0xA74E: + bufpush(0xA74F); + break; + case 0xA750: + bufpush(0xA751); + break; + case 0xA752: + bufpush(0xA753); + break; + case 0xA754: + bufpush(0xA755); + break; + case 0xA756: + bufpush(0xA757); + break; + case 0xA758: + bufpush(0xA759); + break; + case 0xA75A: + bufpush(0xA75B); + break; + case 0xA75C: + bufpush(0xA75D); + break; + case 0xA75E: + bufpush(0xA75F); + break; + case 0xA760: + bufpush(0xA761); + break; + case 0xA762: + bufpush(0xA763); + break; + case 0xA764: + bufpush(0xA765); + break; + case 0xA766: + bufpush(0xA767); + break; + case 0xA768: + bufpush(0xA769); + break; + case 0xA76A: + bufpush(0xA76B); + break; + case 0xA76C: + bufpush(0xA76D); + break; + case 0xA76E: + bufpush(0xA76F); + break; + case 0xA779: + bufpush(0xA77A); + break; + case 0xA77B: + bufpush(0xA77C); + break; + case 0xA77D: + bufpush(0x1D79); + break; + case 0xA77E: + bufpush(0xA77F); + break; + case 0xA780: + bufpush(0xA781); + break; + case 0xA782: + bufpush(0xA783); + break; + case 0xA784: + bufpush(0xA785); + break; + case 0xA786: + bufpush(0xA787); + break; + case 0xA78B: + bufpush(0xA78C); + break; + case 0xA78D: + bufpush(0x0265); + break; + case 0xA790: + bufpush(0xA791); + break; + case 0xA792: + bufpush(0xA793); + break; + case 0xA796: + bufpush(0xA797); + break; + case 0xA798: + bufpush(0xA799); + break; + case 0xA79A: + bufpush(0xA79B); + break; + case 0xA79C: + bufpush(0xA79D); + break; + case 0xA79E: + bufpush(0xA79F); + break; + case 0xA7A0: + bufpush(0xA7A1); + break; + case 0xA7A2: + bufpush(0xA7A3); + break; + case 0xA7A4: + bufpush(0xA7A5); + break; + case 0xA7A6: + bufpush(0xA7A7); + break; + case 0xA7A8: + bufpush(0xA7A9); + break; + case 0xA7AA: + bufpush(0x0266); + break; + case 0xA7AB: + bufpush(0x025C); + break; + case 0xA7AC: + bufpush(0x0261); + break; + case 0xA7AD: + bufpush(0x026C); + break; + case 0xA7AE: + bufpush(0x026A); + break; + case 0xA7B0: + bufpush(0x029E); + break; + case 0xA7B1: + bufpush(0x0287); + break; + case 0xA7B2: + bufpush(0x029D); + break; + case 0xA7B3: + bufpush(0xAB53); + break; + case 0xA7B4: + bufpush(0xA7B5); + break; + case 0xA7B6: + bufpush(0xA7B7); + break; + case 0xAB70: + bufpush(0x13A0); + break; + case 0xAB71: + bufpush(0x13A1); + break; + case 0xAB72: + bufpush(0x13A2); + break; + case 0xAB73: + bufpush(0x13A3); + break; + case 0xAB74: + bufpush(0x13A4); + break; + case 0xAB75: + bufpush(0x13A5); + break; + case 0xAB76: + bufpush(0x13A6); + break; + case 0xAB77: + bufpush(0x13A7); + break; + case 0xAB78: + bufpush(0x13A8); + break; + case 0xAB79: + bufpush(0x13A9); + break; + case 0xAB7A: + bufpush(0x13AA); + break; + case 0xAB7B: + bufpush(0x13AB); + break; + case 0xAB7C: + bufpush(0x13AC); + break; + case 0xAB7D: + bufpush(0x13AD); + break; + case 0xAB7E: + bufpush(0x13AE); + break; + case 0xAB7F: + bufpush(0x13AF); + break; + case 0xAB80: + bufpush(0x13B0); + break; + case 0xAB81: + bufpush(0x13B1); + break; + case 0xAB82: + bufpush(0x13B2); + break; + case 0xAB83: + bufpush(0x13B3); + break; + case 0xAB84: + bufpush(0x13B4); + break; + case 0xAB85: + bufpush(0x13B5); + break; + case 0xAB86: + bufpush(0x13B6); + break; + case 0xAB87: + bufpush(0x13B7); + break; + case 0xAB88: + bufpush(0x13B8); + break; + case 0xAB89: + bufpush(0x13B9); + break; + case 0xAB8A: + bufpush(0x13BA); + break; + case 0xAB8B: + bufpush(0x13BB); + break; + case 0xAB8C: + bufpush(0x13BC); + break; + case 0xAB8D: + bufpush(0x13BD); + break; + case 0xAB8E: + bufpush(0x13BE); + break; + case 0xAB8F: + bufpush(0x13BF); + break; + case 0xAB90: + bufpush(0x13C0); + break; + case 0xAB91: + bufpush(0x13C1); + break; + case 0xAB92: + bufpush(0x13C2); + break; + case 0xAB93: + bufpush(0x13C3); + break; + case 0xAB94: + bufpush(0x13C4); + break; + case 0xAB95: + bufpush(0x13C5); + break; + case 0xAB96: + bufpush(0x13C6); + break; + case 0xAB97: + bufpush(0x13C7); + break; + case 0xAB98: + bufpush(0x13C8); + break; + case 0xAB99: + bufpush(0x13C9); + break; + case 0xAB9A: + bufpush(0x13CA); + break; + case 0xAB9B: + bufpush(0x13CB); + break; + case 0xAB9C: + bufpush(0x13CC); + break; + case 0xAB9D: + bufpush(0x13CD); + break; + case 0xAB9E: + bufpush(0x13CE); + break; + case 0xAB9F: + bufpush(0x13CF); + break; + case 0xABA0: + bufpush(0x13D0); + break; + case 0xABA1: + bufpush(0x13D1); + break; + case 0xABA2: + bufpush(0x13D2); + break; + case 0xABA3: + bufpush(0x13D3); + break; + case 0xABA4: + bufpush(0x13D4); + break; + case 0xABA5: + bufpush(0x13D5); + break; + case 0xABA6: + bufpush(0x13D6); + break; + case 0xABA7: + bufpush(0x13D7); + break; + case 0xABA8: + bufpush(0x13D8); + break; + case 0xABA9: + bufpush(0x13D9); + break; + case 0xABAA: + bufpush(0x13DA); + break; + case 0xABAB: + bufpush(0x13DB); + break; + case 0xABAC: + bufpush(0x13DC); + break; + case 0xABAD: + bufpush(0x13DD); + break; + case 0xABAE: + bufpush(0x13DE); + break; + case 0xABAF: + bufpush(0x13DF); + break; + case 0xABB0: + bufpush(0x13E0); + break; + case 0xABB1: + bufpush(0x13E1); + break; + case 0xABB2: + bufpush(0x13E2); + break; + case 0xABB3: + bufpush(0x13E3); + break; + case 0xABB4: + bufpush(0x13E4); + break; + case 0xABB5: + bufpush(0x13E5); + break; + case 0xABB6: + bufpush(0x13E6); + break; + case 0xABB7: + bufpush(0x13E7); + break; + case 0xABB8: + bufpush(0x13E8); + break; + case 0xABB9: + bufpush(0x13E9); + break; + case 0xABBA: + bufpush(0x13EA); + break; + case 0xABBB: + bufpush(0x13EB); + break; + case 0xABBC: + bufpush(0x13EC); + break; + case 0xABBD: + bufpush(0x13ED); + break; + case 0xABBE: + bufpush(0x13EE); + break; + case 0xABBF: + bufpush(0x13EF); + 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); @@ -2632,6 +3857,471 @@ case 0x10425: bufpush(0x1044D); break; + case 0x10426: + bufpush(0x1044E); + break; + case 0x10427: + bufpush(0x1044F); + break; + case 0x104B0: + bufpush(0x104D8); + break; + case 0x104B1: + bufpush(0x104D9); + break; + case 0x104B2: + bufpush(0x104DA); + break; + case 0x104B3: + bufpush(0x104DB); + break; + case 0x104B4: + bufpush(0x104DC); + break; + case 0x104B5: + bufpush(0x104DD); + break; + case 0x104B6: + bufpush(0x104DE); + break; + case 0x104B7: + bufpush(0x104DF); + break; + case 0x104B8: + bufpush(0x104E0); + break; + case 0x104B9: + bufpush(0x104E1); + break; + case 0x104BA: + bufpush(0x104E2); + break; + case 0x104BB: + bufpush(0x104E3); + break; + case 0x104BC: + bufpush(0x104E4); + break; + case 0x104BD: + bufpush(0x104E5); + break; + case 0x104BE: + bufpush(0x104E6); + break; + case 0x104BF: + bufpush(0x104E7); + break; + case 0x104C0: + bufpush(0x104E8); + break; + case 0x104C1: + bufpush(0x104E9); + break; + case 0x104C2: + bufpush(0x104EA); + break; + case 0x104C3: + bufpush(0x104EB); + break; + case 0x104C4: + bufpush(0x104EC); + break; + case 0x104C5: + bufpush(0x104ED); + break; + case 0x104C6: + bufpush(0x104EE); + break; + case 0x104C7: + bufpush(0x104EF); + break; + case 0x104C8: + bufpush(0x104F0); + break; + case 0x104C9: + bufpush(0x104F1); + break; + case 0x104CA: + bufpush(0x104F2); + break; + case 0x104CB: + bufpush(0x104F3); + break; + case 0x104CC: + bufpush(0x104F4); + break; + case 0x104CD: + bufpush(0x104F5); + break; + case 0x104CE: + bufpush(0x104F6); + break; + case 0x104CF: + bufpush(0x104F7); + break; + case 0x104D0: + bufpush(0x104F8); + break; + case 0x104D1: + bufpush(0x104F9); + break; + case 0x104D2: + bufpush(0x104FA); + break; + case 0x104D3: + bufpush(0x104FB); + break; + case 0x10C80: + bufpush(0x10CC0); + break; + case 0x10C81: + bufpush(0x10CC1); + break; + case 0x10C82: + bufpush(0x10CC2); + break; + case 0x10C83: + bufpush(0x10CC3); + break; + case 0x10C84: + bufpush(0x10CC4); + break; + case 0x10C85: + bufpush(0x10CC5); + break; + case 0x10C86: + bufpush(0x10CC6); + break; + case 0x10C87: + bufpush(0x10CC7); + break; + case 0x10C88: + bufpush(0x10CC8); + break; + case 0x10C89: + bufpush(0x10CC9); + break; + case 0x10C8A: + bufpush(0x10CCA); + break; + case 0x10C8B: + bufpush(0x10CCB); + break; + case 0x10C8C: + bufpush(0x10CCC); + break; + case 0x10C8D: + bufpush(0x10CCD); + break; + case 0x10C8E: + bufpush(0x10CCE); + break; + case 0x10C8F: + bufpush(0x10CCF); + break; + case 0x10C90: + bufpush(0x10CD0); + break; + case 0x10C91: + bufpush(0x10CD1); + break; + case 0x10C92: + bufpush(0x10CD2); + break; + case 0x10C93: + bufpush(0x10CD3); + break; + case 0x10C94: + bufpush(0x10CD4); + break; + case 0x10C95: + bufpush(0x10CD5); + break; + case 0x10C96: + bufpush(0x10CD6); + break; + case 0x10C97: + bufpush(0x10CD7); + break; + case 0x10C98: + bufpush(0x10CD8); + break; + case 0x10C99: + bufpush(0x10CD9); + break; + case 0x10C9A: + bufpush(0x10CDA); + break; + case 0x10C9B: + bufpush(0x10CDB); + break; + case 0x10C9C: + bufpush(0x10CDC); + break; + case 0x10C9D: + bufpush(0x10CDD); + break; + case 0x10C9E: + bufpush(0x10CDE); + break; + case 0x10C9F: + bufpush(0x10CDF); + break; + case 0x10CA0: + bufpush(0x10CE0); + break; + case 0x10CA1: + bufpush(0x10CE1); + break; + case 0x10CA2: + bufpush(0x10CE2); + break; + case 0x10CA3: + bufpush(0x10CE3); + break; + case 0x10CA4: + bufpush(0x10CE4); + break; + case 0x10CA5: + bufpush(0x10CE5); + break; + case 0x10CA6: + bufpush(0x10CE6); + break; + case 0x10CA7: + bufpush(0x10CE7); + break; + case 0x10CA8: + bufpush(0x10CE8); + break; + case 0x10CA9: + bufpush(0x10CE9); + break; + case 0x10CAA: + bufpush(0x10CEA); + break; + case 0x10CAB: + bufpush(0x10CEB); + break; + case 0x10CAC: + bufpush(0x10CEC); + break; + case 0x10CAD: + bufpush(0x10CED); + break; + case 0x10CAE: + bufpush(0x10CEE); + break; + case 0x10CAF: + bufpush(0x10CEF); + break; + case 0x10CB0: + bufpush(0x10CF0); + break; + case 0x10CB1: + bufpush(0x10CF1); + break; + case 0x10CB2: + bufpush(0x10CF2); + break; + case 0x118A0: + bufpush(0x118C0); + break; + case 0x118A1: + bufpush(0x118C1); + break; + case 0x118A2: + bufpush(0x118C2); + break; + case 0x118A3: + bufpush(0x118C3); + break; + case 0x118A4: + bufpush(0x118C4); + break; + case 0x118A5: + bufpush(0x118C5); + break; + case 0x118A6: + bufpush(0x118C6); + break; + case 0x118A7: + bufpush(0x118C7); + break; + case 0x118A8: + bufpush(0x118C8); + break; + case 0x118A9: + bufpush(0x118C9); + break; + case 0x118AA: + bufpush(0x118CA); + break; + case 0x118AB: + bufpush(0x118CB); + break; + case 0x118AC: + bufpush(0x118CC); + break; + case 0x118AD: + bufpush(0x118CD); + break; + case 0x118AE: + bufpush(0x118CE); + break; + case 0x118AF: + bufpush(0x118CF); + break; + case 0x118B0: + bufpush(0x118D0); + break; + case 0x118B1: + bufpush(0x118D1); + break; + case 0x118B2: + bufpush(0x118D2); + break; + case 0x118B3: + bufpush(0x118D3); + break; + case 0x118B4: + bufpush(0x118D4); + break; + case 0x118B5: + bufpush(0x118D5); + break; + case 0x118B6: + bufpush(0x118D6); + break; + case 0x118B7: + bufpush(0x118D7); + break; + case 0x118B8: + bufpush(0x118D8); + break; + case 0x118B9: + bufpush(0x118D9); + break; + case 0x118BA: + bufpush(0x118DA); + break; + case 0x118BB: + bufpush(0x118DB); + break; + case 0x118BC: + bufpush(0x118DC); + break; + case 0x118BD: + bufpush(0x118DD); + break; + case 0x118BE: + bufpush(0x118DE); + break; + case 0x118BF: + bufpush(0x118DF); + break; + case 0x1E900: + bufpush(0x1E922); + break; + case 0x1E901: + bufpush(0x1E923); + break; + case 0x1E902: + bufpush(0x1E924); + break; + case 0x1E903: + bufpush(0x1E925); + break; + case 0x1E904: + bufpush(0x1E926); + break; + case 0x1E905: + bufpush(0x1E927); + break; + case 0x1E906: + bufpush(0x1E928); + break; + case 0x1E907: + bufpush(0x1E929); + break; + case 0x1E908: + bufpush(0x1E92A); + break; + case 0x1E909: + bufpush(0x1E92B); + break; + case 0x1E90A: + bufpush(0x1E92C); + break; + case 0x1E90B: + bufpush(0x1E92D); + break; + case 0x1E90C: + bufpush(0x1E92E); + break; + case 0x1E90D: + bufpush(0x1E92F); + break; + case 0x1E90E: + bufpush(0x1E930); + break; + case 0x1E90F: + bufpush(0x1E931); + break; + case 0x1E910: + bufpush(0x1E932); + break; + case 0x1E911: + bufpush(0x1E933); + break; + case 0x1E912: + bufpush(0x1E934); + break; + case 0x1E913: + bufpush(0x1E935); + break; + case 0x1E914: + bufpush(0x1E936); + break; + case 0x1E915: + bufpush(0x1E937); + break; + case 0x1E916: + bufpush(0x1E938); + break; + case 0x1E917: + bufpush(0x1E939); + break; + case 0x1E918: + bufpush(0x1E93A); + break; + case 0x1E919: + bufpush(0x1E93B); + break; + case 0x1E91A: + bufpush(0x1E93C); + break; + case 0x1E91B: + bufpush(0x1E93D); + break; + case 0x1E91C: + bufpush(0x1E93E); + break; + case 0x1E91D: + bufpush(0x1E93F); + break; + case 0x1E91E: + bufpush(0x1E940); + break; + case 0x1E91F: + bufpush(0x1E941); + break; + case 0x1E920: + bufpush(0x1E942); + break; + case 0x1E921: + bufpush(0x1E943); + break; default: bufpush(c); } diff --git a/chunk.h b/chunk.h index a2248f5..f198be3 100644 --- a/chunk.h +++ b/chunk.h @@ -37,6 +37,8 @@ static CMARK_INLINE void cmark_chunk_ltrim(cmark_chunk *c) { } static CMARK_INLINE void cmark_chunk_rtrim(cmark_chunk *c) { + assert(!c->alloc); + while (c->len > 0) { if (!cmark_isspace(c->data[c->len - 1])) break; @@ -50,8 +52,8 @@ static CMARK_INLINE void cmark_chunk_trim(cmark_chunk *c) { cmark_chunk_rtrim(c); } -static CMARK_INLINE bufsize_t - cmark_chunk_strchr(cmark_chunk *ch, int c, bufsize_t offset) { +static CMARK_INLINE bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c, + bufsize_t offset) { const unsigned char *p = (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); return p ? (bufsize_t)(p - ch->data) : ch->len; @@ -99,8 +101,8 @@ static CMARK_INLINE cmark_chunk cmark_chunk_literal(const char *data) { return c; } -static CMARK_INLINE cmark_chunk - cmark_chunk_dup(const cmark_chunk *ch, bufsize_t pos, bufsize_t len) { +static CMARK_INLINE cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, + bufsize_t pos, bufsize_t len) { cmark_chunk c = {ch->data + pos, len, 0}; return c; } diff --git a/cmark.c b/cmark.c index 0d3bc16..d64237f 100644 --- a/cmark.c +++ b/cmark.c @@ -12,15 +12,19 @@ const char *cmark_version_string() { return CMARK_VERSION_STRING; } static void *xcalloc(size_t nmem, size_t size) { void *ptr = calloc(nmem, size); - if (!ptr) + if (!ptr) { + fprintf(stderr, "[cmark] calloc returned null pointer, aborting\n"); abort(); + } return ptr; } static void *xrealloc(void *ptr, size_t size) { void *new_ptr = realloc(ptr, size); - if (!new_ptr) + if (!new_ptr) { + fprintf(stderr, "[cmark] realloc returned null pointer, aborting\n"); abort(); + } return new_ptr; } diff --git a/cmark.h b/cmark.h index a26ecb4..d1a65aa 100644 --- a/cmark.h +++ b/cmark.h @@ -2,8 +2,8 @@ #define CMARK_H #include -#include "cmark_export.h" -#include "cmark_version.h" +#include +#include #ifdef __cplusplus extern "C" { @@ -265,7 +265,8 @@ CMARK_EXPORT const char *cmark_node_get_type_string(cmark_node *node); /** Returns the string contents of 'node', or an empty - string if none is set. + string if none is set. Returns NULL if called on a + node that does not have string content. */ CMARK_EXPORT const char *cmark_node_get_literal(cmark_node *node); @@ -334,7 +335,8 @@ CMARK_EXPORT const char *cmark_node_get_fence_info(cmark_node *node); CMARK_EXPORT int cmark_node_set_fence_info(cmark_node *node, const char *info); /** Returns the URL of a link or image 'node', or an empty string - if no URL is set. + if no URL is set. Returns NULL if called on a node that is + not a link or image. */ CMARK_EXPORT const char *cmark_node_get_url(cmark_node *node); @@ -344,7 +346,8 @@ CMARK_EXPORT const char *cmark_node_get_url(cmark_node *node); CMARK_EXPORT int cmark_node_set_url(cmark_node *node, const char *url); /** Returns the title of a link or image 'node', or an empty - string if no title is set. + string if no title is set. Returns NULL if called on a node + that is not a link or image. */ CMARK_EXPORT const char *cmark_node_get_title(cmark_node *node); @@ -354,7 +357,8 @@ CMARK_EXPORT const char *cmark_node_get_title(cmark_node *node); CMARK_EXPORT int cmark_node_set_title(cmark_node *node, const char *title); /** Returns the literal "on enter" text for a custom 'node', or - an empty string if no on_enter is set. + an empty string if no on_enter is set. Returns NULL if called + on a non-custom node. */ CMARK_EXPORT const char *cmark_node_get_on_enter(cmark_node *node); @@ -366,7 +370,8 @@ CMARK_EXPORT int cmark_node_set_on_enter(cmark_node *node, const char *on_enter); /** Returns the literal "on exit" text for a custom 'node', or - an empty string if no on_exit is set. + an empty string if no on_exit is set. Returns NULL if + called on a non-custom node. */ CMARK_EXPORT const char *cmark_node_get_on_exit(cmark_node *node); @@ -563,7 +568,7 @@ char *cmark_render_latex(cmark_node *root, int options, int width); * ### Options affecting parsing */ -/** Normalize tree by consolidating adjacent text nodes. +/** Legacy option (no effect). */ #define CMARK_OPT_NORMALIZE (1 << 8) @@ -590,13 +595,13 @@ char *cmark_render_latex(cmark_node *root, int options, int width); * In hexadecimal format, the number 0x010203 represents version 1.2.3. */ CMARK_EXPORT -int cmark_version(); +int cmark_version(void); /** The library version string for runtime checks. Also available as * macro CMARK_VERSION_STRING for compile time checks. */ CMARK_EXPORT -const char *cmark_version_string(); +const char *cmark_version_string(void); /** # AUTHORS * diff --git a/commonmark.c b/commonmark.c index b8b1820..95a1ae5 100644 --- a/commonmark.c +++ b/commonmark.c @@ -1,6 +1,7 @@ #include #include #include +#include #include #include "config.h" @@ -81,7 +82,9 @@ static int longest_backtick_sequence(const char *code) { } static int shortest_unused_backtick_sequence(const char *code) { - int32_t used = 1; + // note: if the shortest sequence is >= 32, this returns 32 + // so as not to overflow the bit array. + uint32_t used = 1; int current = 0; size_t i = 0; size_t code_len = strlen(code); @@ -89,8 +92,8 @@ static int shortest_unused_backtick_sequence(const char *code) { if (code[i] == '`') { current++; } else { - if (current) { - used |= (1 << current); + if (current > 0 && current < 32) { + used |= (1U << current); } current = 0; } @@ -98,7 +101,7 @@ static int shortest_unused_backtick_sequence(const char *code) { } // return number of first bit that is 0: i = 0; - while (used & 1) { + while (i < 32 && used & 1) { used = used >> 1; i++; } diff --git a/commonmark_test.go b/commonmark_test.go index 8f112c5..6ef83cf 100644 --- a/commonmark_test.go +++ b/commonmark_test.go @@ -197,7 +197,7 @@ func TestCMarkLists(t *testing.T) { root.AppendChild(list) t.Logf("\nXML: %v", root.RenderXML(commonmark.CMARK_OPT_DEFAULT)) htmlString := root.RenderHtml(commonmark.CMARK_OPT_DEFAULT) - if htmlString != "
      \n
    1. List Item 1
      2. \n
    2. \n
    \n" { + if htmlString != "
      \n
    1. List Item 1
      2. \n
    2. \n
    \n" { t.Error("htmlString is wrong!") } t.Logf("\nHtmlString: \n%v", htmlString) diff --git a/entities.inc b/entities.inc index ec3d2a9..a7c36e2 100644 --- a/entities.inc +++ b/entities.inc @@ -6,7 +6,7 @@ struct cmark_entity_node { }; #define CMARK_ENTITY_MIN_LENGTH 2 -#define CMARK_ENTITY_MAX_LENGTH 31 +#define CMARK_ENTITY_MAX_LENGTH 32 #define CMARK_NUM_ENTITIES 2125 static const struct cmark_entity_node cmark_entities[] = { diff --git a/houdini_html_u.c b/houdini_html_u.c index 6e8d620..30d08aa 100644 --- a/houdini_html_u.c +++ b/houdini_html_u.c @@ -16,7 +16,7 @@ static const unsigned char *S_lookup(int i, int low, int hi, strncmp((const char *)s, (const char *)cmark_entities[i].entity, len); if (cmp == 0 && cmark_entities[i].entity[len] == 0) { return (const unsigned char *)cmark_entities[i].bytes; - } else if (cmp < 0 && i > low) { + } else if (cmp <= 0 && i > low) { j = i - ((i - low) / 2); if (j == i) j -= 1; diff --git a/inlines.c b/inlines.c index e5ca8e2..2d7f385 100644 --- a/inlines.c +++ b/inlines.c @@ -30,10 +30,13 @@ static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99"; #define make_emph(mem) make_simple(mem, CMARK_NODE_EMPH) #define make_strong(mem) make_simple(mem, CMARK_NODE_STRONG) +#define MAXBACKTICKS 1000 + typedef struct delimiter { struct delimiter *previous; struct delimiter *next; cmark_node *inl_text; + bufsize_t length; unsigned char delim_char; bool can_open; bool can_close; @@ -56,6 +59,8 @@ typedef struct { cmark_reference_map *refmap; delimiter *last_delim; bracket *last_bracket; + bufsize_t backticks[MAXBACKTICKS + 1]; + bool scanned_for_backticks; } subject; static CMARK_INLINE bool S_is_line_end_char(char c) { @@ -110,7 +115,8 @@ static cmark_chunk chunk_clone(cmark_mem *mem, cmark_chunk *src) { c.len = len; c.data = (unsigned char *)mem->calloc(len + 1, 1); c.alloc = 1; - memcpy(c.data, src->data, len); + if (len) + memcpy(c.data, src->data, len); c.data[len] = '\0'; return c; @@ -145,6 +151,7 @@ static CMARK_INLINE cmark_node *make_autolink(cmark_mem *mem, cmark_chunk url, static void subject_from_buf(cmark_mem *mem, subject *e, cmark_strbuf *buffer, cmark_reference_map *refmap) { + int i; e->mem = mem; e->input.data = buffer->ptr; e->input.len = buffer->size; @@ -153,6 +160,10 @@ static void subject_from_buf(cmark_mem *mem, subject *e, cmark_strbuf *buffer, e->refmap = refmap; e->last_delim = NULL; e->last_bracket = NULL; + for (i = 0; i <= MAXBACKTICKS; i++) { + e->backticks[i] = 0; + } + e->scanned_for_backticks = false; } static CMARK_INLINE int isbacktick(int c) { return (c == '`'); } @@ -219,23 +230,42 @@ static CMARK_INLINE cmark_chunk take_while(subject *subj, int (*f)(int)) { // after the closing backticks. static bufsize_t scan_to_closing_backticks(subject *subj, bufsize_t 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 + + bool found = false; + if (openticklength > MAXBACKTICKS) { + // we limit backtick string length because of the array subj->backticks: + return 0; } - bufsize_t numticks = 0; - while (peek_char(subj) == '`') { - advance(subj); - numticks++; + if (subj->scanned_for_backticks && + subj->backticks[openticklength] <= subj->pos) { + // return if we already know there's no closer + return 0; } - if (numticks != openticklength) { - return (scan_to_closing_backticks(subj, openticklength)); + while (!found) { + // read non backticks + unsigned char c; + while ((c = peek_char(subj)) && c != '`') { + advance(subj); + } + if (is_eof(subj)) { + break; + } + bufsize_t numticks = 0; + while (peek_char(subj) == '`') { + advance(subj); + numticks++; + } + // store position of ender + if (numticks <= MAXBACKTICKS) { + subj->backticks[numticks] = subj->pos - numticks; + } + if (numticks == openticklength) { + return (subj->pos); + } } - return (subj->pos); + // got through whole input without finding closer + subj->scanned_for_backticks = true; + return 0; } // Parse backtick code section or raw backticks, return an inline. @@ -302,20 +332,21 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open, after_char = 10; } left_flanking = numdelims > 0 && !cmark_utf8proc_is_space(after_char) && - !(cmark_utf8proc_is_punctuation(after_char) && - !cmark_utf8proc_is_space(before_char) && - !cmark_utf8proc_is_punctuation(before_char)); + (!cmark_utf8proc_is_punctuation(after_char) || + cmark_utf8proc_is_space(before_char) || + cmark_utf8proc_is_punctuation(before_char)); right_flanking = numdelims > 0 && !cmark_utf8proc_is_space(before_char) && - !(cmark_utf8proc_is_punctuation(before_char) && - !cmark_utf8proc_is_space(after_char) && - !cmark_utf8proc_is_punctuation(after_char)); + (!cmark_utf8proc_is_punctuation(before_char) || + cmark_utf8proc_is_space(after_char) || + cmark_utf8proc_is_punctuation(after_char)); if (c == '_') { *can_open = left_flanking && (!right_flanking || cmark_utf8proc_is_punctuation(before_char)); *can_close = right_flanking && (!left_flanking || cmark_utf8proc_is_punctuation(after_char)); } else if (c == '\'' || c == '"') { - *can_open = left_flanking && !right_flanking; + *can_open = left_flanking && !right_flanking && + before_char != ']' && before_char != ')'; *can_close = right_flanking; } else { *can_open = left_flanking; @@ -330,9 +361,8 @@ static void print_delimiters(subject *subj) delimiter *delim; delim = subj->last_delim; while (delim != NULL) { - printf("Item at stack pos %p, text pos %d: %d %d %d next(%p) -prev(%p)\n", - (void*)delim, delim->position, delim->delim_char, + printf("Item at stack pos %p: %d %d %d next(%p) prev(%p)\n", + (void*)delim, delim->delim_char, delim->can_open, delim->can_close, (void*)delim->next, (void*)delim->previous); delim = delim->previous; @@ -353,7 +383,7 @@ static void remove_delimiter(subject *subj, delimiter *delim) { if (delim->previous != NULL) { delim->previous->next = delim->next; } - free(delim); + subj->mem->free(delim); } static void pop_bracket(subject *subj) { @@ -362,7 +392,7 @@ static void pop_bracket(subject *subj) { return; b = subj->last_bracket; subj->last_bracket = subj->last_bracket->previous; - free(b); + subj->mem->free(b); } static void push_delimiter(subject *subj, unsigned char c, bool can_open, @@ -372,6 +402,7 @@ static void push_delimiter(subject *subj, unsigned char c, bool can_open, delim->can_open = can_open; delim->can_close = can_close; delim->inl_text = inl_text; + delim->length = inl_text->as.literal.len; delim->previous = subj->last_delim; delim->next = NULL; if (delim->previous != NULL) { @@ -486,14 +517,9 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) { delimiter *opener; delimiter *old_closer; bool opener_found; - bool odd_match; - delimiter *openers_bottom[128]; - - // initialize openers_bottom: - openers_bottom['*'] = stack_bottom; - openers_bottom['_'] = stack_bottom; - openers_bottom['\''] = stack_bottom; - openers_bottom['"'] = stack_bottom; + int openers_bottom_index; + delimiter *openers_bottom[6] = {stack_bottom, stack_bottom, stack_bottom, + stack_bottom, stack_bottom, stack_bottom}; // move back to first relevant delim. while (closer != NULL && closer->previous != stack_bottom) { @@ -503,23 +529,35 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) { // now move forward, looking for closers, and handling each while (closer != NULL) { if (closer->can_close) { + switch (closer->delim_char) { + case '"': + openers_bottom_index = 0; + break; + case '\'': + openers_bottom_index = 1; + break; + case '_': + openers_bottom_index = 2; + break; + case '*': + openers_bottom_index = 3 + (closer->length % 3); + break; + default: + assert(false); + } + // Now look backwards for first matching opener: opener = closer->previous; opener_found = false; - odd_match = false; - while (opener != NULL && opener != stack_bottom && - opener != openers_bottom[closer->delim_char]) { - // interior closer of size 2 can't match opener of size 1 - // or of size 1 can't match 2 - odd_match = (closer->can_open || opener->can_close) && - ((opener->inl_text->as.literal.len + - closer->inl_text->as.literal.len) % - 3 == - 0); - if (opener->delim_char == closer->delim_char && opener->can_open && - !odd_match) { - opener_found = true; - break; + while (opener != NULL && opener != openers_bottom[openers_bottom_index]) { + if (opener->can_open && opener->delim_char == closer->delim_char) { + // interior closer of size 2 can't match opener of size 1 + // or of size 1 can't match 2 + if (!(closer->can_open || opener->can_close) || + ((opener->length + closer->length) % 3) != 0) { + opener_found = true; + break; + } } opener = opener->previous; } @@ -547,13 +585,9 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) { } closer = closer->next; } - if (!opener_found && !odd_match) { + if (!opener_found) { // set lower bound for future searches for openers - // (we don't do this with 'odd_match' set because - // a ** that didn't match an earlier * might turn into - // an opener, and the * might be matched by something - // else. - openers_bottom[old_closer->delim_char] = old_closer->previous; + openers_bottom[openers_bottom_index] = old_closer->previous; if (!old_closer->can_open) { // we can remove a closer that can't be an // opener, once we've seen there's no @@ -566,7 +600,7 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) { } } // free all delimiters in list until stack_bottom: - while (subj->last_delim != stack_bottom) { + while (subj->last_delim != NULL && subj->last_delim != stack_bottom) { remove_delimiter(subj, subj->last_delim); } } @@ -582,12 +616,7 @@ static delimiter *S_insert_emph(subject *subj, delimiter *opener, cmark_node *tmp, *tmpnext, *emph; // 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; - } + use_delims = (closer_num_chars >= 2 && opener_num_chars >= 2) ? 2 : 1; // remove used characters from associated inlines. opener_num_chars -= use_delims; @@ -667,8 +696,8 @@ static cmark_node *handle_entity(subject *subj) { return make_str(subj->mem, cmark_chunk_buf_detach(&ent)); } -// Clean a URL: remove surrounding whitespace and surrounding <>, -// and remove \ that escape punctuation. +// Clean a URL: remove surrounding whitespace, and remove \ that escape +// punctuation. cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url) { cmark_strbuf buf = CMARK_BUF_INIT(mem); @@ -679,11 +708,7 @@ cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url) { return result; } - 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); - } + houdini_unescape_html_f(&buf, url->data, url->len); cmark_strbuf_unescape(&buf); return cmark_chunk_buf_detach(&buf); @@ -797,12 +822,76 @@ static int link_label(subject *subj, cmark_chunk *raw_label) { return 0; } +static bufsize_t manual_scan_link_url_2(cmark_chunk *input, bufsize_t offset, + cmark_chunk *output) { + bufsize_t i = offset; + size_t nb_p = 0; + + while (i < input->len) { + if (input->data[i] == '\\' && + i + 1 < input-> len && + cmark_ispunct(input->data[i+1])) + i += 2; + else if (input->data[i] == '(') { + ++nb_p; + ++i; + } else if (input->data[i] == ')') { + if (nb_p == 0) + break; + --nb_p; + ++i; + } else if (cmark_isspace(input->data[i])) + break; + else + ++i; + } + + if (i >= input->len) + return -1; + + { + cmark_chunk result = {input->data + offset, i - offset, 0}; + *output = result; + } + return i - offset; +} + +static bufsize_t manual_scan_link_url(cmark_chunk *input, bufsize_t offset, + cmark_chunk *output) { + bufsize_t i = offset; + + if (i < input->len && input->data[i] == '<') { + ++i; + while (i < input->len) { + if (input->data[i] == '>') { + ++i; + break; + } else if (input->data[i] == '\\') + i += 2; + else if (cmark_isspace(input->data[i]) || input->data[i] == '<') + return manual_scan_link_url_2(input, offset, output); + else + ++i; + } + } else { + return manual_scan_link_url_2(input, offset, output); + } + + if (i >= input->len) + return -1; + + { + cmark_chunk result = {input->data + offset + 1, i - 2 - offset, 0}; + *output = result; + } + return i - offset; +} + // Return a link, an image, or a literal close bracket. static cmark_node *handle_close_bracket(subject *subj) { - bufsize_t initial_pos; - bufsize_t starturl, endurl, starttitle, endtitle, endall; - bufsize_t n; - bufsize_t sps; + bufsize_t initial_pos, after_link_text_pos; + bufsize_t endurl, starttitle, endtitle, endall; + bufsize_t sps, n; cmark_reference *ref = NULL; cmark_chunk url_chunk, title_chunk; cmark_chunk url, title; @@ -833,14 +922,16 @@ static cmark_node *handle_close_bracket(subject *subj) { // Now we check to see if it's a link/image. is_image = opener->image; + after_link_text_pos = subj->pos; + // 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)) { + ((n = manual_scan_link_url(&subj->input, subj->pos + 1 + sps, + &url_chunk)) > -1)) { // try to parse an explicit link: - starturl = subj->pos + 1 + sps; // after ( - endurl = starturl + n; + endurl = subj->pos + 1 + sps + n; starttitle = endurl + scan_spacechars(&subj->input, endurl); // ensure there are spaces btw url and title @@ -853,7 +944,6 @@ static cmark_node *handle_close_bracket(subject *subj) { 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(subj->mem, &url_chunk); @@ -863,7 +953,8 @@ static cmark_node *handle_close_bracket(subject *subj) { goto match; } else { - goto noMatch; + // it could still be a shortcut reference link + subj->pos = after_link_text_pos; } } @@ -1094,7 +1185,10 @@ extern void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent, ; process_emphasis(&subj, NULL); - // free bracket stack + // free bracket and delim stack + while (subj.last_delim) { + remove_delimiter(&subj, subj.last_delim); + } while (subj.last_bracket) { pop_bracket(&subj); } @@ -1138,9 +1232,8 @@ bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_strbuf *input, // parse link url: spnl(&subj); - matchlen = scan_link_url(&subj.input, subj.pos); - if (matchlen) { - url = cmark_chunk_dup(&subj.input, subj.pos, matchlen); + if ((matchlen = manual_scan_link_url(&subj.input, subj.pos, &url)) > -1 && + url.len > 0) { subj.pos += matchlen; } else { return 0; diff --git a/latex.c b/latex.c index 7c3decd..0d9517d 100644 --- a/latex.c +++ b/latex.c @@ -42,7 +42,7 @@ static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape, break; case 45: // '-' if (nextc == 45) { // prevent ligature - cmark_render_ascii(renderer, "\\-"); + cmark_render_ascii(renderer, "-{}"); } else { cmark_render_ascii(renderer, "-"); } @@ -179,8 +179,12 @@ static link_type get_link_type(cmark_node *node) { link_text = node->first_child; cmark_consolidate_text_nodes(link_text); + + if (!link_text) + return NO_LINK; + realurl = (char *)url; - realurllen = url_len; + realurllen = (int)url_len; if (strncmp(realurl, "mailto:", 7) == 0) { realurl += 7; realurllen -= 7; @@ -216,11 +220,10 @@ static int S_get_enumlevel(cmark_node *node) { static int S_render_node(cmark_renderer *renderer, cmark_node *node, cmark_event_type ev_type, int options) { int list_number; + int enumlevel; char list_number_string[LIST_NUMBER_STRING_SIZE]; bool entering = (ev_type == CMARK_EVENT_ENTER); cmark_list_type list_type; - const char *roman_numerals[] = {"", "i", "ii", "iii", "iv", "v", - "vi", "vii", "viii", "ix", "x"}; bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options); // avoid warning about unused parameter: @@ -249,13 +252,24 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, CR(); list_number = cmark_node_get_list_start(node); if (list_number > 1) { - snprintf(list_number_string, LIST_NUMBER_STRING_SIZE, "%d", - list_number); - LIT("\\setcounter{enum"); - LIT((char *)roman_numerals[S_get_enumlevel(node)]); - LIT("}{"); - OUT(list_number_string, false, NORMAL); - LIT("}"); + enumlevel = S_get_enumlevel(node); + // latex normally supports only five levels + if (enumlevel >= 1 && enumlevel <= 5) { + snprintf(list_number_string, LIST_NUMBER_STRING_SIZE, "%d", + list_number); + LIT("\\setcounter{enum"); + switch (enumlevel) { + case 1: LIT("i"); break; + case 2: LIT("ii"); break; + case 3: LIT("iii"); break; + case 4: LIT("iv"); break; + case 5: LIT("v"); break; + default: LIT("i"); break; + } + LIT("}{"); + OUT(list_number_string, false, NORMAL); + LIT("}"); + } CR(); } } else { @@ -390,7 +404,8 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, case URL_AUTOLINK: LIT("\\url{"); OUT(url, false, URL); - break; + LIT("}"); + return 0; // Don't process further nodes to avoid double-rendering artefacts case EMAIL_AUTOLINK: LIT("\\href{"); OUT(url, false, URL); diff --git a/node.c b/node.c index e722acf..c6c2902 100644 --- a/node.c +++ b/node.c @@ -85,7 +85,7 @@ cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) { case CMARK_NODE_LIST: { cmark_list *list = &node->as.list; list->list_type = CMARK_BULLET_LIST; - list->start = 1; + list->start = 0; list->tight = false; break; } diff --git a/references.c b/references.c index e141213..89f2dc8 100644 --- a/references.c +++ b/references.c @@ -46,7 +46,7 @@ static unsigned char *normalize_reference(cmark_mem *mem, cmark_chunk *ref) { assert(result); if (result[0] == '\0') { - free(result); + mem->free(result); return NULL; } @@ -114,7 +114,7 @@ cmark_reference *cmark_reference_lookup(cmark_reference_map *map, ref = ref->next; } - free(norm); + map->mem->free(norm); return ref; } @@ -135,7 +135,7 @@ void cmark_reference_map_free(cmark_reference_map *map) { } } - free(map); + map->mem->free(map); } cmark_reference_map *cmark_reference_map_new(cmark_mem *mem) { diff --git a/scanners.c b/scanners.c index 709a74e..b312f66 100644 --- a/scanners.c +++ b/scanners.c @@ -28,176 +28,86 @@ bufsize_t _scan_scheme(const unsigned char *p) { { unsigned char yych; - yych = *(marker = p); - if (yych <= 0x7F) { - if (yych <= ' ') { - if (yych == '\n') - goto yy2; - if (yych <= 0x1F) - goto yy4; - goto yy3; - } else { - if (yych <= 'Z') { - if (yych <= '@') - goto yy4; + yych = *p; + if (yych <= '@') + goto yy2; + if (yych <= 'Z') + goto yy4; + if (yych <= '`') + goto yy2; + if (yych <= 'z') + goto yy4; + yy2: + ++p; + yy3 : { return 0; } + yy4: + yych = *(marker = ++p); + if (yych <= '/') { + if (yych <= '+') { + if (yych <= '*') goto yy3; - } else { - if (yych <= '`') - goto yy4; - if (yych <= 'z') - goto yy3; - goto yy4; - } - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) { - if (yych >= 0xC2) - goto yy5; - } else { - if (yych <= 0xE0) - goto yy7; - if (yych <= 0xEC) - goto yy8; - goto yy12; - } } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy8; - goto yy9; - } else { - if (yych <= 0xF3) - goto yy10; - if (yych <= 0xF4) - goto yy11; - } + if (yych <= ',') + goto yy3; + if (yych >= '/') + goto yy3; } - } - yy2 : { return 0; } - yy3: - yych = *(marker = ++p); - if (yych <= '.') { - if (yych == '+') - goto yy13; - if (yych <= ',') - goto yy2; - goto yy13; } else { if (yych <= 'Z') { + if (yych <= '9') + goto yy5; if (yych <= '@') - goto yy2; - goto yy13; + goto yy3; } else { if (yych <= '`') - goto yy2; - if (yych <= 'z') - goto yy13; - goto yy2; + goto yy3; + if (yych >= '{') + goto yy3; } } - yy4: - yych = *++p; - goto yy2; yy5: - yych = *++p; - if (yych <= 0x7F) - goto yy6; - if (yych <= 0xBF) - goto yy4; - yy6: - p = marker; - goto yy2; - yy7: - yych = *++p; - if (yych <= 0x9F) - goto yy6; - if (yych <= 0xBF) - goto yy5; - goto yy6; - yy8: - yych = *++p; - if (yych <= 0x7F) - goto yy6; - if (yych <= 0xBF) - goto yy5; - goto yy6; - yy9: - yych = *++p; - if (yych <= 0x8F) - goto yy6; - if (yych <= 0xBF) - goto yy8; - goto yy6; - yy10: - yych = *++p; - if (yych <= 0x7F) - goto yy6; - if (yych <= 0xBF) - goto yy8; - goto yy6; - yy11: - yych = *++p; - if (yych <= 0x7F) - goto yy6; - if (yych <= 0x8F) - goto yy8; - goto yy6; - yy12: - yych = *++p; - if (yych <= 0x7F) - goto yy6; - if (yych <= 0x9F) - goto yy5; - goto yy6; - yy13: yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy6; - goto yy16; + if (yych <= ',') { + if (yych == '+') + goto yy9; } else { - if (yych <= ',') - goto yy6; - if (yych <= '.') - goto yy16; - goto yy6; + if (yych != '/') + goto yy9; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; - if (yych <= '@') - goto yy6; - goto yy16; + goto yy7; + if (yych >= 'A') + goto yy9; } else { if (yych <= '`') goto yy6; if (yych <= 'z') - goto yy16; - goto yy6; + goto yy9; } } - yy14: + yy6: + p = marker; + goto yy3; + yy7: ++p; { return (bufsize_t)(p - start); } - yy16: + yy9: yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -209,19 +119,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -233,19 +141,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -257,19 +163,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -281,19 +185,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -305,19 +207,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -329,19 +229,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -353,19 +251,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -377,19 +273,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -401,19 +295,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -425,19 +317,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -449,19 +339,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -473,19 +361,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -497,19 +383,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -521,19 +405,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -545,19 +427,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -569,19 +449,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -593,19 +471,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -617,19 +493,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -641,19 +515,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -665,19 +537,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -689,19 +559,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -713,19 +581,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -737,19 +603,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -761,19 +625,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -785,19 +647,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -809,19 +669,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -833,19 +691,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -857,19 +713,17 @@ bufsize_t _scan_scheme(const unsigned char *p) { } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') + if (yych <= ',') { + if (yych != '+') goto yy6; } else { - if (yych <= ',') - goto yy6; - if (yych >= '/') + if (yych == '/') goto yy6; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy14; + goto yy7; if (yych <= '@') goto yy6; } else { @@ -881,7 +735,7 @@ bufsize_t _scan_scheme(const unsigned char *p) { } ++p; if ((yych = *p) == ':') - goto yy14; + goto yy7; goto yy6; } } @@ -914,950 +768,804 @@ bufsize_t _scan_autolink_uri(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - yych = *(marker = p); - if (yych <= 0x7F) { - if (yych <= ' ') { - if (yych == '\n') - goto yy48; - if (yych <= 0x1F) - goto yy50; - goto yy49; - } else { - if (yych <= 'Z') { - if (yych <= '@') - goto yy50; - goto yy49; - } else { - if (yych <= '`') - goto yy50; - if (yych <= 'z') - goto yy49; - goto yy50; - } - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) { - if (yych >= 0xC2) - goto yy51; - } else { - if (yych <= 0xE0) - goto yy53; - if (yych <= 0xEC) - goto yy54; - goto yy58; - } + yych = *p; + if (yych <= '@') + goto yy41; + if (yych <= 'Z') + goto yy43; + if (yych <= '`') + goto yy41; + if (yych <= 'z') + goto yy43; + yy41: + ++p; + yy42 : { return 0; } + yy43: + yych = *(marker = ++p); + if (yych <= '/') { + if (yych <= '+') { + if (yych <= '*') + goto yy42; } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy54; - goto yy55; - } else { - if (yych <= 0xF3) - goto yy56; - if (yych <= 0xF4) - goto yy57; - } + if (yych <= ',') + goto yy42; + if (yych >= '/') + goto yy42; } - } - yy48 : { return 0; } - yy49: - yych = *(marker = ++p); - if (yych <= '.') { - if (yych == '+') - goto yy59; - if (yych <= ',') - goto yy48; - goto yy59; } else { if (yych <= 'Z') { + if (yych <= '9') + goto yy44; if (yych <= '@') - goto yy48; - goto yy59; + goto yy42; } else { if (yych <= '`') - goto yy48; - if (yych <= 'z') - goto yy59; - goto yy48; + goto yy42; + if (yych >= '{') + goto yy42; } } - yy50: - yych = *++p; - goto yy48; - yy51: - yych = *++p; - if (yych <= 0x7F) - goto yy52; - if (yych <= 0xBF) - goto yy50; - yy52: - p = marker; - goto yy48; - yy53: - yych = *++p; - if (yych <= 0x9F) - goto yy52; - if (yych <= 0xBF) - goto yy51; - goto yy52; - yy54: - yych = *++p; - if (yych <= 0x7F) - goto yy52; - if (yych <= 0xBF) - goto yy51; - goto yy52; - yy55: - yych = *++p; - if (yych <= 0x8F) - goto yy52; - if (yych <= 0xBF) - goto yy54; - goto yy52; - yy56: - yych = *++p; - if (yych <= 0x7F) - goto yy52; - if (yych <= 0xBF) - goto yy54; - goto yy52; - yy57: - yych = *++p; - if (yych <= 0x7F) - goto yy52; - if (yych <= 0x8F) - goto yy54; - goto yy52; - yy58: - yych = *++p; - if (yych <= 0x7F) - goto yy52; - if (yych <= 0x9F) - goto yy51; - goto yy52; - yy59: + yy44: yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; - goto yy62; + if (yych <= ',') { + if (yych == '+') + goto yy48; } else { - if (yych <= ',') - goto yy52; - if (yych <= '.') - goto yy62; - goto yy52; + if (yych != '/') + goto yy48; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; - if (yych <= '@') - goto yy52; - goto yy62; + goto yy46; + if (yych >= 'A') + goto yy48; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych <= 'z') - goto yy62; - goto yy52; + goto yy48; } } - yy60: + yy45: + p = marker; + goto yy42; + yy46: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy60; + goto yy46; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '<') - goto yy52; + goto yy45; if (yych <= '>') - goto yy99; - goto yy52; + goto yy85; + goto yy45; } else { if (yych <= 0xDF) - goto yy92; + goto yy78; if (yych <= 0xE0) - goto yy93; - goto yy94; + goto yy79; + goto yy80; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy98; + goto yy84; if (yych <= 0xEF) - goto yy94; - goto yy95; + goto yy80; + goto yy81; } else { if (yych <= 0xF3) - goto yy96; + goto yy82; if (yych <= 0xF4) - goto yy97; - goto yy52; + goto yy83; + goto yy45; } } - yy62: + yy48: yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych <= '9') { - if (yych <= '+') { - if (yych <= '*') - goto yy52; + if (yych <= ',') { + if (yych != '+') + goto yy45; } else { - if (yych <= ',') - goto yy52; - if (yych >= '/') - goto yy52; + if (yych == '/') + goto yy45; } } else { if (yych <= 'Z') { if (yych <= ':') - goto yy60; + goto yy46; if (yych <= '@') - goto yy52; + goto yy45; } else { if (yych <= '`') - goto yy52; + goto yy45; if (yych >= '{') - goto yy52; + goto yy45; } } yych = *++p; if (yych == ':') - goto yy60; - goto yy52; - yy92: + goto yy46; + goto yy45; + yy78: ++p; yych = *p; if (yych <= 0x7F) - goto yy52; + goto yy45; if (yych <= 0xBF) - goto yy60; - goto yy52; - yy93: + goto yy46; + goto yy45; + yy79: ++p; yych = *p; if (yych <= 0x9F) - goto yy52; + goto yy45; if (yych <= 0xBF) - goto yy92; - goto yy52; - yy94: + goto yy78; + goto yy45; + yy80: ++p; yych = *p; if (yych <= 0x7F) - goto yy52; + goto yy45; if (yych <= 0xBF) - goto yy92; - goto yy52; - yy95: + goto yy78; + goto yy45; + yy81: ++p; yych = *p; if (yych <= 0x8F) - goto yy52; + goto yy45; if (yych <= 0xBF) - goto yy94; - goto yy52; - yy96: + goto yy80; + goto yy45; + yy82: ++p; yych = *p; if (yych <= 0x7F) - goto yy52; + goto yy45; if (yych <= 0xBF) - goto yy94; - goto yy52; - yy97: + goto yy80; + goto yy45; + yy83: ++p; yych = *p; if (yych <= 0x7F) - goto yy52; + goto yy45; if (yych <= 0x8F) - goto yy94; - goto yy52; - yy98: + goto yy80; + goto yy45; + yy84: ++p; yych = *p; if (yych <= 0x7F) - goto yy52; + goto yy45; if (yych <= 0x9F) - goto yy92; - goto yy52; - yy99: + goto yy78; + goto yy45; + yy85: ++p; { return (bufsize_t)(p - start); } } @@ -1891,309 +1599,230 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - yych = *(marker = p); - if (yych <= '?') { - if (yych <= ')') { - if (yych <= ' ') { - if (yych != '\n') - goto yy105; - } else { - if (yych == '"') - goto yy105; - if (yych <= '\'') - goto yy104; - goto yy105; - } + yych = *p; + if (yych <= '9') { + if (yych <= '\'') { + if (yych == '!') + goto yy91; + if (yych >= '#') + goto yy91; } else { - if (yych <= '9') { - if (yych == ',') - goto yy105; - goto yy104; - } else { - if (yych == '=') - goto yy104; - if (yych <= '>') - goto yy105; - goto yy104; - } + if (yych <= ')') + goto yy89; + if (yych != ',') + goto yy91; } } else { - if (yych <= 0xDF) { - if (yych <= ']') { - if (yych <= '@') - goto yy105; - if (yych <= 'Z') - goto yy104; - goto yy105; - } else { - if (yych <= '~') - goto yy104; - if (yych <= 0x7F) - goto yy105; - if (yych >= 0xC2) - goto yy106; - } + if (yych <= '?') { + if (yych == '=') + goto yy91; + if (yych >= '?') + goto yy91; } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy108; - if (yych == 0xED) - goto yy113; - goto yy109; + if (yych <= 'Z') { + if (yych >= 'A') + goto yy91; } else { - if (yych <= 0xF0) - goto yy110; - if (yych <= 0xF3) - goto yy111; - if (yych <= 0xF4) - goto yy112; + if (yych <= ']') + goto yy89; + if (yych <= '~') + goto yy91; } } } - yy103 : { return 0; } - yy104: + yy89: + ++p; + yy90 : { return 0; } + yy91: yych = *(marker = ++p); if (yych <= ',') { if (yych <= '"') { if (yych == '!') - goto yy116; - goto yy103; + goto yy95; + goto yy90; } else { if (yych <= '\'') - goto yy116; + goto yy95; if (yych <= ')') - goto yy103; + goto yy90; if (yych <= '+') - goto yy116; - goto yy103; + goto yy95; + goto yy90; } } else { if (yych <= '>') { if (yych <= '9') - goto yy116; + goto yy95; if (yych == '=') - goto yy116; - goto yy103; + goto yy95; + goto yy90; } else { if (yych <= 'Z') - goto yy116; + goto yy95; if (yych <= ']') - goto yy103; + goto yy90; if (yych <= '~') - goto yy116; - goto yy103; + goto yy95; + goto yy90; } } - yy105: - yych = *++p; - goto yy103; - yy106: - yych = *++p; - if (yych <= 0x7F) - goto yy107; - if (yych <= 0xBF) - goto yy105; - yy107: - p = marker; - goto yy103; - yy108: - yych = *++p; - if (yych <= 0x9F) - goto yy107; - if (yych <= 0xBF) - goto yy106; - goto yy107; - yy109: - yych = *++p; - if (yych <= 0x7F) - goto yy107; - if (yych <= 0xBF) - goto yy106; - goto yy107; - yy110: - yych = *++p; - if (yych <= 0x8F) - goto yy107; - if (yych <= 0xBF) - goto yy109; - goto yy107; - yy111: - yych = *++p; - if (yych <= 0x7F) - goto yy107; - if (yych <= 0xBF) - goto yy109; - goto yy107; - yy112: - yych = *++p; - if (yych <= 0x7F) - goto yy107; - if (yych <= 0x8F) - goto yy109; - goto yy107; - yy113: - yych = *++p; - if (yych <= 0x7F) - goto yy107; - if (yych <= 0x9F) - goto yy106; - goto yy107; - yy114: + yy92: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy117; - goto yy107; + goto yy96; } else { if (yych <= 'Z') - goto yy117; + goto yy96; if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy117; - goto yy107; + goto yy96; } - yy115: + yy93: + p = marker; + goto yy90; + yy94: ++p; yych = *p; - yy116: + yy95: if (yybm[0 + yych] & 128) { - goto yy115; + goto yy94; } if (yych <= '>') - goto yy107; + goto yy93; if (yych <= '@') - goto yy114; - goto yy107; - yy117: + goto yy92; + goto yy93; + yy96: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy119; - goto yy120; + goto yy98; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych >= ':') - goto yy107; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy248; - goto yy120; + goto yy227; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy247; - goto yy107; + goto yy226; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy247; + goto yy93; + goto yy226; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy247; - goto yy107; + goto yy226; + goto yy93; } } - yy119: + yy98: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy248; + goto yy227; if (yych <= '/') - goto yy107; - goto yy247; + goto yy93; + goto yy226; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; - goto yy247; + goto yy93; + goto yy226; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy247; - goto yy107; + goto yy226; + goto yy93; } } - yy120: + yy99: ++p; yych = *p; if (yych <= '@') { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy123; - goto yy107; + goto yy102; + goto yy93; } else { if (yych <= 'Z') - goto yy123; + goto yy102; if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy123; - goto yy107; + goto yy102; + goto yy93; } - yy121: + yy100: ++p; { return (bufsize_t)(p - start); } - yy123: + yy102: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy125; - goto yy120; + goto yy104; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych >= ':') - goto yy107; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } ++p; @@ -2201,6050 +1830,6050 @@ bufsize_t _scan_autolink_email(const unsigned char *p) { if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy127; - goto yy120; + goto yy106; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy126; - goto yy107; + goto yy105; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy126; + goto yy93; + goto yy105; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy126; - goto yy107; + goto yy105; + goto yy93; } } - yy125: + yy104: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy127; + goto yy106; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy126: + yy105: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy129; - goto yy120; + goto yy108; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy128; - goto yy107; + goto yy107; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy128; + goto yy93; + goto yy107; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy128; - goto yy107; + goto yy107; + goto yy93; } } - yy127: + yy106: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy129; + goto yy108; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy128: + yy107: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy131; - goto yy120; + goto yy110; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy130; - goto yy107; + goto yy109; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy130; + goto yy93; + goto yy109; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy130; - goto yy107; + goto yy109; + goto yy93; } } - yy129: + yy108: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy131; + goto yy110; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy130: + yy109: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy133; - goto yy120; + goto yy112; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy132; - goto yy107; + goto yy111; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy132; + goto yy93; + goto yy111; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy132; - goto yy107; + goto yy111; + goto yy93; } } - yy131: + yy110: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy133; + goto yy112; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy132: + yy111: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy135; - goto yy120; + goto yy114; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy134; - goto yy107; + goto yy113; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy134; + goto yy93; + goto yy113; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy134; - goto yy107; + goto yy113; + goto yy93; } } - yy133: + yy112: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy135; + goto yy114; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy134: + yy113: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy137; - goto yy120; + goto yy116; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy136; - goto yy107; + goto yy115; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy136; + goto yy93; + goto yy115; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy136; - goto yy107; + goto yy115; + goto yy93; } } - yy135: + yy114: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy137; + goto yy116; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy136: + yy115: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy139; - goto yy120; + goto yy118; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy138; - goto yy107; + goto yy117; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy138; + goto yy93; + goto yy117; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy138; - goto yy107; + goto yy117; + goto yy93; } } - yy137: + yy116: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy139; + goto yy118; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy138: + yy117: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy141; - goto yy120; + goto yy120; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy140; - goto yy107; + goto yy119; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy140; + goto yy93; + goto yy119; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy140; - goto yy107; + goto yy119; + goto yy93; } } - yy139: + yy118: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy141; + goto yy120; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy140: + yy119: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy143; - goto yy120; + goto yy122; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy142; - goto yy107; + goto yy121; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy142; + goto yy93; + goto yy121; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy142; - goto yy107; + goto yy121; + goto yy93; } } - yy141: + yy120: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy143; + goto yy122; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy142: + yy121: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy145; - goto yy120; + goto yy124; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy144; - goto yy107; + goto yy123; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy144; + goto yy93; + goto yy123; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy144; - goto yy107; + goto yy123; + goto yy93; } } - yy143: + yy122: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy145; + goto yy124; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy144: + yy123: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy147; - goto yy120; + goto yy126; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy146; - goto yy107; + goto yy125; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy146; + goto yy93; + goto yy125; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy146; - goto yy107; + goto yy125; + goto yy93; } } - yy145: + yy124: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy147; + goto yy126; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy146: + yy125: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy149; - goto yy120; + goto yy128; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy148; - goto yy107; + goto yy127; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy148; + goto yy93; + goto yy127; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy148; - goto yy107; + goto yy127; + goto yy93; } } - yy147: + yy126: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy149; + goto yy128; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy148: + yy127: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy151; - goto yy120; + goto yy130; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy150; - goto yy107; + goto yy129; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy150; + goto yy93; + goto yy129; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy150; - goto yy107; + goto yy129; + goto yy93; } } - yy149: + yy128: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy151; + goto yy130; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy150: + yy129: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy153; - goto yy120; + goto yy132; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy152; - goto yy107; + goto yy131; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy152; + goto yy93; + goto yy131; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy152; - goto yy107; + goto yy131; + goto yy93; } } - yy151: + yy130: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy153; + goto yy132; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy152: + yy131: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy155; - goto yy120; + goto yy134; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy154; - goto yy107; + goto yy133; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy154; + goto yy93; + goto yy133; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy154; - goto yy107; + goto yy133; + goto yy93; } } - yy153: + yy132: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy155; + goto yy134; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy154: + yy133: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy157; - goto yy120; + goto yy136; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy156; - goto yy107; + goto yy135; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy156; + goto yy93; + goto yy135; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy156; - goto yy107; + goto yy135; + goto yy93; } } - yy155: + yy134: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy157; + goto yy136; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy156: + yy135: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy159; - goto yy120; + goto yy138; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy158; - goto yy107; + goto yy137; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy158; + goto yy93; + goto yy137; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy158; - goto yy107; + goto yy137; + goto yy93; } } - yy157: + yy136: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy159; + goto yy138; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy158: + yy137: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy161; - goto yy120; + goto yy140; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy160; - goto yy107; + goto yy139; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy160; + goto yy93; + goto yy139; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy160; - goto yy107; + goto yy139; + goto yy93; } } - yy159: + yy138: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy161; + goto yy140; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy160: + yy139: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy163; - goto yy120; + goto yy142; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy162; - goto yy107; + goto yy141; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy162; + goto yy93; + goto yy141; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy162; - goto yy107; + goto yy141; + goto yy93; } } - yy161: + yy140: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy163; + goto yy142; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy162: + yy141: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy165; - goto yy120; + goto yy144; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy164; - goto yy107; + goto yy143; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy164; + goto yy93; + goto yy143; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy164; - goto yy107; + goto yy143; + goto yy93; } } - yy163: + yy142: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy165; + goto yy144; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy164: + yy143: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy167; - goto yy120; + goto yy146; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy166; - goto yy107; + goto yy145; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy166; + goto yy93; + goto yy145; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy166; - goto yy107; + goto yy145; + goto yy93; } } - yy165: + yy144: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy167; + goto yy146; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy166: + yy145: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy169; - goto yy120; + goto yy148; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy168; - goto yy107; + goto yy147; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy168; + goto yy93; + goto yy147; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy168; - goto yy107; + goto yy147; + goto yy93; } } - yy167: + yy146: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy169; + goto yy148; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy168: + yy147: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy171; - goto yy120; + goto yy150; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy170; - goto yy107; + goto yy149; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy170; + goto yy93; + goto yy149; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy170; - goto yy107; + goto yy149; + goto yy93; } } - yy169: + yy148: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy171; + goto yy150; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy170: + yy149: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy173; - goto yy120; + goto yy152; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy172; - goto yy107; + goto yy151; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy172; + goto yy93; + goto yy151; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy172; - goto yy107; + goto yy151; + goto yy93; } } - yy171: + yy150: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy173; + goto yy152; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy172: + yy151: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy175; - goto yy120; + goto yy154; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy174; - goto yy107; + goto yy153; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy174; + goto yy93; + goto yy153; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy174; - goto yy107; + goto yy153; + goto yy93; } } - yy173: + yy152: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy175; + goto yy154; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy174: + yy153: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy177; - goto yy120; + goto yy156; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy176; - goto yy107; + goto yy155; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy176; + goto yy93; + goto yy155; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy176; - goto yy107; + goto yy155; + goto yy93; } } - yy175: + yy154: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy177; + goto yy156; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy176: + yy155: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy179; - goto yy120; + goto yy158; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy178; - goto yy107; + goto yy157; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy178; + goto yy93; + goto yy157; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy178; - goto yy107; + goto yy157; + goto yy93; } } - yy177: + yy156: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy179; + goto yy158; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy178: + yy157: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy181; - goto yy120; + goto yy160; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy180; - goto yy107; + goto yy159; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy180; + goto yy93; + goto yy159; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy180; - goto yy107; + goto yy159; + goto yy93; } } - yy179: + yy158: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy181; + goto yy160; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy180: + yy159: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy183; - goto yy120; + goto yy162; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy182; - goto yy107; + goto yy161; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy182; + goto yy93; + goto yy161; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy182; - goto yy107; + goto yy161; + goto yy93; } } - yy181: + yy160: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy183; + goto yy162; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy182: + yy161: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy185; - goto yy120; + goto yy164; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy184; - goto yy107; + goto yy163; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy184; + goto yy93; + goto yy163; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy184; - goto yy107; + goto yy163; + goto yy93; } } - yy183: + yy162: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy185; + goto yy164; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy184: + yy163: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy187; - goto yy120; + goto yy166; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy186; - goto yy107; + goto yy165; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy186; + goto yy93; + goto yy165; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy186; - goto yy107; + goto yy165; + goto yy93; } } - yy185: + yy164: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy187; + goto yy166; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy186: + yy165: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy189; - goto yy120; + goto yy168; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy188; - goto yy107; + goto yy167; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy188; + goto yy93; + goto yy167; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy188; - goto yy107; + goto yy167; + goto yy93; } } - yy187: + yy166: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy189; + goto yy168; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy188: + yy167: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy191; - goto yy120; + goto yy170; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy190; - goto yy107; + goto yy169; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy190; + goto yy93; + goto yy169; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy190; - goto yy107; + goto yy169; + goto yy93; } } - yy189: + yy168: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy191; + goto yy170; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy190: + yy169: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy193; - goto yy120; + goto yy172; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy192; - goto yy107; + goto yy171; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy192; + goto yy93; + goto yy171; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy192; - goto yy107; + goto yy171; + goto yy93; } } - yy191: + yy170: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy193; + goto yy172; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy192: + yy171: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy195; - goto yy120; + goto yy174; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy194; - goto yy107; + goto yy173; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy194; + goto yy93; + goto yy173; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy194; - goto yy107; + goto yy173; + goto yy93; } } - yy193: + yy172: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy195; + goto yy174; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy194: + yy173: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy197; - goto yy120; + goto yy176; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy196; - goto yy107; + goto yy175; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy196; + goto yy93; + goto yy175; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy196; - goto yy107; + goto yy175; + goto yy93; } } - yy195: + yy174: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy197; + goto yy176; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy196: + yy175: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy199; - goto yy120; + goto yy178; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy198; - goto yy107; + goto yy177; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy198; + goto yy93; + goto yy177; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy198; - goto yy107; + goto yy177; + goto yy93; } } - yy197: + yy176: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy199; + goto yy178; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy198: + yy177: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy201; - goto yy120; + goto yy180; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy200; - goto yy107; + goto yy179; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy200; + goto yy93; + goto yy179; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy200; - goto yy107; + goto yy179; + goto yy93; } } - yy199: + yy178: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy201; + goto yy180; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy200: + yy179: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy203; - goto yy120; + goto yy182; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy202; - goto yy107; + goto yy181; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy202; + goto yy93; + goto yy181; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy202; - goto yy107; + goto yy181; + goto yy93; } } - yy201: + yy180: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy203; + goto yy182; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy202: + yy181: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy205; - goto yy120; + goto yy184; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy204; - goto yy107; + goto yy183; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy204; + goto yy93; + goto yy183; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy204; - goto yy107; + goto yy183; + goto yy93; } } - yy203: + yy182: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy205; + goto yy184; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy204: + yy183: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy207; - goto yy120; + goto yy186; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy206; - goto yy107; + goto yy185; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy206; + goto yy93; + goto yy185; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy206; - goto yy107; + goto yy185; + goto yy93; } } - yy205: + yy184: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy207; + goto yy186; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy206: + yy185: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy209; - goto yy120; + goto yy188; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy208; - goto yy107; + goto yy187; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy208; + goto yy93; + goto yy187; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy208; - goto yy107; + goto yy187; + goto yy93; } } - yy207: + yy186: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy209; + goto yy188; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy208: + yy187: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy211; - goto yy120; + goto yy190; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy210; - goto yy107; + goto yy189; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy210; + goto yy93; + goto yy189; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy210; - goto yy107; + goto yy189; + goto yy93; } } - yy209: + yy188: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy211; + goto yy190; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy210: + yy189: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy213; - goto yy120; + goto yy192; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy212; - goto yy107; + goto yy191; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy212; + goto yy93; + goto yy191; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy212; - goto yy107; + goto yy191; + goto yy93; } } - yy211: + yy190: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy213; + goto yy192; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy212: + yy191: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy215; - goto yy120; + goto yy194; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy214; - goto yy107; + goto yy193; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy214; + goto yy93; + goto yy193; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy214; - goto yy107; + goto yy193; + goto yy93; } } - yy213: + yy192: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy215; + goto yy194; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy214: + yy193: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy217; - goto yy120; + goto yy196; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy216; - goto yy107; + goto yy195; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy216; + goto yy93; + goto yy195; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy216; - goto yy107; + goto yy195; + goto yy93; } } - yy215: + yy194: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy217; + goto yy196; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy216: + yy195: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy219; - goto yy120; + goto yy198; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy218; - goto yy107; + goto yy197; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy218; + goto yy93; + goto yy197; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy218; - goto yy107; + goto yy197; + goto yy93; } } - yy217: + yy196: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy219; + goto yy198; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy218: + yy197: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy221; - goto yy120; + goto yy200; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy220; - goto yy107; + goto yy199; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy220; + goto yy93; + goto yy199; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy220; - goto yy107; + goto yy199; + goto yy93; } } - yy219: + yy198: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy221; + goto yy200; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy220: + yy199: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy223; - goto yy120; + goto yy202; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy222; - goto yy107; + goto yy201; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy222; + goto yy93; + goto yy201; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy222; - goto yy107; + goto yy201; + goto yy93; } } - yy221: + yy200: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy223; + goto yy202; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy222: + yy201: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy225; - goto yy120; + goto yy204; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy224; - goto yy107; + goto yy203; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy224; + goto yy93; + goto yy203; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy224; - goto yy107; + goto yy203; + goto yy93; } } - yy223: + yy202: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy225; + goto yy204; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy224: + yy203: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy227; - goto yy120; + goto yy206; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy226; - goto yy107; + goto yy205; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy226; + goto yy93; + goto yy205; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy226; - goto yy107; + goto yy205; + goto yy93; } } - yy225: + yy204: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy227; + goto yy206; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy226: + yy205: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy229; - goto yy120; + goto yy208; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy228; - goto yy107; + goto yy207; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy228; + goto yy93; + goto yy207; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy228; - goto yy107; + goto yy207; + goto yy93; } } - yy227: + yy206: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy229; + goto yy208; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy228: + yy207: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy231; - goto yy120; + goto yy210; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy230; - goto yy107; + goto yy209; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy230; + goto yy93; + goto yy209; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy230; - goto yy107; + goto yy209; + goto yy93; } } - yy229: + yy208: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy231; + goto yy210; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy230: + yy209: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy233; - goto yy120; + goto yy212; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy232; - goto yy107; + goto yy211; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy232; + goto yy93; + goto yy211; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy232; - goto yy107; + goto yy211; + goto yy93; } } - yy231: + yy210: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy233; + goto yy212; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy232: + yy211: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy235; - goto yy120; + goto yy214; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy234; - goto yy107; + goto yy213; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy234; + goto yy93; + goto yy213; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy234; - goto yy107; + goto yy213; + goto yy93; } } - yy233: + yy212: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy235; + goto yy214; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy234: + yy213: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy237; - goto yy120; + goto yy216; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy236; - goto yy107; + goto yy215; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy236; + goto yy93; + goto yy215; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy236; - goto yy107; + goto yy215; + goto yy93; } } - yy235: + yy214: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy237; + goto yy216; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy236: + yy215: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy239; - goto yy120; + goto yy218; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy238; - goto yy107; + goto yy217; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy238; + goto yy93; + goto yy217; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy238; - goto yy107; + goto yy217; + goto yy93; } } - yy237: + yy216: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy239; + goto yy218; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy238: + yy217: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy241; - goto yy120; + goto yy220; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy240; - goto yy107; + goto yy219; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy240; + goto yy93; + goto yy219; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy240; - goto yy107; + goto yy219; + goto yy93; } } - yy239: + yy218: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy241; + goto yy220; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy240: + yy219: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy243; - goto yy120; + goto yy222; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy242; - goto yy107; + goto yy221; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy242; + goto yy93; + goto yy221; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy242; - goto yy107; + goto yy221; + goto yy93; } } - yy241: + yy220: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy243; + goto yy222; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy242: + yy221: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy245; - goto yy120; + goto yy224; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy244; - goto yy107; + goto yy223; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy244; + goto yy93; + goto yy223; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy244; - goto yy107; + goto yy223; + goto yy93; } } - yy243: + yy222: ++p; yych = *p; if (yych <= '9') { if (yych == '-') - goto yy245; + goto yy224; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy244: + yy223: ++p; yych = *p; if (yych <= '=') { if (yych <= '.') { if (yych <= '-') - goto yy107; - goto yy120; + goto yy93; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy246; - goto yy107; + goto yy225; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy246; + goto yy93; + goto yy225; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy246; - goto yy107; + goto yy225; + goto yy93; } } - yy245: + yy224: ++p; yych = *p; if (yych <= '@') { if (yych <= '/') - goto yy107; + goto yy93; if (yych >= ':') - goto yy107; + goto yy93; } else { if (yych <= 'Z') - goto yy246; + goto yy225; if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } - yy246: + yy225: ++p; yych = *p; if (yych == '.') - goto yy120; + goto yy99; if (yych == '>') - goto yy121; - goto yy107; - yy247: + goto yy100; + goto yy93; + yy226: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy250; - goto yy120; + goto yy229; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy249; - goto yy107; + goto yy228; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy249; + goto yy93; + goto yy228; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy249; - goto yy107; + goto yy228; + goto yy93; } } - yy248: + yy227: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy250; + goto yy229; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy249: + yy228: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy252; - goto yy120; + goto yy231; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy251; - goto yy107; + goto yy230; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy251; + goto yy93; + goto yy230; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy251; - goto yy107; + goto yy230; + goto yy93; } } - yy250: + yy229: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy252; + goto yy231; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy251: + yy230: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy254; - goto yy120; + goto yy233; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy253; - goto yy107; + goto yy232; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy253; + goto yy93; + goto yy232; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy253; - goto yy107; + goto yy232; + goto yy93; } } - yy252: + yy231: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy254; + goto yy233; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy253: + yy232: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy256; - goto yy120; + goto yy235; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy255; - goto yy107; + goto yy234; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy255; + goto yy93; + goto yy234; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy255; - goto yy107; + goto yy234; + goto yy93; } } - yy254: + yy233: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy256; + goto yy235; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy255: + yy234: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy258; - goto yy120; + goto yy237; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy257; - goto yy107; + goto yy236; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy257; + goto yy93; + goto yy236; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy257; - goto yy107; + goto yy236; + goto yy93; } } - yy256: + yy235: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy258; + goto yy237; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy257: + yy236: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy260; - goto yy120; + goto yy239; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy259; - goto yy107; + goto yy238; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy259; + goto yy93; + goto yy238; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy259; - goto yy107; + goto yy238; + goto yy93; } } - yy258: + yy237: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy260; + goto yy239; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy259: + yy238: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy262; - goto yy120; + goto yy241; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy261; - goto yy107; + goto yy240; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy261; + goto yy93; + goto yy240; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy261; - goto yy107; + goto yy240; + goto yy93; } } - yy260: + yy239: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy262; + goto yy241; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy261: + yy240: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy264; - goto yy120; + goto yy243; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy263; - goto yy107; + goto yy242; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy263; + goto yy93; + goto yy242; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy263; - goto yy107; + goto yy242; + goto yy93; } } - yy262: + yy241: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy264; + goto yy243; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy263: + yy242: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy266; - goto yy120; + goto yy245; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy265; - goto yy107; + goto yy244; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy265; + goto yy93; + goto yy244; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy265; - goto yy107; + goto yy244; + goto yy93; } } - yy264: + yy243: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy266; + goto yy245; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy265: + yy244: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy268; - goto yy120; + goto yy247; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy267; - goto yy107; + goto yy246; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy267; + goto yy93; + goto yy246; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy267; - goto yy107; + goto yy246; + goto yy93; } } - yy266: + yy245: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy268; + goto yy247; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy267: + yy246: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy270; - goto yy120; + goto yy249; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy269; - goto yy107; + goto yy248; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy269; + goto yy93; + goto yy248; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy269; - goto yy107; + goto yy248; + goto yy93; } } - yy268: + yy247: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy270; + goto yy249; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy269: + yy248: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy272; - goto yy120; + goto yy251; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy271; - goto yy107; + goto yy250; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy271; + goto yy93; + goto yy250; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy271; - goto yy107; + goto yy250; + goto yy93; } } - yy270: + yy249: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy272; + goto yy251; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy271: + yy250: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy274; - goto yy120; + goto yy253; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy273; - goto yy107; + goto yy252; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy273; + goto yy93; + goto yy252; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy273; - goto yy107; + goto yy252; + goto yy93; } } - yy272: + yy251: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy274; + goto yy253; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy273: + yy252: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy276; - goto yy120; + goto yy255; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy275; - goto yy107; + goto yy254; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy275; + goto yy93; + goto yy254; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy275; - goto yy107; + goto yy254; + goto yy93; } } - yy274: + yy253: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy276; + goto yy255; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy275: + yy254: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy278; - goto yy120; + goto yy257; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy277; - goto yy107; + goto yy256; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy277; + goto yy93; + goto yy256; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy277; - goto yy107; + goto yy256; + goto yy93; } } - yy276: + yy255: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy278; + goto yy257; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy277: + yy256: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy280; - goto yy120; + goto yy259; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy279; - goto yy107; + goto yy258; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy279; + goto yy93; + goto yy258; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy279; - goto yy107; + goto yy258; + goto yy93; } } - yy278: + yy257: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy280; + goto yy259; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy279: + yy258: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy282; - goto yy120; + goto yy261; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy281; - goto yy107; + goto yy260; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy281; + goto yy93; + goto yy260; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy281; - goto yy107; + goto yy260; + goto yy93; } } - yy280: + yy259: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy282; + goto yy261; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy281: + yy260: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy284; - goto yy120; + goto yy263; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy283; - goto yy107; + goto yy262; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy283; + goto yy93; + goto yy262; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy283; - goto yy107; + goto yy262; + goto yy93; } } - yy282: + yy261: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy284; + goto yy263; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy283: + yy262: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy286; - goto yy120; + goto yy265; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy285; - goto yy107; + goto yy264; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy285; + goto yy93; + goto yy264; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy285; - goto yy107; + goto yy264; + goto yy93; } } - yy284: + yy263: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy286; + goto yy265; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy285: + yy264: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy288; - goto yy120; + goto yy267; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy287; - goto yy107; + goto yy266; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy287; + goto yy93; + goto yy266; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy287; - goto yy107; + goto yy266; + goto yy93; } } - yy286: + yy265: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy288; + goto yy267; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy287: + yy266: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy290; - goto yy120; + goto yy269; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy289; - goto yy107; + goto yy268; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy289; + goto yy93; + goto yy268; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy289; - goto yy107; + goto yy268; + goto yy93; } } - yy288: + yy267: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy290; + goto yy269; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy289: + yy268: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy292; - goto yy120; + goto yy271; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy291; - goto yy107; + goto yy270; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy291; + goto yy93; + goto yy270; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy291; - goto yy107; + goto yy270; + goto yy93; } } - yy290: + yy269: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy292; + goto yy271; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy291: + yy270: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy294; - goto yy120; + goto yy273; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy293; - goto yy107; + goto yy272; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy293; + goto yy93; + goto yy272; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy293; - goto yy107; + goto yy272; + goto yy93; } } - yy292: + yy271: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy294; + goto yy273; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy293: + yy272: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy296; - goto yy120; + goto yy275; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy295; - goto yy107; + goto yy274; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy295; + goto yy93; + goto yy274; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy295; - goto yy107; + goto yy274; + goto yy93; } } - yy294: + yy273: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy296; + goto yy275; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy295: + yy274: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy298; - goto yy120; + goto yy277; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy297; - goto yy107; + goto yy276; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy297; + goto yy93; + goto yy276; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy297; - goto yy107; + goto yy276; + goto yy93; } } - yy296: + yy275: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy298; + goto yy277; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy297: + yy276: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy300; - goto yy120; + goto yy279; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy299; - goto yy107; + goto yy278; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy299; + goto yy93; + goto yy278; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy299; - goto yy107; + goto yy278; + goto yy93; } } - yy298: + yy277: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy300; + goto yy279; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy299: + yy278: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy302; - goto yy120; + goto yy281; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy301; - goto yy107; + goto yy280; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy301; + goto yy93; + goto yy280; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy301; - goto yy107; + goto yy280; + goto yy93; } } - yy300: + yy279: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy302; + goto yy281; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy301: + yy280: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy304; - goto yy120; + goto yy283; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy303; - goto yy107; + goto yy282; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy303; + goto yy93; + goto yy282; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy303; - goto yy107; + goto yy282; + goto yy93; } } - yy302: + yy281: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy304; + goto yy283; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy303: + yy282: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy306; - goto yy120; + goto yy285; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy305; - goto yy107; + goto yy284; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy305; + goto yy93; + goto yy284; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy305; - goto yy107; + goto yy284; + goto yy93; } } - yy304: + yy283: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy306; + goto yy285; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy305: + yy284: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy308; - goto yy120; + goto yy287; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy307; - goto yy107; + goto yy286; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy307; + goto yy93; + goto yy286; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy307; - goto yy107; + goto yy286; + goto yy93; } } - yy306: + yy285: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy308; + goto yy287; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy307: + yy286: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy310; - goto yy120; + goto yy289; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy309; - goto yy107; + goto yy288; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy309; + goto yy93; + goto yy288; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy309; - goto yy107; + goto yy288; + goto yy93; } } - yy308: + yy287: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy310; + goto yy289; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy309: + yy288: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy312; - goto yy120; + goto yy291; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy311; - goto yy107; + goto yy290; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy311; + goto yy93; + goto yy290; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy311; - goto yy107; + goto yy290; + goto yy93; } } - yy310: + yy289: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy312; + goto yy291; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy311: + yy290: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy314; - goto yy120; + goto yy293; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy313; - goto yy107; + goto yy292; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy313; + goto yy93; + goto yy292; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy313; - goto yy107; + goto yy292; + goto yy93; } } - yy312: + yy291: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy314; + goto yy293; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy313: + yy292: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy316; - goto yy120; + goto yy295; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy315; - goto yy107; + goto yy294; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy315; + goto yy93; + goto yy294; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy315; - goto yy107; + goto yy294; + goto yy93; } } - yy314: + yy293: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy316; + goto yy295; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy315: + yy294: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy318; - goto yy120; + goto yy297; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy317; - goto yy107; + goto yy296; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy317; + goto yy93; + goto yy296; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy317; - goto yy107; + goto yy296; + goto yy93; } } - yy316: + yy295: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy318; + goto yy297; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy317: + yy296: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy320; - goto yy120; + goto yy299; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy319; - goto yy107; + goto yy298; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy319; + goto yy93; + goto yy298; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy319; - goto yy107; + goto yy298; + goto yy93; } } - yy318: + yy297: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy320; + goto yy299; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy319: + yy298: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy322; - goto yy120; + goto yy301; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy321; - goto yy107; + goto yy300; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy321; + goto yy93; + goto yy300; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy321; - goto yy107; + goto yy300; + goto yy93; } } - yy320: + yy299: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy322; + goto yy301; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy321: + yy300: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy324; - goto yy120; + goto yy303; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy323; - goto yy107; + goto yy302; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy323; + goto yy93; + goto yy302; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy323; - goto yy107; + goto yy302; + goto yy93; } } - yy322: + yy301: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy324; + goto yy303; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy323: + yy302: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy326; - goto yy120; + goto yy305; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy325; - goto yy107; + goto yy304; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy325; + goto yy93; + goto yy304; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy325; - goto yy107; + goto yy304; + goto yy93; } } - yy324: + yy303: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy326; + goto yy305; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy325: + yy304: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy328; - goto yy120; + goto yy307; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy327; - goto yy107; + goto yy306; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy327; + goto yy93; + goto yy306; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy327; - goto yy107; + goto yy306; + goto yy93; } } - yy326: + yy305: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy328; + goto yy307; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy327: + yy306: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy330; - goto yy120; + goto yy309; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy329; - goto yy107; + goto yy308; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy329; + goto yy93; + goto yy308; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy329; - goto yy107; + goto yy308; + goto yy93; } } - yy328: + yy307: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy330; + goto yy309; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy329: + yy308: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy332; - goto yy120; + goto yy311; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy331; - goto yy107; + goto yy310; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy331; + goto yy93; + goto yy310; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy331; - goto yy107; + goto yy310; + goto yy93; } } - yy330: + yy309: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy332; + goto yy311; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy331: + yy310: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy334; - goto yy120; + goto yy313; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy333; - goto yy107; + goto yy312; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy333; + goto yy93; + goto yy312; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy333; - goto yy107; + goto yy312; + goto yy93; } } - yy332: + yy311: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy334; + goto yy313; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy333: + yy312: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy336; - goto yy120; + goto yy315; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy335; - goto yy107; + goto yy314; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy335; + goto yy93; + goto yy314; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy335; - goto yy107; + goto yy314; + goto yy93; } } - yy334: + yy313: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy336; + goto yy315; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy335: + yy314: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy338; - goto yy120; + goto yy317; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy337; - goto yy107; + goto yy316; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy337; + goto yy93; + goto yy316; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy337; - goto yy107; + goto yy316; + goto yy93; } } - yy336: + yy315: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy338; + goto yy317; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy337: + yy316: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy340; - goto yy120; + goto yy319; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy339; - goto yy107; + goto yy318; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy339; + goto yy93; + goto yy318; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy339; - goto yy107; + goto yy318; + goto yy93; } } - yy338: + yy317: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy340; + goto yy319; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy339: + yy318: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy342; - goto yy120; + goto yy321; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy341; - goto yy107; + goto yy320; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy341; + goto yy93; + goto yy320; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy341; - goto yy107; + goto yy320; + goto yy93; } } - yy340: + yy319: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy342; + goto yy321; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy341: + yy320: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy344; - goto yy120; + goto yy323; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy343; - goto yy107; + goto yy322; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy343; + goto yy93; + goto yy322; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy343; - goto yy107; + goto yy322; + goto yy93; } } - yy342: + yy321: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy344; + goto yy323; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy343: + yy322: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy346; - goto yy120; + goto yy325; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy345; - goto yy107; + goto yy324; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy345; + goto yy93; + goto yy324; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy345; - goto yy107; + goto yy324; + goto yy93; } } - yy344: + yy323: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy346; + goto yy325; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy345: + yy324: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy348; - goto yy120; + goto yy327; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy347; - goto yy107; + goto yy326; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy347; + goto yy93; + goto yy326; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy347; - goto yy107; + goto yy326; + goto yy93; } } - yy346: + yy325: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy348; + goto yy327; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy347: + yy326: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy350; - goto yy120; + goto yy329; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy349; - goto yy107; + goto yy328; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy349; + goto yy93; + goto yy328; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy349; - goto yy107; + goto yy328; + goto yy93; } } - yy348: + yy327: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy350; + goto yy329; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy349: + yy328: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy352; - goto yy120; + goto yy331; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy351; - goto yy107; + goto yy330; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy351; + goto yy93; + goto yy330; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy351; - goto yy107; + goto yy330; + goto yy93; } } - yy350: + yy329: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy352; + goto yy331; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy351: + yy330: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy354; - goto yy120; + goto yy333; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy353; - goto yy107; + goto yy332; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy353; + goto yy93; + goto yy332; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy353; - goto yy107; + goto yy332; + goto yy93; } } - yy352: + yy331: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy354; + goto yy333; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy353: + yy332: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy356; - goto yy120; + goto yy335; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy355; - goto yy107; + goto yy334; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy355; + goto yy93; + goto yy334; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy355; - goto yy107; + goto yy334; + goto yy93; } } - yy354: + yy333: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy356; + goto yy335; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy355: + yy334: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy358; - goto yy120; + goto yy337; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy357; - goto yy107; + goto yy336; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy357; + goto yy93; + goto yy336; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy357; - goto yy107; + goto yy336; + goto yy93; } } - yy356: + yy335: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy358; + goto yy337; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy357: + yy336: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy360; - goto yy120; + goto yy339; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy359; - goto yy107; + goto yy338; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy359; + goto yy93; + goto yy338; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy359; - goto yy107; + goto yy338; + goto yy93; } } - yy358: + yy337: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy360; + goto yy339; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy359: + yy338: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy362; - goto yy120; + goto yy341; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy361; - goto yy107; + goto yy340; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy361; + goto yy93; + goto yy340; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy361; - goto yy107; + goto yy340; + goto yy93; } } - yy360: + yy339: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy362; + goto yy341; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy361: + yy340: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy364; - goto yy120; + goto yy343; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy363; - goto yy107; + goto yy342; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy363; + goto yy93; + goto yy342; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy363; - goto yy107; + goto yy342; + goto yy93; } } - yy362: + yy341: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy364; + goto yy343; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy363: + yy342: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= ',') - goto yy107; + goto yy93; if (yych <= '-') - goto yy366; - goto yy120; + goto yy345; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy365; - goto yy107; + goto yy344; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy365; + goto yy93; + goto yy344; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy365; - goto yy107; + goto yy344; + goto yy93; } } - yy364: + yy343: yych = *++p; if (yych <= '9') { if (yych == '-') - goto yy366; + goto yy345; if (yych <= '/') - goto yy107; + goto yy93; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy107; + goto yy93; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych >= '{') - goto yy107; + goto yy93; } } - yy365: + yy344: yych = *++p; if (yych <= '=') { if (yych <= '.') { if (yych <= '-') - goto yy107; - goto yy120; + goto yy93; + goto yy99; } else { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy246; - goto yy107; + goto yy225; + goto yy93; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy121; + goto yy100; if (yych <= '@') - goto yy107; - goto yy246; + goto yy93; + goto yy225; } else { if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy246; - goto yy107; + goto yy225; + goto yy93; } } - yy366: + yy345: ++p; if ((yych = *p) <= '@') { if (yych <= '/') - goto yy107; + goto yy93; if (yych <= '9') - goto yy246; - goto yy107; + goto yy225; + goto yy93; } else { if (yych <= 'Z') - goto yy246; + goto yy225; if (yych <= '`') - goto yy107; + goto yy93; if (yych <= 'z') - goto yy246; - goto yy107; + goto yy225; + goto yy93; } } } @@ -8258,16 +7887,16 @@ bufsize_t _scan_html_tag(const unsigned char *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, 254, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 239, 239, 239, 239, 239, 239, 239, 239, 238, 238, 238, 238, 238, + 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, + 239, 239, 239, 239, 238, 239, 234, 239, 239, 239, 239, 236, 239, 239, + 239, 239, 239, 207, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, + 239, 239, 239, 239, 238, 238, 174, 231, 239, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 239, 239, 111, 239, 239, 238, 239, + 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, + 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, + 239, 239, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -8278,16 +7907,16 @@ bufsize_t _scan_html_tag(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 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, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, + 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, 160, 128, 0, 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 128, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 128, 0, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -8298,1919 +7927,1830 @@ bufsize_t _scan_html_tag(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - yych = *(marker = p); - if (yych <= '`') { - if (yych <= '.') { - if (yych <= '\n') { - if (yych <= '\t') - goto yy374; - } else { - if (yych == '!') - goto yy372; - goto yy374; - } - } else { - if (yych <= '?') { - if (yych <= '/') - goto yy371; - if (yych <= '>') - goto yy374; - goto yy373; - } else { - if (yych <= '@') - goto yy374; - if (yych <= 'Z') - goto yy370; - goto yy374; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 'z') - goto yy370; - if (yych <= 0x7F) - goto yy374; - } else { - if (yych <= 0xDF) - goto yy375; - if (yych <= 0xE0) - goto yy377; - goto yy378; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy382; - if (yych <= 0xEF) - goto yy378; - goto yy379; - } else { - if (yych <= 0xF3) - goto yy380; - if (yych <= 0xF4) - goto yy381; - } - } - } - yy369 : { return 0; } - yy370: - yych = *(marker = ++p); - if (yych <= '/') { - if (yych <= ' ') { - if (yych <= 0x08) - goto yy369; - if (yych <= '\r') - goto yy474; - if (yych <= 0x1F) - goto yy369; - goto yy474; + yych = *p; + if (yych <= '>') { + if (yych <= '!') { + if (yych >= '!') + goto yy350; } else { - if (yych == '-') - goto yy472; - if (yych <= '.') - goto yy369; - goto yy476; + if (yych == '/') + goto yy351; } } else { - if (yych <= '@') { - if (yych <= '9') - goto yy472; - if (yych == '>') - goto yy393; - goto yy369; + if (yych <= 'Z') { + if (yych <= '?') + goto yy352; + if (yych >= 'A') + goto yy353; } else { - if (yych <= 'Z') - goto yy472; if (yych <= '`') - goto yy369; + goto yy348; if (yych <= 'z') - goto yy472; - goto yy369; + goto yy353; } } - yy371: - yych = *(marker = ++p); - if (yych <= '@') - goto yy369; - if (yych <= 'Z') - goto yy468; - if (yych <= '`') - goto yy369; - if (yych <= 'z') - goto yy468; - goto yy369; - yy372: + yy348: + ++p; + yy349 : { return 0; } + yy350: yych = *(marker = ++p); - if (yybm[256 + yych] & 64) { - goto yy403; + if (yybm[0 + yych] & 16) { + goto yy426; } if (yych == '-') - goto yy405; + goto yy428; if (yych <= '@') - goto yy369; + goto yy349; if (yych <= '[') - goto yy402; - goto yy369; - yy373: + goto yy425; + goto yy349; + yy351: + yych = *(marker = ++p); + if (yych <= '@') + goto yy349; + if (yych <= 'Z') + goto yy421; + if (yych <= '`') + goto yy349; + if (yych <= 'z') + goto yy421; + goto yy349; + yy352: yych = *(marker = ++p); if (yych <= 0x00) - goto yy369; + goto yy349; if (yych <= 0x7F) - goto yy384; + goto yy405; if (yych <= 0xC1) - goto yy369; + goto yy349; if (yych <= 0xF4) - goto yy384; - goto yy369; - yy374: - yych = *++p; - goto yy369; - yy375: - yych = *++p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy374; - yy376: - p = marker; - goto yy369; - yy377: - yych = *++p; - if (yych <= 0x9F) - goto yy376; - if (yych <= 0xBF) - goto yy375; - goto yy376; - yy378: - yych = *++p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy375; - goto yy376; - yy379: - yych = *++p; - if (yych <= 0x8F) - goto yy376; - if (yych <= 0xBF) - goto yy378; - goto yy376; - yy380: - yych = *++p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy378; - goto yy376; - yy381: - yych = *++p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0x8F) - goto yy378; - goto yy376; - yy382: - yych = *++p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0x9F) - goto yy375; - goto yy376; - yy383: - ++p; - yych = *p; - yy384: - if (yybm[256 + yych] & 32) { - goto yy383; + goto yy405; + goto yy349; + yy353: + yych = *(marker = ++p); + if (yybm[256 + yych] & 64) { + goto yy357; } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) - goto yy376; - if (yych <= '?') - goto yy392; - goto yy376; + if (yych <= '=') { + if (yych <= '.') { + if (yych != '-') + goto yy349; } else { - if (yych <= 0xDF) - goto yy385; - if (yych <= 0xE0) - goto yy386; - goto yy387; + if (yych <= '/') + goto yy359; + if (yych >= ':') + goto yy349; } } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy391; - if (yych <= 0xEF) - goto yy387; - goto yy388; + if (yych <= 'Z') { + if (yych <= '>') + goto yy360; + if (yych <= '@') + goto yy349; } else { - if (yych <= 0xF3) - goto yy389; - if (yych <= 0xF4) - goto yy390; - goto yy376; + if (yych <= '`') + goto yy349; + if (yych >= '{') + goto yy349; } } - yy385: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy383; - goto yy376; - yy386: + yy354: ++p; yych = *p; - if (yych <= 0x9F) - goto yy376; - if (yych <= 0xBF) - goto yy385; - goto yy376; - yy387: + if (yybm[256 + yych] & 64) { + goto yy357; + } + if (yych <= '=') { + if (yych <= '.') { + if (yych == '-') + goto yy354; + } else { + if (yych <= '/') + goto yy359; + if (yych <= '9') + goto yy354; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy360; + if (yych >= 'A') + goto yy354; + } else { + if (yych <= '`') + goto yy356; + if (yych <= 'z') + goto yy354; + } + } + yy356: + p = marker; + goto yy349; + yy357: ++p; yych = *p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy385; - goto yy376; - yy388: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy376; - if (yych <= 0xBF) - goto yy387; - goto yy376; - yy389: + if (yybm[256 + yych] & 64) { + goto yy357; + } + if (yych <= '>') { + if (yych <= '9') { + if (yych != '/') + goto yy356; + } else { + if (yych <= ':') + goto yy362; + if (yych <= '=') + goto yy356; + goto yy360; + } + } else { + if (yych <= '^') { + if (yych <= '@') + goto yy356; + if (yych <= 'Z') + goto yy362; + goto yy356; + } else { + if (yych == '`') + goto yy356; + if (yych <= 'z') + goto yy362; + goto yy356; + } + } + yy359: + yych = *++p; + if (yych != '>') + goto yy356; + yy360: ++p; - yych = *p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy387; - goto yy376; - yy390: + { return (bufsize_t)(p - start); } + yy362: ++p; yych = *p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0x8F) - goto yy387; - goto yy376; - yy391: + if (yybm[256 + yych] & 128) { + goto yy362; + } + if (yych <= ',') { + if (yych <= '\r') { + if (yych <= 0x08) + goto yy356; + } else { + if (yych != ' ') + goto yy356; + } + } else { + if (yych <= '<') { + if (yych <= '/') + goto yy359; + goto yy356; + } else { + if (yych <= '=') + goto yy366; + if (yych <= '>') + goto yy360; + goto yy356; + } + } + yy364: ++p; yych = *p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0x9F) - goto yy385; - goto yy376; - yy392: + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy356; + if (yych <= '\r') + goto yy364; + if (yych <= 0x1F) + goto yy356; + goto yy364; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy356; + goto yy359; + } else { + if (yych == ':') + goto yy362; + goto yy356; + } + } + } else { + if (yych <= 'Z') { + if (yych <= '=') + goto yy366; + if (yych <= '>') + goto yy360; + if (yych <= '@') + goto yy356; + goto yy362; + } else { + if (yych <= '_') { + if (yych <= '^') + goto yy356; + goto yy362; + } else { + if (yych <= '`') + goto yy356; + if (yych <= 'z') + goto yy362; + goto yy356; + } + } + } + yy366: ++p; yych = *p; + if (yybm[0 + yych] & 1) { + goto yy368; + } if (yych <= 0xE0) { - if (yych <= '>') { + if (yych <= '"') { if (yych <= 0x00) - goto yy376; - if (yych <= '=') - goto yy383; + goto yy356; + if (yych >= '!') + goto yy379; } else { - if (yych <= 0x7F) - goto yy383; + if (yych <= '\'') + goto yy377; if (yych <= 0xC1) - goto yy376; + goto yy356; if (yych <= 0xDF) - goto yy395; - goto yy396; + goto yy370; + goto yy371; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy401; - goto yy397; + goto yy376; + goto yy372; } else { if (yych <= 0xF0) - goto yy398; + goto yy373; + if (yych <= 0xF3) + goto yy374; + if (yych <= 0xF4) + goto yy375; + goto yy356; + } + } + ++p; + yych = *p; + if (yybm[0 + yych] & 1) { + goto yy368; + } + if (yych <= 0xDF) { + if (yych <= '\'') { + if (yych <= 0x00) + goto yy356; + if (yych <= ' ') + goto yy402; + if (yych <= '"') + goto yy379; + goto yy377; + } else { + if (yych == '>') + goto yy360; + if (yych <= 0xC1) + goto yy356; + goto yy370; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy371; + if (yych == 0xED) + goto yy376; + goto yy372; + } else { + if (yych <= 0xF0) + goto yy373; if (yych <= 0xF3) - goto yy399; + goto yy374; if (yych <= 0xF4) - goto yy400; - goto yy376; + goto yy375; + goto yy356; } } - yy393: + yy368: ++p; - { return (bufsize_t)(p - start); } - yy395: + yych = *p; + if (yybm[0 + yych] & 1) { + goto yy368; + } + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy356; + if (yych <= ' ') + goto yy396; + goto yy356; + } else { + if (yych <= '>') + goto yy360; + if (yych <= 0xC1) + goto yy356; + if (yych >= 0xE0) + goto yy371; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy376; + goto yy372; + } else { + if (yych <= 0xF0) + goto yy373; + if (yych <= 0xF3) + goto yy374; + if (yych <= 0xF4) + goto yy375; + goto yy356; + } + } + yy370: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy383; - goto yy376; - yy396: + goto yy368; + goto yy356; + yy371: ++p; yych = *p; if (yych <= 0x9F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy395; - goto yy376; - yy397: + goto yy370; + goto yy356; + yy372: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy395; - goto yy376; - yy398: + goto yy370; + goto yy356; + yy373: ++p; yych = *p; if (yych <= 0x8F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy397; - goto yy376; - yy399: + goto yy372; + goto yy356; + yy374: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy397; - goto yy376; - yy400: + goto yy372; + goto yy356; + yy375: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x8F) - goto yy397; - goto yy376; - yy401: + goto yy372; + goto yy356; + yy376: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x9F) - goto yy395; - goto yy376; - yy402: - yych = *++p; - if (yych == 'C') - goto yy438; - if (yych == 'c') - goto yy438; - goto yy376; - yy403: + goto yy370; + goto yy356; + yy377: ++p; yych = *p; - if (yybm[0 + yych] & 1) { - goto yy427; + if (yybm[0 + yych] & 2) { + goto yy377; } - if (yych <= '@') - goto yy376; - if (yych <= 'Z') - goto yy403; - goto yy376; - yy405: - yych = *++p; - if (yych != '-') - goto yy376; - yych = *++p; - if (yych <= 0xE0) { - if (yych <= '=') { - if (yych != '-') - goto yy409; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy356; + if (yych <= '\'') + goto yy388; + goto yy356; } else { - if (yych <= '>') - goto yy376; - if (yych <= 0xC1) - goto yy409; if (yych <= 0xDF) - goto yy410; - goto yy411; + goto yy389; + if (yych <= 0xE0) + goto yy390; + goto yy391; } } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy416; - goto yy412; + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy395; + if (yych <= 0xEF) + goto yy391; + goto yy392; } else { - if (yych <= 0xF0) - goto yy413; if (yych <= 0xF3) - goto yy414; + goto yy393; if (yych <= 0xF4) - goto yy415; - goto yy409; + goto yy394; + goto yy356; } } - yych = *++p; - if (yych <= 0xE0) { - if (yych <= '=') { - if (yych == '-') - goto yy426; - goto yy409; - } else { - if (yych <= '>') - goto yy376; - if (yych <= 0xC1) - goto yy409; - if (yych <= 0xDF) - goto yy410; - goto yy411; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy416; - goto yy412; - } else { - if (yych <= 0xF0) - goto yy413; - if (yych <= 0xF3) - goto yy414; - if (yych <= 0xF4) - goto yy415; - goto yy409; - } - } - yy408: - ++p; - yych = *p; - yy409: - if (yybm[256 + yych] & 128) { - goto yy408; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) - goto yy376; - if (yych <= '-') - goto yy417; - goto yy376; - } else { - if (yych <= 0xDF) - goto yy418; - if (yych <= 0xE0) - goto yy419; - goto yy420; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy424; - if (yych <= 0xEF) - goto yy420; - goto yy421; - } else { - if (yych <= 0xF3) - goto yy422; - if (yych <= 0xF4) - goto yy423; - goto yy376; - } - } - yy410: - yych = *++p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy408; - goto yy376; - yy411: - yych = *++p; - if (yych <= 0x9F) - goto yy376; - if (yych <= 0xBF) - goto yy410; - goto yy376; - yy412: - yych = *++p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy410; - goto yy376; - yy413: - yych = *++p; - if (yych <= 0x8F) - goto yy376; - if (yych <= 0xBF) - goto yy412; - goto yy376; - yy414: - yych = *++p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy412; - goto yy376; - yy415: - yych = *++p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0x8F) - goto yy412; - goto yy376; - yy416: - yych = *++p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0x9F) - goto yy410; - goto yy376; - yy417: + yy379: ++p; yych = *p; - if (yybm[256 + yych] & 128) { - goto yy408; + if (yybm[0 + yych] & 4) { + goto yy379; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy376; - if (yych <= '-') - goto yy425; - goto yy376; + goto yy356; + if (yych <= '"') + goto yy388; + goto yy356; } else { if (yych <= 0xDF) - goto yy418; + goto yy381; if (yych <= 0xE0) - goto yy419; - goto yy420; + goto yy382; + goto yy383; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy424; + goto yy387; if (yych <= 0xEF) - goto yy420; - goto yy421; + goto yy383; + goto yy384; } else { if (yych <= 0xF3) - goto yy422; + goto yy385; if (yych <= 0xF4) - goto yy423; - goto yy376; + goto yy386; + goto yy356; } } - yy418: + yy381: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy408; - goto yy376; - yy419: + goto yy379; + goto yy356; + yy382: ++p; yych = *p; if (yych <= 0x9F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy418; - goto yy376; - yy420: + goto yy381; + goto yy356; + yy383: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy418; - goto yy376; - yy421: + goto yy381; + goto yy356; + yy384: ++p; yych = *p; if (yych <= 0x8F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy420; - goto yy376; - yy422: + goto yy383; + goto yy356; + yy385: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy420; - goto yy376; - yy423: + goto yy383; + goto yy356; + yy386: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x8F) - goto yy420; - goto yy376; - yy424: + goto yy383; + goto yy356; + yy387: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x9F) - goto yy418; - goto yy376; - yy425: - yych = *++p; - if (yych == '>') - goto yy393; - goto yy376; - yy426: - yych = *++p; - if (yych == '>') - goto yy393; - goto yy376; - yy427: - ++p; - yych = *p; - if (yybm[0 + yych] & 1) { - goto yy427; - } - if (yych <= 0xE0) { - if (yych <= '>') { - if (yych <= 0x00) - goto yy376; - if (yych >= '>') - goto yy393; - } else { - if (yych <= 0x7F) - goto yy429; - if (yych <= 0xC1) - goto yy376; - if (yych <= 0xDF) - goto yy431; - goto yy432; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy437; - goto yy433; - } else { - if (yych <= 0xF0) - goto yy434; - if (yych <= 0xF3) - goto yy435; - if (yych <= 0xF4) - goto yy436; - goto yy376; - } - } - yy429: + goto yy381; + goto yy356; + yy388: ++p; yych = *p; - if (yybm[0 + yych] & 2) { - goto yy429; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) - goto yy376; - if (yych <= '>') - goto yy393; - goto yy376; - } else { - if (yych <= 0xDF) - goto yy431; - if (yych <= 0xE0) - goto yy432; - goto yy433; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy437; - if (yych <= 0xEF) - goto yy433; - goto yy434; - } else { - if (yych <= 0xF3) - goto yy435; - if (yych <= 0xF4) - goto yy436; - goto yy376; - } + if (yybm[256 + yych] & 64) { + goto yy357; } - yy431: + if (yych == '/') + goto yy359; + if (yych == '>') + goto yy360; + goto yy356; + yy389: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy429; - goto yy376; - yy432: + goto yy377; + goto yy356; + yy390: ++p; yych = *p; if (yych <= 0x9F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy431; - goto yy376; - yy433: + goto yy389; + goto yy356; + yy391: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy431; - goto yy376; - yy434: + goto yy389; + goto yy356; + yy392: ++p; yych = *p; if (yych <= 0x8F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy433; - goto yy376; - yy435: + goto yy391; + goto yy356; + yy393: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy433; - goto yy376; - yy436: + goto yy391; + goto yy356; + yy394: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x8F) - goto yy433; - goto yy376; - yy437: + goto yy391; + goto yy356; + yy395: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x9F) - goto yy431; - goto yy376; - yy438: - yych = *++p; - if (yych == 'D') - goto yy439; - if (yych != 'd') - goto yy376; - yy439: - yych = *++p; - if (yych == 'A') - goto yy440; - if (yych != 'a') - goto yy376; - yy440: - yych = *++p; - if (yych == 'T') - goto yy441; - if (yych != 't') - goto yy376; - yy441: - yych = *++p; - if (yych == 'A') - goto yy442; - if (yych != 'a') - goto yy376; - yy442: - yych = *++p; - if (yych != '[') - goto yy376; - yy443: + goto yy389; + goto yy356; + yy396: ++p; yych = *p; - if (yybm[0 + yych] & 4) { - goto yy443; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x00) - goto yy376; - if (yych <= ']') - goto yy452; - goto yy376; + if (yych <= '@') { + if (yych <= '"') { + if (yych <= '\r') { + if (yych <= 0x00) + goto yy356; + if (yych <= 0x08) + goto yy368; + goto yy396; + } else { + if (yych == ' ') + goto yy396; + if (yych <= '!') + goto yy368; + goto yy356; + } } else { - if (yych <= 0xDF) - goto yy445; - if (yych <= 0xE0) - goto yy446; - goto yy447; + if (yych <= ':') { + if (yych == '\'') + goto yy356; + if (yych <= '9') + goto yy368; + } else { + if (yych <= ';') + goto yy368; + if (yych <= '=') + goto yy356; + if (yych <= '>') + goto yy360; + goto yy368; + } } } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy451; - if (yych <= 0xEF) - goto yy447; - goto yy448; + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') + goto yy398; + if (yych <= '^') + goto yy368; + if (yych >= '`') + goto yy356; + } else { + if (yych <= 'z') + goto yy398; + if (yych <= 0x7F) + goto yy368; + if (yych <= 0xC1) + goto yy356; + goto yy370; + } } else { - if (yych <= 0xF3) - goto yy449; - if (yych <= 0xF4) - goto yy450; - goto yy376; + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy371; + if (yych == 0xED) + goto yy376; + goto yy372; + } else { + if (yych <= 0xF0) + goto yy373; + if (yych <= 0xF3) + goto yy374; + if (yych <= 0xF4) + goto yy375; + goto yy356; + } } } - yy445: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy443; - goto yy376; - yy446: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy376; - if (yych <= 0xBF) - goto yy445; - goto yy376; - yy447: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy445; - goto yy376; - yy448: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy376; - if (yych <= 0xBF) - goto yy447; - goto yy376; - yy449: + yy398: ++p; yych = *p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0xBF) - goto yy447; - goto yy376; - yy450: + if (yych <= '>') { + if (yych <= '&') { + if (yych <= 0x1F) { + if (yych <= 0x00) + goto yy356; + if (yych <= 0x08) + goto yy368; + if (yych >= 0x0E) + goto yy368; + } else { + if (yych <= ' ') + goto yy400; + if (yych == '"') + goto yy356; + goto yy368; + } + } else { + if (yych <= '/') { + if (yych <= '\'') + goto yy356; + if (yych <= ',') + goto yy368; + if (yych <= '.') + goto yy398; + goto yy368; + } else { + if (yych <= ';') { + if (yych <= ':') + goto yy398; + goto yy368; + } else { + if (yych <= '<') + goto yy356; + if (yych <= '=') + goto yy366; + goto yy360; + } + } + } + } else { + if (yych <= 0xC1) { + if (yych <= '_') { + if (yych <= '@') + goto yy368; + if (yych <= 'Z') + goto yy398; + if (yych <= '^') + goto yy368; + goto yy398; + } else { + if (yych <= '`') + goto yy356; + if (yych <= 'z') + goto yy398; + if (yych <= 0x7F) + goto yy368; + goto yy356; + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy370; + if (yych <= 0xE0) + goto yy371; + if (yych <= 0xEC) + goto yy372; + goto yy376; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy372; + goto yy373; + } else { + if (yych <= 0xF3) + goto yy374; + if (yych <= 0xF4) + goto yy375; + goto yy356; + } + } + } + } + yy400: ++p; yych = *p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0x8F) - goto yy447; - goto yy376; - yy451: + if (yych <= '@') { + if (yych <= '&') { + if (yych <= 0x1F) { + if (yych <= 0x00) + goto yy356; + if (yych <= 0x08) + goto yy368; + if (yych <= '\r') + goto yy400; + goto yy368; + } else { + if (yych <= ' ') + goto yy400; + if (yych == '"') + goto yy356; + goto yy368; + } + } else { + if (yych <= ';') { + if (yych <= '\'') + goto yy356; + if (yych == ':') + goto yy398; + goto yy368; + } else { + if (yych <= '<') + goto yy356; + if (yych <= '=') + goto yy366; + if (yych <= '>') + goto yy360; + goto yy368; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') + goto yy398; + if (yych <= '^') + goto yy368; + if (yych <= '_') + goto yy398; + goto yy356; + } else { + if (yych <= 'z') + goto yy398; + if (yych <= 0x7F) + goto yy368; + if (yych <= 0xC1) + goto yy356; + goto yy370; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy371; + if (yych == 0xED) + goto yy376; + goto yy372; + } else { + if (yych <= 0xF0) + goto yy373; + if (yych <= 0xF3) + goto yy374; + if (yych <= 0xF4) + goto yy375; + goto yy356; + } + } + } + yy402: ++p; yych = *p; - if (yych <= 0x7F) - goto yy376; - if (yych <= 0x9F) - goto yy445; - goto yy376; - yy452: + if (yych <= '@') { + if (yych <= '"') { + if (yych <= '\r') { + if (yych <= 0x00) + goto yy356; + if (yych <= 0x08) + goto yy368; + goto yy402; + } else { + if (yych == ' ') + goto yy402; + if (yych <= '!') + goto yy368; + goto yy379; + } + } else { + if (yych <= ':') { + if (yych == '\'') + goto yy377; + if (yych <= '9') + goto yy368; + goto yy398; + } else { + if (yych <= ';') + goto yy368; + if (yych <= '=') + goto yy356; + if (yych <= '>') + goto yy360; + goto yy368; + } + } + } else { + if (yych <= 0xDF) { + if (yych <= '`') { + if (yych <= 'Z') + goto yy398; + if (yych <= '^') + goto yy368; + if (yych <= '_') + goto yy398; + goto yy356; + } else { + if (yych <= 'z') + goto yy398; + if (yych <= 0x7F) + goto yy368; + if (yych <= 0xC1) + goto yy356; + goto yy370; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy371; + if (yych == 0xED) + goto yy376; + goto yy372; + } else { + if (yych <= 0xF0) + goto yy373; + if (yych <= 0xF3) + goto yy374; + if (yych <= 0xF4) + goto yy375; + goto yy356; + } + } + } + yy404: ++p; yych = *p; - if (yybm[0 + yych] & 4) { - goto yy443; + yy405: + if (yybm[0 + yych] & 8) { + goto yy404; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy376; - if (yych >= '^') - goto yy376; + goto yy356; + if (yych <= '?') + goto yy413; + goto yy356; } else { if (yych <= 0xDF) - goto yy454; + goto yy406; if (yych <= 0xE0) - goto yy455; - goto yy456; + goto yy407; + goto yy408; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy460; + goto yy412; if (yych <= 0xEF) - goto yy456; - goto yy457; - } else { - if (yych <= 0xF3) - goto yy458; - if (yych <= 0xF4) - goto yy459; - goto yy376; - } - } - ++p; - yych = *p; - if (yych <= 0xE0) { - if (yych <= '>') { - if (yych <= 0x00) - goto yy376; - if (yych <= '=') - goto yy443; - goto yy393; - } else { - if (yych <= 0x7F) - goto yy443; - if (yych <= 0xC1) - goto yy376; - if (yych <= 0xDF) - goto yy461; - goto yy462; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy467; - goto yy463; + goto yy408; + goto yy409; } else { - if (yych <= 0xF0) - goto yy464; if (yych <= 0xF3) - goto yy465; + goto yy410; if (yych <= 0xF4) - goto yy466; - goto yy376; + goto yy411; + goto yy356; } } - yy454: + yy406: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy443; - goto yy376; - yy455: + goto yy404; + goto yy356; + yy407: ++p; yych = *p; if (yych <= 0x9F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy454; - goto yy376; - yy456: + goto yy406; + goto yy356; + yy408: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy454; - goto yy376; - yy457: + goto yy406; + goto yy356; + yy409: ++p; yych = *p; if (yych <= 0x8F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy456; - goto yy376; - yy458: + goto yy408; + goto yy356; + yy410: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy456; - goto yy376; - yy459: + goto yy408; + goto yy356; + yy411: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x8F) - goto yy456; - goto yy376; - yy460: + goto yy408; + goto yy356; + yy412: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x9F) - goto yy454; - goto yy376; - yy461: + goto yy406; + goto yy356; + yy413: + ++p; + yych = *p; + if (yych <= 0xE0) { + if (yych <= '>') { + if (yych <= 0x00) + goto yy356; + if (yych <= '=') + goto yy404; + goto yy360; + } else { + if (yych <= 0x7F) + goto yy404; + if (yych <= 0xC1) + goto yy356; + if (yych >= 0xE0) + goto yy415; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy420; + goto yy416; + } else { + if (yych <= 0xF0) + goto yy417; + if (yych <= 0xF3) + goto yy418; + if (yych <= 0xF4) + goto yy419; + goto yy356; + } + } + yy414: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy443; - goto yy376; - yy462: + goto yy404; + goto yy356; + yy415: ++p; yych = *p; if (yych <= 0x9F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy461; - goto yy376; - yy463: + goto yy414; + goto yy356; + yy416: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy461; - goto yy376; - yy464: + goto yy414; + goto yy356; + yy417: ++p; yych = *p; if (yych <= 0x8F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy463; - goto yy376; - yy465: + goto yy416; + goto yy356; + yy418: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy463; - goto yy376; - yy466: + goto yy416; + goto yy356; + yy419: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x8F) - goto yy463; - goto yy376; - yy467: + goto yy416; + goto yy356; + yy420: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x9F) - goto yy461; - goto yy376; - yy468: - ++p; - yych = *p; - if (yybm[0 + yych] & 8) { - goto yy468; - } - if (yych <= 0x1F) { - if (yych <= 0x08) - goto yy376; - if (yych >= 0x0E) - goto yy376; - } else { - if (yych <= ' ') - goto yy470; - if (yych == '>') - goto yy393; - goto yy376; - } - yy470: - ++p; - yych = *p; - if (yych <= 0x1F) { - if (yych <= 0x08) - goto yy376; - if (yych <= '\r') - goto yy470; - goto yy376; - } else { - if (yych <= ' ') - goto yy470; - if (yych == '>') - goto yy393; - goto yy376; - } - yy472: + goto yy414; + goto yy356; + yy421: ++p; yych = *p; if (yych <= '/') { - if (yych <= ' ') { + if (yych <= 0x1F) { if (yych <= 0x08) - goto yy376; - if (yych <= '\r') - goto yy474; - if (yych <= 0x1F) - goto yy376; + goto yy356; + if (yych >= 0x0E) + goto yy356; } else { + if (yych <= ' ') + goto yy423; if (yych == '-') - goto yy472; - if (yych <= '.') - goto yy376; - goto yy476; + goto yy421; + goto yy356; } } else { if (yych <= '@') { if (yych <= '9') - goto yy472; + goto yy421; if (yych == '>') - goto yy393; - goto yy376; + goto yy360; + goto yy356; } else { if (yych <= 'Z') - goto yy472; + goto yy421; if (yych <= '`') - goto yy376; + goto yy356; if (yych <= 'z') - goto yy472; - goto yy376; + goto yy421; + goto yy356; } } - yy474: + yy423: ++p; yych = *p; - if (yych <= ':') { - if (yych <= ' ') { - if (yych <= 0x08) - goto yy376; - if (yych <= '\r') - goto yy474; - if (yych <= 0x1F) - goto yy376; - goto yy474; - } else { - if (yych == '/') - goto yy476; - if (yych <= '9') - goto yy376; - goto yy477; - } + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy356; + if (yych <= '\r') + goto yy423; + goto yy356; } else { - if (yych <= 'Z') { - if (yych == '>') - goto yy393; - if (yych <= '@') - goto yy376; - goto yy477; - } else { - if (yych <= '_') { - if (yych <= '^') - goto yy376; - goto yy477; - } else { - if (yych <= '`') - goto yy376; - if (yych <= 'z') - goto yy477; - goto yy376; - } - } + if (yych <= ' ') + goto yy423; + if (yych == '>') + goto yy360; + goto yy356; } - yy476: + yy425: yych = *++p; - if (yych == '>') - goto yy393; - goto yy376; - yy477: + if (yych == 'C') + goto yy461; + if (yych == 'c') + goto yy461; + goto yy356; + yy426: ++p; yych = *p; if (yybm[0 + yych] & 16) { - goto yy477; - } - if (yych <= ',') { - if (yych <= '\r') { - if (yych <= 0x08) - goto yy376; - } else { - if (yych != ' ') - goto yy376; - } - } else { - if (yych <= '<') { - if (yych <= '/') - goto yy476; - goto yy376; - } else { - if (yych <= '=') - goto yy481; - if (yych <= '>') - goto yy393; - goto yy376; - } - } - yy479: - ++p; - yych = *p; - if (yych <= '<') { - if (yych <= ' ') { - if (yych <= 0x08) - goto yy376; - if (yych <= '\r') - goto yy479; - if (yych <= 0x1F) - goto yy376; - goto yy479; - } else { - if (yych <= '/') { - if (yych <= '.') - goto yy376; - goto yy476; - } else { - if (yych == ':') - goto yy477; - goto yy376; - } - } - } else { - if (yych <= 'Z') { - if (yych <= '=') - goto yy481; - if (yych <= '>') - goto yy393; - if (yych <= '@') - goto yy376; - goto yy477; - } else { - if (yych <= '_') { - if (yych <= '^') - goto yy376; - goto yy477; - } else { - if (yych <= '`') - goto yy376; - if (yych <= 'z') - goto yy477; - goto yy376; - } - } - } - yy481: - ++p; - yych = *p; - if (yybm[0 + yych] & 32) { - goto yy483; + goto yy426; } + if (yych <= 0x08) + goto yy356; + if (yych <= '\r') + goto yy450; + if (yych == ' ') + goto yy450; + goto yy356; + yy428: + yych = *++p; + if (yych != '-') + goto yy356; + yych = *++p; if (yych <= 0xE0) { - if (yych <= '"') { - if (yych <= 0x00) - goto yy376; - if (yych >= '!') - goto yy494; + if (yych <= '=') { + if (yych != '-') + goto yy432; } else { - if (yych <= '\'') - goto yy492; + if (yych <= '>') + goto yy356; if (yych <= 0xC1) - goto yy376; + goto yy432; if (yych <= 0xDF) - goto yy485; - goto yy486; + goto yy433; + goto yy434; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy491; - goto yy487; + goto yy439; + goto yy435; } else { if (yych <= 0xF0) - goto yy488; + goto yy436; if (yych <= 0xF3) - goto yy489; + goto yy437; if (yych <= 0xF4) - goto yy490; - goto yy376; + goto yy438; + goto yy432; } } - ++p; - yych = *p; - if (yybm[0 + yych] & 32) { - goto yy483; - } - if (yych <= 0xDF) { - if (yych <= '\'') { - if (yych <= 0x00) - goto yy376; - if (yych <= ' ') - goto yy517; - if (yych <= '"') - goto yy494; - goto yy492; + yych = *++p; + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych == '-') + goto yy449; + goto yy432; } else { - if (yych == '>') - goto yy393; + if (yych <= '>') + goto yy356; if (yych <= 0xC1) - goto yy376; - goto yy485; + goto yy432; + if (yych <= 0xDF) + goto yy433; + goto yy434; } } else { if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy486; if (yych == 0xED) - goto yy491; - goto yy487; + goto yy439; + goto yy435; } else { if (yych <= 0xF0) - goto yy488; + goto yy436; if (yych <= 0xF3) - goto yy489; + goto yy437; if (yych <= 0xF4) - goto yy490; - goto yy376; + goto yy438; + goto yy432; } } - yy483: + yy431: ++p; yych = *p; + yy432: if (yybm[0 + yych] & 32) { - goto yy483; + goto yy431; } - if (yych <= 0xE0) { - if (yych <= '=') { + if (yych <= 0xEC) { + if (yych <= 0xC1) { if (yych <= 0x00) - goto yy376; - if (yych <= ' ') - goto yy511; - goto yy376; + goto yy356; + if (yych <= '-') + goto yy440; + goto yy356; } else { - if (yych <= '>') - goto yy393; - if (yych <= 0xC1) - goto yy376; - if (yych >= 0xE0) - goto yy486; + if (yych <= 0xDF) + goto yy441; + if (yych <= 0xE0) + goto yy442; + goto yy443; } } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy491; - goto yy487; + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy447; + if (yych <= 0xEF) + goto yy443; + goto yy444; } else { - if (yych <= 0xF0) - goto yy488; if (yych <= 0xF3) - goto yy489; + goto yy445; if (yych <= 0xF4) - goto yy490; - goto yy376; + goto yy446; + goto yy356; } } - yy485: + yy433: + yych = *++p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0xBF) + goto yy431; + goto yy356; + yy434: + yych = *++p; + if (yych <= 0x9F) + goto yy356; + if (yych <= 0xBF) + goto yy433; + goto yy356; + yy435: + yych = *++p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0xBF) + goto yy433; + goto yy356; + yy436: + yych = *++p; + if (yych <= 0x8F) + goto yy356; + if (yych <= 0xBF) + goto yy435; + goto yy356; + yy437: + yych = *++p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0xBF) + goto yy435; + goto yy356; + yy438: + yych = *++p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0x8F) + goto yy435; + goto yy356; + yy439: + yych = *++p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0x9F) + goto yy433; + goto yy356; + yy440: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy431; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy356; + if (yych <= '-') + goto yy448; + goto yy356; + } else { + if (yych <= 0xDF) + goto yy441; + if (yych <= 0xE0) + goto yy442; + goto yy443; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy447; + if (yych <= 0xEF) + goto yy443; + goto yy444; + } else { + if (yych <= 0xF3) + goto yy445; + if (yych <= 0xF4) + goto yy446; + goto yy356; + } + } + yy441: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy483; - goto yy376; - yy486: + goto yy431; + goto yy356; + yy442: ++p; yych = *p; if (yych <= 0x9F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy485; - goto yy376; - yy487: + goto yy441; + goto yy356; + yy443: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy485; - goto yy376; - yy488: + goto yy441; + goto yy356; + yy444: ++p; yych = *p; if (yych <= 0x8F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy487; - goto yy376; - yy489: + goto yy443; + goto yy356; + yy445: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy487; - goto yy376; - yy490: + goto yy443; + goto yy356; + yy446: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x8F) - goto yy487; - goto yy376; - yy491: + goto yy443; + goto yy356; + yy447: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x9F) - goto yy485; - goto yy376; - yy492: + goto yy441; + goto yy356; + yy448: + yych = *++p; + if (yych == '>') + goto yy360; + goto yy356; + yy449: + yych = *++p; + if (yych == '>') + goto yy360; + goto yy356; + yy450: ++p; yych = *p; - if (yybm[0 + yych] & 64) { - goto yy492; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { + if (yych <= 0xC1) { + if (yych <= 0x1F) { if (yych <= 0x00) - goto yy376; - if (yych <= '\'') - goto yy503; - goto yy376; + goto yy356; + if (yych <= 0x08) + goto yy452; + if (yych <= '\r') + goto yy450; } else { - if (yych <= 0xDF) - goto yy504; - if (yych <= 0xE0) - goto yy505; - goto yy506; + if (yych <= '=') { + if (yych <= ' ') + goto yy450; + } else { + if (yych <= '>') + goto yy360; + if (yych >= 0x80) + goto yy356; + } } } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy510; - if (yych <= 0xEF) - goto yy506; - goto yy507; + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy454; + if (yych <= 0xE0) + goto yy455; + if (yych <= 0xEC) + goto yy456; + goto yy460; } else { - if (yych <= 0xF3) - goto yy508; - if (yych <= 0xF4) - goto yy509; - goto yy376; + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy456; + goto yy457; + } else { + if (yych <= 0xF3) + goto yy458; + if (yych <= 0xF4) + goto yy459; + goto yy356; + } } } - yy494: + yy452: ++p; yych = *p; - if (yybm[0 + yych] & 128) { - goto yy494; + if (yybm[0 + yych] & 64) { + goto yy452; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy376; - if (yych <= '"') - goto yy503; - goto yy376; + goto yy356; + if (yych <= '>') + goto yy360; + goto yy356; } else { if (yych <= 0xDF) - goto yy496; + goto yy454; if (yych <= 0xE0) - goto yy497; - goto yy498; + goto yy455; + goto yy456; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy502; + goto yy460; if (yych <= 0xEF) - goto yy498; - goto yy499; + goto yy456; + goto yy457; } else { if (yych <= 0xF3) - goto yy500; + goto yy458; if (yych <= 0xF4) - goto yy501; - goto yy376; + goto yy459; + goto yy356; } } - yy496: + yy454: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy494; - goto yy376; - yy497: + goto yy452; + goto yy356; + yy455: ++p; yych = *p; if (yych <= 0x9F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy496; - goto yy376; - yy498: + goto yy454; + goto yy356; + yy456: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy496; - goto yy376; - yy499: + goto yy454; + goto yy356; + yy457: ++p; yych = *p; if (yych <= 0x8F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy498; - goto yy376; - yy500: + goto yy456; + goto yy356; + yy458: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy498; - goto yy376; - yy501: + goto yy456; + goto yy356; + yy459: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x8F) - goto yy498; - goto yy376; - yy502: + goto yy456; + goto yy356; + yy460: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x9F) - goto yy496; - goto yy376; - yy503: - ++p; - yych = *p; - if (yych <= ' ') { - if (yych <= 0x08) - goto yy376; - if (yych <= '\r') - goto yy474; - if (yych <= 0x1F) - goto yy376; - goto yy474; - } else { - if (yych <= '/') { - if (yych <= '.') - goto yy376; - goto yy476; - } else { - if (yych == '>') - goto yy393; - goto yy376; - } - } - yy504: + goto yy454; + goto yy356; + yy461: + yych = *++p; + if (yych == 'D') + goto yy462; + if (yych != 'd') + goto yy356; + yy462: + yych = *++p; + if (yych == 'A') + goto yy463; + if (yych != 'a') + goto yy356; + yy463: + yych = *++p; + if (yych == 'T') + goto yy464; + if (yych != 't') + goto yy356; + yy464: + yych = *++p; + if (yych == 'A') + goto yy465; + if (yych != 'a') + goto yy356; + yy465: + yych = *++p; + if (yych != '[') + goto yy356; + yy466: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy466; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy356; + if (yych <= ']') + goto yy475; + goto yy356; + } else { + if (yych <= 0xDF) + goto yy468; + if (yych <= 0xE0) + goto yy469; + goto yy470; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy474; + if (yych <= 0xEF) + goto yy470; + goto yy471; + } else { + if (yych <= 0xF3) + goto yy472; + if (yych <= 0xF4) + goto yy473; + goto yy356; + } + } + yy468: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy492; - goto yy376; - yy505: + goto yy466; + goto yy356; + yy469: ++p; yych = *p; if (yych <= 0x9F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy504; - goto yy376; - yy506: + goto yy468; + goto yy356; + yy470: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy504; - goto yy376; - yy507: + goto yy468; + goto yy356; + yy471: ++p; yych = *p; if (yych <= 0x8F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy506; - goto yy376; - yy508: + goto yy470; + goto yy356; + yy472: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0xBF) - goto yy506; - goto yy376; - yy509: + goto yy470; + goto yy356; + yy473: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x8F) - goto yy506; - goto yy376; - yy510: + goto yy470; + goto yy356; + yy474: ++p; yych = *p; if (yych <= 0x7F) - goto yy376; + goto yy356; if (yych <= 0x9F) - goto yy504; - goto yy376; - yy511: + goto yy468; + goto yy356; + yy475: ++p; yych = *p; - if (yych <= '@') { - if (yych <= '"') { - if (yych <= '\r') { - if (yych <= 0x00) - goto yy376; - if (yych <= 0x08) - goto yy483; - goto yy511; - } else { - if (yych == ' ') - goto yy511; - if (yych <= '!') - goto yy483; - goto yy376; - } + if (yybm[0 + yych] & 128) { + goto yy466; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy356; + if (yych >= '^') + goto yy356; } else { - if (yych <= ':') { - if (yych == '\'') - goto yy376; - if (yych <= '9') - goto yy483; - } else { - if (yych <= ';') - goto yy483; - if (yych <= '=') - goto yy376; - if (yych <= '>') - goto yy393; - goto yy483; - } + if (yych <= 0xDF) + goto yy477; + if (yych <= 0xE0) + goto yy478; + goto yy479; } } else { - if (yych <= 0xDF) { - if (yych <= '`') { - if (yych <= 'Z') - goto yy513; - if (yych <= '^') - goto yy483; - if (yych >= '`') - goto yy376; - } else { - if (yych <= 'z') - goto yy513; - if (yych <= 0x7F) - goto yy483; - if (yych <= 0xC1) - goto yy376; - goto yy485; - } + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy483; + if (yych <= 0xEF) + goto yy479; + goto yy480; } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy486; - if (yych == 0xED) - goto yy491; - goto yy487; - } else { - if (yych <= 0xF0) - goto yy488; - if (yych <= 0xF3) - goto yy489; - if (yych <= 0xF4) - goto yy490; - goto yy376; - } + if (yych <= 0xF3) + goto yy481; + if (yych <= 0xF4) + goto yy482; + goto yy356; } } - yy513: ++p; yych = *p; - if (yych <= '>') { - if (yych <= '&') { - if (yych <= 0x1F) { - if (yych <= 0x00) - goto yy376; - if (yych <= 0x08) - goto yy483; - if (yych >= 0x0E) - goto yy483; - } else { - if (yych <= ' ') - goto yy515; - if (yych == '"') - goto yy376; - goto yy483; - } + if (yych <= 0xE0) { + if (yych <= '>') { + if (yych <= 0x00) + goto yy356; + if (yych <= '=') + goto yy466; + goto yy360; } else { - if (yych <= '/') { - if (yych <= '\'') - goto yy376; - if (yych <= ',') - goto yy483; - if (yych <= '.') - goto yy513; - goto yy483; - } else { - if (yych <= ';') { - if (yych <= ':') - goto yy513; - goto yy483; - } else { - if (yych <= '<') - goto yy376; - if (yych <= '=') - goto yy481; - goto yy393; - } - } + if (yych <= 0x7F) + goto yy466; + if (yych <= 0xC1) + goto yy356; + if (yych <= 0xDF) + goto yy484; + goto yy485; } } else { - if (yych <= 0xC1) { - if (yych <= '_') { - if (yych <= '@') - goto yy483; - if (yych <= 'Z') - goto yy513; - if (yych <= '^') - goto yy483; - goto yy513; - } else { - if (yych <= '`') - goto yy376; - if (yych <= 'z') - goto yy513; - if (yych <= 0x7F) - goto yy483; - goto yy376; - } + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy490; + goto yy486; } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy485; - if (yych <= 0xE0) - goto yy486; - if (yych <= 0xEC) - goto yy487; - goto yy491; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy487; - goto yy488; - } else { - if (yych <= 0xF3) - goto yy489; - if (yych <= 0xF4) - goto yy490; - goto yy376; - } - } + if (yych <= 0xF0) + goto yy487; + if (yych <= 0xF3) + goto yy488; + if (yych <= 0xF4) + goto yy489; + goto yy356; } } - yy515: + yy477: ++p; yych = *p; - if (yych <= '@') { - if (yych <= '&') { - if (yych <= 0x1F) { - if (yych <= 0x00) - goto yy376; - if (yych <= 0x08) - goto yy483; - if (yych <= '\r') - goto yy515; - goto yy483; - } else { - if (yych <= ' ') - goto yy515; - if (yych == '"') - goto yy376; - goto yy483; - } - } else { - if (yych <= ';') { - if (yych <= '\'') - goto yy376; - if (yych == ':') - goto yy513; - goto yy483; - } else { - if (yych <= '<') - goto yy376; - if (yych <= '=') - goto yy481; - if (yych <= '>') - goto yy393; - goto yy483; - } - } - } else { - if (yych <= 0xDF) { - if (yych <= '`') { - if (yych <= 'Z') - goto yy513; - if (yych <= '^') - goto yy483; - if (yych <= '_') - goto yy513; - goto yy376; - } else { - if (yych <= 'z') - goto yy513; - if (yych <= 0x7F) - goto yy483; - if (yych <= 0xC1) - goto yy376; - goto yy485; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy486; - if (yych == 0xED) - goto yy491; - goto yy487; - } else { - if (yych <= 0xF0) - goto yy488; - if (yych <= 0xF3) - goto yy489; - if (yych <= 0xF4) - goto yy490; - goto yy376; - } - } - } - yy517: + if (yych <= 0x7F) + goto yy356; + if (yych <= 0xBF) + goto yy466; + goto yy356; + yy478: ++p; yych = *p; - if (yych <= '@') { - if (yych <= '"') { - if (yych <= '\r') { - if (yych <= 0x00) - goto yy376; - if (yych <= 0x08) - goto yy483; - goto yy517; - } else { - if (yych == ' ') - goto yy517; - if (yych <= '!') - goto yy483; - goto yy494; - } - } else { - if (yych <= ':') { - if (yych == '\'') - goto yy492; - if (yych <= '9') - goto yy483; - goto yy513; - } else { - if (yych <= ';') - goto yy483; - if (yych <= '=') - goto yy376; - if (yych <= '>') - goto yy393; - goto yy483; - } - } - } else { - if (yych <= 0xDF) { - if (yych <= '`') { - if (yych <= 'Z') - goto yy513; - if (yych <= '^') - goto yy483; - if (yych <= '_') - goto yy513; - goto yy376; - } else { - if (yych <= 'z') - goto yy513; - if (yych <= 0x7F) - goto yy483; - if (yych <= 0xC1) - goto yy376; - goto yy485; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy486; - if (yych == 0xED) - goto yy491; - goto yy487; - } else { - if (yych <= 0xF0) - goto yy488; - if (yych <= 0xF3) - goto yy489; - if (yych <= 0xF4) - goto yy490; - goto yy376; - } - } - } + if (yych <= 0x9F) + goto yy356; + if (yych <= 0xBF) + goto yy477; + goto yy356; + yy479: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0xBF) + goto yy477; + goto yy356; + yy480: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy356; + if (yych <= 0xBF) + goto yy479; + goto yy356; + yy481: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0xBF) + goto yy479; + goto yy356; + yy482: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0x8F) + goto yy479; + goto yy356; + yy483: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0x9F) + goto yy477; + goto yy356; + yy484: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0xBF) + goto yy466; + goto yy356; + yy485: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy356; + if (yych <= 0xBF) + goto yy484; + goto yy356; + yy486: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0xBF) + goto yy484; + goto yy356; + yy487: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy356; + if (yych <= 0xBF) + goto yy486; + goto yy356; + yy488: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0xBF) + goto yy486; + goto yy356; + yy489: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0x8F) + goto yy486; + goto yy356; + yy490: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy356; + if (yych <= 0x9F) + goto yy484; + goto yy356; } } @@ -10222,317 +9762,241 @@ bufsize_t _scan_html_block_start(const unsigned char *p) { { unsigned char yych; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= ';') { - if (yych != '\n') - goto yy523; - } else { - if (yych <= '<') - goto yy522; - if (yych <= 0x7F) - goto yy523; - if (yych >= 0xC2) - goto yy524; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy526; - if (yych == 0xED) - goto yy531; - goto yy527; - } else { - if (yych <= 0xF0) - goto yy528; - if (yych <= 0xF3) - goto yy529; - if (yych <= 0xF4) - goto yy530; - } - } - yy521 : { return 0; } - yy522: + yych = *p; + if (yych == '<') + goto yy495; + ++p; + yy494 : { return 0; } + yy495: yych = *(marker = ++p); switch (yych) { case '!': - goto yy548; + goto yy513; case '/': - goto yy532; + goto yy496; case '?': - goto yy549; + goto yy514; case 'A': case 'a': - goto yy534; + goto yy499; case 'B': case 'b': - goto yy535; + goto yy500; case 'C': case 'c': - goto yy536; + goto yy501; case 'D': case 'd': - goto yy537; + goto yy502; case 'F': case 'f': - goto yy538; + goto yy503; case 'H': case 'h': - goto yy539; + goto yy504; case 'I': case 'i': - goto yy540; + goto yy505; case 'L': case 'l': - goto yy541; + goto yy506; case 'M': case 'm': - goto yy542; + goto yy507; case 'N': case 'n': - goto yy543; + goto yy508; case 'O': case 'o': - goto yy544; + goto yy509; case 'P': case 'p': - goto yy533; + goto yy498; case 'S': case 's': - goto yy545; + goto yy510; case 'T': case 't': - goto yy546; + goto yy511; case 'U': case 'u': - goto yy547; + goto yy512; default: - goto yy521; + goto yy494; } - yy523: - yych = *++p; - goto yy521; - yy524: - yych = *++p; - if (yych <= 0x7F) - goto yy525; - if (yych <= 0xBF) - goto yy523; - yy525: - p = marker; - goto yy521; - yy526: - yych = *++p; - if (yych <= 0x9F) - goto yy525; - if (yych <= 0xBF) - goto yy524; - goto yy525; - yy527: - yych = *++p; - if (yych <= 0x7F) - goto yy525; - if (yych <= 0xBF) - goto yy524; - goto yy525; - yy528: - yych = *++p; - if (yych <= 0x8F) - goto yy525; - if (yych <= 0xBF) - goto yy527; - goto yy525; - yy529: - yych = *++p; - if (yych <= 0x7F) - goto yy525; - if (yych <= 0xBF) - goto yy527; - goto yy525; - yy530: - yych = *++p; - if (yych <= 0x7F) - goto yy525; - if (yych <= 0x8F) - goto yy527; - goto yy525; - yy531: - yych = *++p; - if (yych <= 0x7F) - goto yy525; - if (yych <= 0x9F) - goto yy524; - goto yy525; - yy532: + yy496: yych = *++p; switch (yych) { case 'A': case 'a': - goto yy534; + goto yy499; case 'B': case 'b': - goto yy535; + goto yy500; case 'C': case 'c': - goto yy536; + goto yy501; case 'D': case 'd': - goto yy537; + goto yy502; case 'F': case 'f': - goto yy538; + goto yy503; case 'H': case 'h': - goto yy539; + goto yy504; case 'I': case 'i': - goto yy540; + goto yy505; case 'L': case 'l': - goto yy541; + goto yy506; case 'M': case 'm': - goto yy542; + goto yy507; case 'N': case 'n': - goto yy543; + goto yy508; case 'O': case 'o': - goto yy544; + goto yy509; case 'P': case 'p': - goto yy733; + goto yy698; case 'S': case 's': - goto yy734; + goto yy699; case 'T': case 't': - goto yy546; + goto yy511; case 'U': case 'u': - goto yy547; + goto yy512; default: - goto yy525; + goto yy497; } - yy533: + yy497: + p = marker; + goto yy494; + yy498: yych = *++p; if (yych <= '>') { if (yych <= ' ') { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; + goto yy530; if (yych <= 0x1F) - goto yy525; - goto yy565; + goto yy497; + goto yy530; } else { if (yych == '/') - goto yy567; + goto yy532; if (yych <= '=') - goto yy525; - goto yy565; + goto yy497; + goto yy530; } } else { if (yych <= 'R') { if (yych == 'A') - goto yy730; + goto yy695; if (yych <= 'Q') - goto yy525; - goto yy729; + goto yy497; + goto yy694; } else { if (yych <= 'a') { if (yych <= '`') - goto yy525; - goto yy730; + goto yy497; + goto yy695; } else { if (yych == 'r') - goto yy729; - goto yy525; + goto yy694; + goto yy497; } } } - yy534: + yy499: yych = *++p; if (yych <= 'S') { if (yych <= 'D') { if (yych <= 'C') - goto yy525; - goto yy718; + goto yy497; + goto yy683; } else { if (yych <= 'Q') - goto yy525; + goto yy497; if (yych <= 'R') - goto yy717; - goto yy716; + goto yy682; + goto yy681; } } else { if (yych <= 'q') { if (yych == 'd') - goto yy718; - goto yy525; + goto yy683; + goto yy497; } else { if (yych <= 'r') - goto yy717; + goto yy682; if (yych <= 's') - goto yy716; - goto yy525; + goto yy681; + goto yy497; } } - yy535: + yy500: yych = *++p; if (yych <= 'O') { if (yych <= 'K') { if (yych == 'A') - goto yy702; - goto yy525; + goto yy667; + goto yy497; } else { if (yych <= 'L') - goto yy701; + goto yy666; if (yych <= 'N') - goto yy525; - goto yy700; + goto yy497; + goto yy665; } } else { if (yych <= 'k') { if (yych == 'a') - goto yy702; - goto yy525; + goto yy667; + goto yy497; } else { if (yych <= 'l') - goto yy701; + goto yy666; if (yych == 'o') - goto yy700; - goto yy525; + goto yy665; + goto yy497; } } - yy536: + yy501: yych = *++p; if (yych <= 'O') { if (yych <= 'D') { if (yych == 'A') - goto yy687; - goto yy525; + goto yy652; + goto yy497; } else { if (yych <= 'E') - goto yy686; + goto yy651; if (yych <= 'N') - goto yy525; - goto yy685; + goto yy497; + goto yy650; } } else { if (yych <= 'd') { if (yych == 'a') - goto yy687; - goto yy525; + goto yy652; + goto yy497; } else { if (yych <= 'e') - goto yy686; + goto yy651; if (yych == 'o') - goto yy685; - goto yy525; + goto yy650; + goto yy497; } } - yy537: + yy502: yych = *++p; switch (yych) { case 'D': @@ -10541,1662 +10005,1664 @@ bufsize_t _scan_html_block_start(const unsigned char *p) { case 'd': case 'l': case 't': - goto yy564; + goto yy529; case 'E': case 'e': - goto yy677; + goto yy642; case 'I': case 'i': - goto yy676; + goto yy641; default: - goto yy525; + goto yy497; } - yy538: + yy503: yych = *++p; if (yych <= 'R') { if (yych <= 'N') { if (yych == 'I') - goto yy652; - goto yy525; + goto yy617; + goto yy497; } else { if (yych <= 'O') - goto yy651; + goto yy616; if (yych <= 'Q') - goto yy525; - goto yy650; + goto yy497; + goto yy615; } } else { if (yych <= 'n') { if (yych == 'i') - goto yy652; - goto yy525; + goto yy617; + goto yy497; } else { if (yych <= 'o') - goto yy651; + goto yy616; if (yych == 'r') - goto yy650; - goto yy525; + goto yy615; + goto yy497; } } - yy539: + yy504: yych = *++p; if (yych <= 'S') { if (yych <= 'D') { - if (yych == '1') - goto yy564; - goto yy525; + if (yych <= '0') + goto yy497; + if (yych <= '6') + goto yy529; + goto yy497; } else { if (yych <= 'E') - goto yy645; + goto yy610; if (yych == 'R') - goto yy564; - goto yy525; + goto yy529; + goto yy497; } } else { if (yych <= 'q') { if (yych <= 'T') - goto yy644; + goto yy609; if (yych == 'e') - goto yy645; - goto yy525; + goto yy610; + goto yy497; } else { if (yych <= 'r') - goto yy564; + goto yy529; if (yych == 't') - goto yy644; - goto yy525; + goto yy609; + goto yy497; } } - yy540: + yy505: yych = *++p; if (yych == 'F') - goto yy640; + goto yy605; if (yych == 'f') - goto yy640; - goto yy525; - yy541: + goto yy605; + goto yy497; + yy506: yych = *++p; if (yych <= 'I') { if (yych == 'E') - goto yy635; + goto yy600; if (yych <= 'H') - goto yy525; - goto yy634; + goto yy497; + goto yy599; } else { if (yych <= 'e') { if (yych <= 'd') - goto yy525; - goto yy635; + goto yy497; + goto yy600; } else { if (yych == 'i') - goto yy634; - goto yy525; + goto yy599; + goto yy497; } } - yy542: + yy507: yych = *++p; if (yych <= 'E') { if (yych == 'A') - goto yy626; + goto yy591; if (yych <= 'D') - goto yy525; - goto yy625; + goto yy497; + goto yy590; } else { if (yych <= 'a') { if (yych <= '`') - goto yy525; - goto yy626; + goto yy497; + goto yy591; } else { if (yych == 'e') - goto yy625; - goto yy525; + goto yy590; + goto yy497; } } - yy543: + yy508: yych = *++p; if (yych <= 'O') { if (yych == 'A') - goto yy619; + goto yy584; if (yych <= 'N') - goto yy525; - goto yy618; + goto yy497; + goto yy583; } else { if (yych <= 'a') { if (yych <= '`') - goto yy525; - goto yy619; + goto yy497; + goto yy584; } else { if (yych == 'o') - goto yy618; - goto yy525; + goto yy583; + goto yy497; } } - yy544: + yy509: yych = *++p; if (yych <= 'P') { if (yych == 'L') - goto yy564; + goto yy529; if (yych <= 'O') - goto yy525; - goto yy610; + goto yy497; + goto yy575; } else { if (yych <= 'l') { if (yych <= 'k') - goto yy525; - goto yy564; + goto yy497; + goto yy529; } else { if (yych == 'p') - goto yy610; - goto yy525; + goto yy575; + goto yy497; } } - yy545: + yy510: yych = *++p; switch (yych) { case 'C': case 'c': - goto yy587; + goto yy552; case 'E': case 'e': - goto yy590; + goto yy555; case 'O': case 'o': - goto yy589; + goto yy554; case 'T': case 't': - goto yy586; + goto yy551; case 'U': case 'u': - goto yy588; + goto yy553; default: - goto yy525; + goto yy497; } - yy546: + yy511: yych = *++p; switch (yych) { case 'A': case 'a': - goto yy573; + goto yy538; case 'B': case 'b': - goto yy572; + goto yy537; case 'D': case 'd': - goto yy564; + goto yy529; case 'F': case 'f': - goto yy571; + goto yy536; case 'H': case 'h': - goto yy570; + goto yy535; case 'I': case 'i': - goto yy569; + goto yy534; case 'R': case 'r': - goto yy568; + goto yy533; default: - goto yy525; + goto yy497; } - yy547: + yy512: yych = *++p; if (yych == 'L') - goto yy564; + goto yy529; if (yych == 'l') - goto yy564; - goto yy525; - yy548: + goto yy529; + goto yy497; + yy513: yych = *++p; if (yych <= '@') { if (yych == '-') - goto yy551; - goto yy525; + goto yy516; + goto yy497; } else { if (yych <= 'Z') - goto yy552; + goto yy517; if (yych <= '[') - goto yy554; - goto yy525; + goto yy519; + goto yy497; } - yy549: + yy514: ++p; { return 3; } - yy551: + yy516: yych = *++p; if (yych == '-') - goto yy562; - goto yy525; - yy552: + goto yy527; + goto yy497; + yy517: ++p; { return 4; } - yy554: + yy519: yych = *++p; if (yych == 'C') - goto yy555; + goto yy520; if (yych != 'c') - goto yy525; - yy555: + goto yy497; + yy520: yych = *++p; if (yych == 'D') - goto yy556; + goto yy521; if (yych != 'd') - goto yy525; - yy556: + goto yy497; + yy521: yych = *++p; if (yych == 'A') - goto yy557; + goto yy522; if (yych != 'a') - goto yy525; - yy557: + goto yy497; + yy522: yych = *++p; if (yych == 'T') - goto yy558; + goto yy523; if (yych != 't') - goto yy525; - yy558: + goto yy497; + yy523: yych = *++p; if (yych == 'A') - goto yy559; + goto yy524; if (yych != 'a') - goto yy525; - yy559: + goto yy497; + yy524: yych = *++p; if (yych != '[') - goto yy525; + goto yy497; ++p; { return 5; } - yy562: + yy527: ++p; { return 2; } - yy564: + yy529: yych = *++p; if (yych <= ' ') { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; + goto yy530; if (yych <= 0x1F) - goto yy525; + goto yy497; } else { if (yych <= '/') { if (yych <= '.') - goto yy525; - goto yy567; + goto yy497; + goto yy532; } else { if (yych != '>') - goto yy525; + goto yy497; } } - yy565: + yy530: ++p; { return 6; } - yy567: + yy532: yych = *++p; if (yych == '>') - goto yy565; - goto yy525; - yy568: + goto yy530; + goto yy497; + yy533: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= ' ') - goto yy565; + goto yy530; if (yych <= '.') - goto yy525; - goto yy567; + goto yy497; + goto yy532; } } else { if (yych <= '@') { if (yych == '>') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= 'A') - goto yy584; + goto yy549; if (yych == 'a') - goto yy584; - goto yy525; + goto yy549; + goto yy497; } } - yy569: + yy534: yych = *++p; if (yych == 'T') - goto yy582; + goto yy547; if (yych == 't') - goto yy582; - goto yy525; - yy570: + goto yy547; + goto yy497; + yy535: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= ' ') - goto yy565; + goto yy530; if (yych <= '.') - goto yy525; - goto yy567; + goto yy497; + goto yy532; } } else { if (yych <= 'D') { if (yych == '>') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= 'E') - goto yy580; + goto yy545; if (yych == 'e') - goto yy580; - goto yy525; + goto yy545; + goto yy497; } } - yy571: + yy536: yych = *++p; if (yych == 'O') - goto yy578; + goto yy543; if (yych == 'o') - goto yy578; - goto yy525; - yy572: + goto yy543; + goto yy497; + yy537: yych = *++p; if (yych == 'O') - goto yy576; + goto yy541; if (yych == 'o') - goto yy576; - goto yy525; - yy573: + goto yy541; + goto yy497; + yy538: yych = *++p; if (yych == 'B') - goto yy574; + goto yy539; if (yych != 'b') - goto yy525; - yy574: + goto yy497; + yy539: yych = *++p; if (yych == 'L') - goto yy575; + goto yy540; if (yych != 'l') - goto yy525; - yy575: + goto yy497; + yy540: yych = *++p; if (yych == 'E') - goto yy564; + goto yy529; if (yych == 'e') - goto yy564; - goto yy525; - yy576: + goto yy529; + goto yy497; + yy541: yych = *++p; if (yych == 'D') - goto yy577; + goto yy542; if (yych != 'd') - goto yy525; - yy577: + goto yy497; + yy542: yych = *++p; if (yych == 'Y') - goto yy564; + goto yy529; if (yych == 'y') - goto yy564; - goto yy525; - yy578: + goto yy529; + goto yy497; + yy543: yych = *++p; if (yych == 'O') - goto yy579; + goto yy544; if (yych != 'o') - goto yy525; - yy579: + goto yy497; + yy544: yych = *++p; if (yych == 'T') - goto yy564; + goto yy529; if (yych == 't') - goto yy564; - goto yy525; - yy580: + goto yy529; + goto yy497; + yy545: yych = *++p; if (yych == 'A') - goto yy581; + goto yy546; if (yych != 'a') - goto yy525; - yy581: + goto yy497; + yy546: yych = *++p; if (yych == 'D') - goto yy564; + goto yy529; if (yych == 'd') - goto yy564; - goto yy525; - yy582: + goto yy529; + goto yy497; + yy547: yych = *++p; if (yych == 'L') - goto yy583; + goto yy548; if (yych != 'l') - goto yy525; - yy583: + goto yy497; + yy548: yych = *++p; if (yych == 'E') - goto yy564; + goto yy529; if (yych == 'e') - goto yy564; - goto yy525; - yy584: + goto yy529; + goto yy497; + yy549: yych = *++p; if (yych == 'C') - goto yy585; + goto yy550; if (yych != 'c') - goto yy525; - yy585: + goto yy497; + yy550: yych = *++p; if (yych == 'K') - goto yy564; + goto yy529; if (yych == 'k') - goto yy564; - goto yy525; - yy586: + goto yy529; + goto yy497; + yy551: yych = *++p; if (yych == 'Y') - goto yy608; + goto yy573; if (yych == 'y') - goto yy608; - goto yy525; - yy587: + goto yy573; + goto yy497; + yy552: yych = *++p; if (yych == 'R') - goto yy602; + goto yy567; if (yych == 'r') - goto yy602; - goto yy525; - yy588: + goto yy567; + goto yy497; + yy553: yych = *++p; if (yych == 'M') - goto yy598; + goto yy563; if (yych == 'm') - goto yy598; - goto yy525; - yy589: + goto yy563; + goto yy497; + yy554: yych = *++p; if (yych == 'U') - goto yy595; + goto yy560; if (yych == 'u') - goto yy595; - goto yy525; - yy590: + goto yy560; + goto yy497; + yy555: yych = *++p; if (yych == 'C') - goto yy591; + goto yy556; if (yych != 'c') - goto yy525; - yy591: + goto yy497; + yy556: yych = *++p; if (yych == 'T') - goto yy592; + goto yy557; if (yych != 't') - goto yy525; - yy592: + goto yy497; + yy557: yych = *++p; if (yych == 'I') - goto yy593; + goto yy558; if (yych != 'i') - goto yy525; - yy593: + goto yy497; + yy558: yych = *++p; if (yych == 'O') - goto yy594; + goto yy559; if (yych != 'o') - goto yy525; - yy594: + goto yy497; + yy559: yych = *++p; if (yych == 'N') - goto yy564; + goto yy529; if (yych == 'n') - goto yy564; - goto yy525; - yy595: + goto yy529; + goto yy497; + yy560: yych = *++p; if (yych == 'R') - goto yy596; + goto yy561; if (yych != 'r') - goto yy525; - yy596: + goto yy497; + yy561: yych = *++p; if (yych == 'C') - goto yy597; + goto yy562; if (yych != 'c') - goto yy525; - yy597: + goto yy497; + yy562: yych = *++p; if (yych == 'E') - goto yy564; + goto yy529; if (yych == 'e') - goto yy564; - goto yy525; - yy598: + goto yy529; + goto yy497; + yy563: yych = *++p; if (yych == 'M') - goto yy599; + goto yy564; if (yych != 'm') - goto yy525; - yy599: + goto yy497; + yy564: yych = *++p; if (yych == 'A') - goto yy600; + goto yy565; if (yych != 'a') - goto yy525; - yy600: + goto yy497; + yy565: yych = *++p; if (yych == 'R') - goto yy601; + goto yy566; if (yych != 'r') - goto yy525; - yy601: + goto yy497; + yy566: yych = *++p; if (yych == 'Y') - goto yy564; + goto yy529; if (yych == 'y') - goto yy564; - goto yy525; - yy602: + goto yy529; + goto yy497; + yy567: yych = *++p; if (yych == 'I') - goto yy603; + goto yy568; if (yych != 'i') - goto yy525; - yy603: + goto yy497; + yy568: yych = *++p; if (yych == 'P') - goto yy604; + goto yy569; if (yych != 'p') - goto yy525; - yy604: + goto yy497; + yy569: yych = *++p; if (yych == 'T') - goto yy605; + goto yy570; if (yych != 't') - goto yy525; - yy605: + goto yy497; + yy570: yych = *++p; if (yych <= 0x1F) { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych >= 0x0E) - goto yy525; + goto yy497; } else { if (yych <= ' ') - goto yy606; + goto yy571; if (yych != '>') - goto yy525; + goto yy497; } - yy606: + yy571: ++p; { return 1; } - yy608: + yy573: yych = *++p; if (yych == 'L') - goto yy609; + goto yy574; if (yych != 'l') - goto yy525; - yy609: + goto yy497; + yy574: yych = *++p; if (yych == 'E') - goto yy605; + goto yy570; if (yych == 'e') - goto yy605; - goto yy525; - yy610: + goto yy570; + goto yy497; + yy575: yych = *++p; if (yych == 'T') - goto yy611; + goto yy576; if (yych != 't') - goto yy525; - yy611: + goto yy497; + yy576: yych = *++p; if (yych <= 'I') { if (yych == 'G') - goto yy613; + goto yy578; if (yych <= 'H') - goto yy525; + goto yy497; } else { if (yych <= 'g') { if (yych <= 'f') - goto yy525; - goto yy613; + goto yy497; + goto yy578; } else { if (yych != 'i') - goto yy525; + goto yy497; } } yych = *++p; if (yych == 'O') - goto yy617; + goto yy582; if (yych == 'o') - goto yy617; - goto yy525; - yy613: + goto yy582; + goto yy497; + yy578: yych = *++p; if (yych == 'R') - goto yy614; + goto yy579; if (yych != 'r') - goto yy525; - yy614: + goto yy497; + yy579: yych = *++p; if (yych == 'O') - goto yy615; + goto yy580; if (yych != 'o') - goto yy525; - yy615: + goto yy497; + yy580: yych = *++p; if (yych == 'U') - goto yy616; + goto yy581; if (yych != 'u') - goto yy525; - yy616: + goto yy497; + yy581: yych = *++p; if (yych == 'P') - goto yy564; + goto yy529; if (yych == 'p') - goto yy564; - goto yy525; - yy617: + goto yy529; + goto yy497; + yy582: yych = *++p; if (yych == 'N') - goto yy564; + goto yy529; if (yych == 'n') - goto yy564; - goto yy525; - yy618: + goto yy529; + goto yy497; + yy583: yych = *++p; if (yych == 'F') - goto yy620; + goto yy585; if (yych == 'f') - goto yy620; - goto yy525; - yy619: + goto yy585; + goto yy497; + yy584: yych = *++p; if (yych == 'V') - goto yy564; + goto yy529; if (yych == 'v') - goto yy564; - goto yy525; - yy620: + goto yy529; + goto yy497; + yy585: yych = *++p; if (yych == 'R') - goto yy621; + goto yy586; if (yych != 'r') - goto yy525; - yy621: + goto yy497; + yy586: yych = *++p; if (yych == 'A') - goto yy622; + goto yy587; if (yych != 'a') - goto yy525; - yy622: + goto yy497; + yy587: yych = *++p; if (yych == 'M') - goto yy623; + goto yy588; if (yych != 'm') - goto yy525; - yy623: + goto yy497; + yy588: yych = *++p; if (yych == 'E') - goto yy624; + goto yy589; if (yych != 'e') - goto yy525; - yy624: + goto yy497; + yy589: yych = *++p; if (yych == 'S') - goto yy564; + goto yy529; if (yych == 's') - goto yy564; - goto yy525; - yy625: + goto yy529; + goto yy497; + yy590: yych = *++p; if (yych <= 'T') { if (yych == 'N') - goto yy628; + goto yy593; if (yych <= 'S') - goto yy525; - goto yy629; + goto yy497; + goto yy594; } else { if (yych <= 'n') { if (yych <= 'm') - goto yy525; - goto yy628; + goto yy497; + goto yy593; } else { if (yych == 't') - goto yy629; - goto yy525; + goto yy594; + goto yy497; } } - yy626: + yy591: yych = *++p; if (yych == 'I') - goto yy627; + goto yy592; if (yych != 'i') - goto yy525; - yy627: + goto yy497; + yy592: yych = *++p; if (yych == 'N') - goto yy564; + goto yy529; if (yych == 'n') - goto yy564; - goto yy525; - yy628: + goto yy529; + goto yy497; + yy593: yych = *++p; if (yych == 'U') - goto yy630; + goto yy595; if (yych == 'u') - goto yy630; - goto yy525; - yy629: + goto yy595; + goto yy497; + yy594: yych = *++p; if (yych == 'A') - goto yy564; + goto yy529; if (yych == 'a') - goto yy564; - goto yy525; - yy630: + goto yy529; + goto yy497; + yy595: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= ' ') - goto yy565; + goto yy530; if (yych <= '.') - goto yy525; - goto yy567; + goto yy497; + goto yy532; } } else { if (yych <= 'H') { if (yych == '>') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= 'I') - goto yy631; + goto yy596; if (yych != 'i') - goto yy525; + goto yy497; } } - yy631: + yy596: yych = *++p; if (yych == 'T') - goto yy632; + goto yy597; if (yych != 't') - goto yy525; - yy632: + goto yy497; + yy597: yych = *++p; if (yych == 'E') - goto yy633; + goto yy598; if (yych != 'e') - goto yy525; - yy633: + goto yy497; + yy598: yych = *++p; if (yych == 'M') - goto yy564; + goto yy529; if (yych == 'm') - goto yy564; - goto yy525; - yy634: + goto yy529; + goto yy497; + yy599: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= ' ') - goto yy565; + goto yy530; if (yych <= '.') - goto yy525; - goto yy567; + goto yy497; + goto yy532; } } else { if (yych <= 'M') { if (yych == '>') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= 'N') - goto yy639; + goto yy604; if (yych == 'n') - goto yy639; - goto yy525; + goto yy604; + goto yy497; } } - yy635: + yy600: yych = *++p; if (yych == 'G') - goto yy636; + goto yy601; if (yych != 'g') - goto yy525; - yy636: + goto yy497; + yy601: yych = *++p; if (yych == 'E') - goto yy637; + goto yy602; if (yych != 'e') - goto yy525; - yy637: + goto yy497; + yy602: yych = *++p; if (yych == 'N') - goto yy638; + goto yy603; if (yych != 'n') - goto yy525; - yy638: + goto yy497; + yy603: yych = *++p; if (yych == 'D') - goto yy564; + goto yy529; if (yych == 'd') - goto yy564; - goto yy525; - yy639: + goto yy529; + goto yy497; + yy604: yych = *++p; if (yych == 'K') - goto yy564; + goto yy529; if (yych == 'k') - goto yy564; - goto yy525; - yy640: + goto yy529; + goto yy497; + yy605: yych = *++p; if (yych == 'R') - goto yy641; + goto yy606; if (yych != 'r') - goto yy525; - yy641: + goto yy497; + yy606: yych = *++p; if (yych == 'A') - goto yy642; + goto yy607; if (yych != 'a') - goto yy525; - yy642: + goto yy497; + yy607: yych = *++p; if (yych == 'M') - goto yy643; + goto yy608; if (yych != 'm') - goto yy525; - yy643: + goto yy497; + yy608: yych = *++p; if (yych == 'E') - goto yy564; + goto yy529; if (yych == 'e') - goto yy564; - goto yy525; - yy644: + goto yy529; + goto yy497; + yy609: yych = *++p; if (yych == 'M') - goto yy649; + goto yy614; if (yych == 'm') - goto yy649; - goto yy525; - yy645: + goto yy614; + goto yy497; + yy610: yych = *++p; if (yych == 'A') - goto yy646; + goto yy611; if (yych != 'a') - goto yy525; - yy646: + goto yy497; + yy611: yych = *++p; if (yych == 'D') - goto yy647; + goto yy612; if (yych != 'd') - goto yy525; - yy647: + goto yy497; + yy612: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= ' ') - goto yy565; + goto yy530; if (yych <= '.') - goto yy525; - goto yy567; + goto yy497; + goto yy532; } } else { if (yych <= 'D') { if (yych == '>') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= 'E') - goto yy648; + goto yy613; if (yych != 'e') - goto yy525; + goto yy497; } } - yy648: + yy613: yych = *++p; if (yych == 'R') - goto yy564; + goto yy529; if (yych == 'r') - goto yy564; - goto yy525; - yy649: + goto yy529; + goto yy497; + yy614: yych = *++p; if (yych == 'L') - goto yy564; + goto yy529; if (yych == 'l') - goto yy564; - goto yy525; - yy650: + goto yy529; + goto yy497; + yy615: yych = *++p; if (yych == 'A') - goto yy671; + goto yy636; if (yych == 'a') - goto yy671; - goto yy525; - yy651: + goto yy636; + goto yy497; + yy616: yych = *++p; if (yych <= 'R') { if (yych == 'O') - goto yy667; + goto yy632; if (yych <= 'Q') - goto yy525; - goto yy668; + goto yy497; + goto yy633; } else { if (yych <= 'o') { if (yych <= 'n') - goto yy525; - goto yy667; + goto yy497; + goto yy632; } else { if (yych == 'r') - goto yy668; - goto yy525; + goto yy633; + goto yy497; } } - yy652: + yy617: yych = *++p; if (yych <= 'G') { if (yych == 'E') - goto yy653; + goto yy618; if (yych <= 'F') - goto yy525; - goto yy654; + goto yy497; + goto yy619; } else { if (yych <= 'e') { if (yych <= 'd') - goto yy525; + goto yy497; } else { if (yych == 'g') - goto yy654; - goto yy525; + goto yy619; + goto yy497; } } - yy653: + yy618: yych = *++p; if (yych == 'L') - goto yy663; + goto yy628; if (yych == 'l') - goto yy663; - goto yy525; - yy654: + goto yy628; + goto yy497; + yy619: yych = *++p; if (yych <= 'U') { if (yych == 'C') - goto yy656; + goto yy621; if (yych <= 'T') - goto yy525; + goto yy497; } else { if (yych <= 'c') { if (yych <= 'b') - goto yy525; - goto yy656; + goto yy497; + goto yy621; } else { if (yych != 'u') - goto yy525; + goto yy497; } } yych = *++p; if (yych == 'R') - goto yy662; + goto yy627; if (yych == 'r') - goto yy662; - goto yy525; - yy656: + goto yy627; + goto yy497; + yy621: yych = *++p; if (yych == 'A') - goto yy657; + goto yy622; if (yych != 'a') - goto yy525; - yy657: + goto yy497; + yy622: yych = *++p; if (yych == 'P') - goto yy658; + goto yy623; if (yych != 'p') - goto yy525; - yy658: + goto yy497; + yy623: yych = *++p; if (yych == 'T') - goto yy659; + goto yy624; if (yych != 't') - goto yy525; - yy659: + goto yy497; + yy624: yych = *++p; if (yych == 'I') - goto yy660; + goto yy625; if (yych != 'i') - goto yy525; - yy660: + goto yy497; + yy625: yych = *++p; if (yych == 'O') - goto yy661; + goto yy626; if (yych != 'o') - goto yy525; - yy661: + goto yy497; + yy626: yych = *++p; if (yych == 'N') - goto yy564; + goto yy529; if (yych == 'n') - goto yy564; - goto yy525; - yy662: + goto yy529; + goto yy497; + yy627: yych = *++p; if (yych == 'E') - goto yy564; + goto yy529; if (yych == 'e') - goto yy564; - goto yy525; - yy663: + goto yy529; + goto yy497; + yy628: yych = *++p; if (yych == 'D') - goto yy664; + goto yy629; if (yych != 'd') - goto yy525; - yy664: + goto yy497; + yy629: yych = *++p; if (yych == 'S') - goto yy665; + goto yy630; if (yych != 's') - goto yy525; - yy665: + goto yy497; + yy630: yych = *++p; if (yych == 'E') - goto yy666; + goto yy631; if (yych != 'e') - goto yy525; - yy666: + goto yy497; + yy631: yych = *++p; if (yych == 'T') - goto yy564; + goto yy529; if (yych == 't') - goto yy564; - goto yy525; - yy667: + goto yy529; + goto yy497; + yy632: yych = *++p; if (yych == 'T') - goto yy669; + goto yy634; if (yych == 't') - goto yy669; - goto yy525; - yy668: + goto yy634; + goto yy497; + yy633: yych = *++p; if (yych == 'M') - goto yy564; + goto yy529; if (yych == 'm') - goto yy564; - goto yy525; - yy669: + goto yy529; + goto yy497; + yy634: yych = *++p; if (yych == 'E') - goto yy670; + goto yy635; if (yych != 'e') - goto yy525; - yy670: + goto yy497; + yy635: yych = *++p; if (yych == 'R') - goto yy564; + goto yy529; if (yych == 'r') - goto yy564; - goto yy525; - yy671: + goto yy529; + goto yy497; + yy636: yych = *++p; if (yych == 'M') - goto yy672; + goto yy637; if (yych != 'm') - goto yy525; - yy672: + goto yy497; + yy637: yych = *++p; if (yych == 'E') - goto yy673; + goto yy638; if (yych != 'e') - goto yy525; - yy673: + goto yy497; + yy638: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= ' ') - goto yy565; + goto yy530; if (yych <= '.') - goto yy525; - goto yy567; + goto yy497; + goto yy532; } } else { if (yych <= 'R') { if (yych == '>') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= 'S') - goto yy674; + goto yy639; if (yych != 's') - goto yy525; + goto yy497; } } - yy674: + yy639: yych = *++p; if (yych == 'E') - goto yy675; + goto yy640; if (yych != 'e') - goto yy525; - yy675: + goto yy497; + yy640: yych = *++p; if (yych == 'T') - goto yy564; + goto yy529; if (yych == 't') - goto yy564; - goto yy525; - yy676: + goto yy529; + goto yy497; + yy641: yych = *++p; if (yych <= 'V') { if (yych <= 'Q') { if (yych == 'A') - goto yy682; - goto yy525; + goto yy647; + goto yy497; } else { if (yych <= 'R') - goto yy564; + goto yy529; if (yych <= 'U') - goto yy525; - goto yy564; + goto yy497; + goto yy529; } } else { if (yych <= 'q') { if (yych == 'a') - goto yy682; - goto yy525; + goto yy647; + goto yy497; } else { if (yych <= 'r') - goto yy564; + goto yy529; if (yych == 'v') - goto yy564; - goto yy525; + goto yy529; + goto yy497; } } - yy677: + yy642: yych = *++p; if (yych == 'T') - goto yy678; + goto yy643; if (yych != 't') - goto yy525; - yy678: + goto yy497; + yy643: yych = *++p; if (yych == 'A') - goto yy679; + goto yy644; if (yych != 'a') - goto yy525; - yy679: + goto yy497; + yy644: yych = *++p; if (yych == 'I') - goto yy680; + goto yy645; if (yych != 'i') - goto yy525; - yy680: + goto yy497; + yy645: yych = *++p; if (yych == 'L') - goto yy681; + goto yy646; if (yych != 'l') - goto yy525; - yy681: + goto yy497; + yy646: yych = *++p; if (yych == 'S') - goto yy564; + goto yy529; if (yych == 's') - goto yy564; - goto yy525; - yy682: + goto yy529; + goto yy497; + yy647: yych = *++p; if (yych == 'L') - goto yy683; + goto yy648; if (yych != 'l') - goto yy525; - yy683: + goto yy497; + yy648: yych = *++p; if (yych == 'O') - goto yy684; + goto yy649; if (yych != 'o') - goto yy525; - yy684: + goto yy497; + yy649: yych = *++p; if (yych == 'G') - goto yy564; + goto yy529; if (yych == 'g') - goto yy564; - goto yy525; - yy685: + goto yy529; + goto yy497; + yy650: yych = *++p; if (yych == 'L') - goto yy695; + goto yy660; if (yych == 'l') - goto yy695; - goto yy525; - yy686: + goto yy660; + goto yy497; + yy651: yych = *++p; if (yych == 'N') - goto yy692; + goto yy657; if (yych == 'n') - goto yy692; - goto yy525; - yy687: + goto yy657; + goto yy497; + yy652: yych = *++p; if (yych == 'P') - goto yy688; + goto yy653; if (yych != 'p') - goto yy525; - yy688: + goto yy497; + yy653: yych = *++p; if (yych == 'T') - goto yy689; + goto yy654; if (yych != 't') - goto yy525; - yy689: + goto yy497; + yy654: yych = *++p; if (yych == 'I') - goto yy690; + goto yy655; if (yych != 'i') - goto yy525; - yy690: + goto yy497; + yy655: yych = *++p; if (yych == 'O') - goto yy691; + goto yy656; if (yych != 'o') - goto yy525; - yy691: + goto yy497; + yy656: yych = *++p; if (yych == 'N') - goto yy564; + goto yy529; if (yych == 'n') - goto yy564; - goto yy525; - yy692: + goto yy529; + goto yy497; + yy657: yych = *++p; if (yych == 'T') - goto yy693; + goto yy658; if (yych != 't') - goto yy525; - yy693: + goto yy497; + yy658: yych = *++p; if (yych == 'E') - goto yy694; + goto yy659; if (yych != 'e') - goto yy525; - yy694: + goto yy497; + yy659: yych = *++p; if (yych == 'R') - goto yy564; + goto yy529; if (yych == 'r') - goto yy564; - goto yy525; - yy695: + goto yy529; + goto yy497; + yy660: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= ' ') - goto yy565; + goto yy530; if (yych <= '.') - goto yy525; - goto yy567; + goto yy497; + goto yy532; } } else { if (yych <= 'F') { if (yych == '>') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= 'G') - goto yy696; + goto yy661; if (yych != 'g') - goto yy525; + goto yy497; } } - yy696: + yy661: yych = *++p; if (yych == 'R') - goto yy697; + goto yy662; if (yych != 'r') - goto yy525; - yy697: + goto yy497; + yy662: yych = *++p; if (yych == 'O') - goto yy698; + goto yy663; if (yych != 'o') - goto yy525; - yy698: + goto yy497; + yy663: yych = *++p; if (yych == 'U') - goto yy699; + goto yy664; if (yych != 'u') - goto yy525; - yy699: + goto yy497; + yy664: yych = *++p; if (yych == 'P') - goto yy564; + goto yy529; if (yych == 'p') - goto yy564; - goto yy525; - yy700: + goto yy529; + goto yy497; + yy665: yych = *++p; if (yych == 'D') - goto yy715; + goto yy680; if (yych == 'd') - goto yy715; - goto yy525; - yy701: + goto yy680; + goto yy497; + yy666: yych = *++p; if (yych == 'O') - goto yy708; + goto yy673; if (yych == 'o') - goto yy708; - goto yy525; - yy702: + goto yy673; + goto yy497; + yy667: yych = *++p; if (yych == 'S') - goto yy703; + goto yy668; if (yych != 's') - goto yy525; - yy703: + goto yy497; + yy668: yych = *++p; if (yych == 'E') - goto yy704; + goto yy669; if (yych != 'e') - goto yy525; - yy704: + goto yy497; + yy669: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= ' ') - goto yy565; + goto yy530; if (yych <= '.') - goto yy525; - goto yy567; + goto yy497; + goto yy532; } } else { if (yych <= 'E') { if (yych == '>') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= 'F') - goto yy705; + goto yy670; if (yych != 'f') - goto yy525; + goto yy497; } } - yy705: + yy670: yych = *++p; if (yych == 'O') - goto yy706; + goto yy671; if (yych != 'o') - goto yy525; - yy706: + goto yy497; + yy671: yych = *++p; if (yych == 'N') - goto yy707; + goto yy672; if (yych != 'n') - goto yy525; - yy707: + goto yy497; + yy672: yych = *++p; if (yych == 'T') - goto yy564; + goto yy529; if (yych == 't') - goto yy564; - goto yy525; - yy708: + goto yy529; + goto yy497; + yy673: yych = *++p; if (yych == 'C') - goto yy709; + goto yy674; if (yych != 'c') - goto yy525; - yy709: + goto yy497; + yy674: yych = *++p; if (yych == 'K') - goto yy710; + goto yy675; if (yych != 'k') - goto yy525; - yy710: + goto yy497; + yy675: yych = *++p; if (yych == 'Q') - goto yy711; + goto yy676; if (yych != 'q') - goto yy525; - yy711: + goto yy497; + yy676: yych = *++p; if (yych == 'U') - goto yy712; + goto yy677; if (yych != 'u') - goto yy525; - yy712: + goto yy497; + yy677: yych = *++p; if (yych == 'O') - goto yy713; + goto yy678; if (yych != 'o') - goto yy525; - yy713: + goto yy497; + yy678: yych = *++p; if (yych == 'T') - goto yy714; + goto yy679; if (yych != 't') - goto yy525; - yy714: + goto yy497; + yy679: yych = *++p; if (yych == 'E') - goto yy564; + goto yy529; if (yych == 'e') - goto yy564; - goto yy525; - yy715: + goto yy529; + goto yy497; + yy680: yych = *++p; if (yych == 'Y') - goto yy564; + goto yy529; if (yych == 'y') - goto yy564; - goto yy525; - yy716: + goto yy529; + goto yy497; + yy681: yych = *++p; if (yych == 'I') - goto yy727; + goto yy692; if (yych == 'i') - goto yy727; - goto yy525; - yy717: + goto yy692; + goto yy497; + yy682: yych = *++p; if (yych == 'T') - goto yy723; + goto yy688; if (yych == 't') - goto yy723; - goto yy525; - yy718: + goto yy688; + goto yy497; + yy683: yych = *++p; if (yych == 'D') - goto yy719; + goto yy684; if (yych != 'd') - goto yy525; - yy719: + goto yy497; + yy684: yych = *++p; if (yych == 'R') - goto yy720; + goto yy685; if (yych != 'r') - goto yy525; - yy720: + goto yy497; + yy685: yych = *++p; if (yych == 'E') - goto yy721; + goto yy686; if (yych != 'e') - goto yy525; - yy721: + goto yy497; + yy686: yych = *++p; if (yych == 'S') - goto yy722; + goto yy687; if (yych != 's') - goto yy525; - yy722: + goto yy497; + yy687: yych = *++p; if (yych == 'S') - goto yy564; + goto yy529; if (yych == 's') - goto yy564; - goto yy525; - yy723: + goto yy529; + goto yy497; + yy688: yych = *++p; if (yych == 'I') - goto yy724; + goto yy689; if (yych != 'i') - goto yy525; - yy724: + goto yy497; + yy689: yych = *++p; if (yych == 'C') - goto yy725; + goto yy690; if (yych != 'c') - goto yy525; - yy725: + goto yy497; + yy690: yych = *++p; if (yych == 'L') - goto yy726; + goto yy691; if (yych != 'l') - goto yy525; - yy726: + goto yy497; + yy691: yych = *++p; if (yych == 'E') - goto yy564; + goto yy529; if (yych == 'e') - goto yy564; - goto yy525; - yy727: + goto yy529; + goto yy497; + yy692: yych = *++p; if (yych == 'D') - goto yy728; + goto yy693; if (yych != 'd') - goto yy525; - yy728: + goto yy497; + yy693: yych = *++p; if (yych == 'E') - goto yy564; + goto yy529; if (yych == 'e') - goto yy564; - goto yy525; - yy729: + goto yy529; + goto yy497; + yy694: yych = *++p; if (yych == 'E') - goto yy605; + goto yy570; if (yych == 'e') - goto yy605; - goto yy525; - yy730: + goto yy570; + goto yy497; + yy695: yych = *++p; if (yych == 'R') - goto yy731; + goto yy696; if (yych != 'r') - goto yy525; - yy731: + goto yy497; + yy696: yych = *++p; if (yych == 'A') - goto yy732; + goto yy697; if (yych != 'a') - goto yy525; - yy732: + goto yy497; + yy697: yych = *++p; if (yych == 'M') - goto yy564; + goto yy529; if (yych == 'm') - goto yy564; - goto yy525; - yy733: + goto yy529; + goto yy497; + yy698: yych = *++p; if (yych <= '/') { if (yych <= 0x1F) { if (yych <= 0x08) - goto yy525; + goto yy497; if (yych <= '\r') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= ' ') - goto yy565; + goto yy530; if (yych <= '.') - goto yy525; - goto yy567; + goto yy497; + goto yy532; } } else { if (yych <= '@') { if (yych == '>') - goto yy565; - goto yy525; + goto yy530; + goto yy497; } else { if (yych <= 'A') - goto yy730; + goto yy695; if (yych == 'a') - goto yy730; - goto yy525; + goto yy695; + goto yy497; } } - yy734: + yy699: ++p; if ((yych = *p) <= 'U') { if (yych <= 'N') { if (yych == 'E') - goto yy590; - goto yy525; + goto yy555; + goto yy497; } else { if (yych <= 'O') - goto yy589; + goto yy554; if (yych <= 'T') - goto yy525; - goto yy588; + goto yy497; + goto yy553; } } else { if (yych <= 'n') { if (yych == 'e') - goto yy590; - goto yy525; + goto yy555; + goto yy497; } else { if (yych <= 'o') - goto yy589; + goto yy554; if (yych == 'u') - goto yy588; - goto yy525; + goto yy553; + goto yy497; } } } @@ -12231,817 +11697,737 @@ bufsize_t _scan_html_block_start_7(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= ';') { - if (yych != '\n') - goto yy739; - } else { - if (yych <= '<') - goto yy738; - if (yych <= 0x7F) - goto yy739; - if (yych >= 0xC2) - goto yy740; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy742; - if (yych == 0xED) - goto yy747; - goto yy743; - } else { - if (yych <= 0xF0) - goto yy744; - if (yych <= 0xF3) - goto yy745; - if (yych <= 0xF4) - goto yy746; - } - } - yy737 : { return 0; } - yy738: + yych = *p; + if (yych == '<') + goto yy704; + ++p; + yy703 : { return 0; } + yy704: yyaccept = 0; yych = *(marker = ++p); if (yych <= '@') { if (yych == '/') - goto yy750; - goto yy737; + goto yy708; + goto yy703; } else { if (yych <= 'Z') - goto yy748; + goto yy705; if (yych <= '`') - goto yy737; - if (yych <= 'z') - goto yy748; - goto yy737; - } - yy739: - yych = *++p; - goto yy737; - yy740: - yych = *++p; - if (yych <= 0x7F) - goto yy741; - if (yych <= 0xBF) - goto yy739; - yy741: - p = marker; - if (yyaccept == 0) { - goto yy737; - } else { - goto yy759; + goto yy703; + if (yych >= '{') + goto yy703; } - yy742: - yych = *++p; - if (yych <= 0x9F) - goto yy741; - if (yych <= 0xBF) - goto yy740; - goto yy741; - yy743: - yych = *++p; - if (yych <= 0x7F) - goto yy741; - if (yych <= 0xBF) - goto yy740; - goto yy741; - yy744: - yych = *++p; - if (yych <= 0x8F) - goto yy741; - if (yych <= 0xBF) - goto yy743; - goto yy741; - yy745: - yych = *++p; - if (yych <= 0x7F) - goto yy741; - if (yych <= 0xBF) - goto yy743; - goto yy741; - yy746: - yych = *++p; - if (yych <= 0x7F) - goto yy741; - if (yych <= 0x8F) - goto yy743; - goto yy741; - yy747: - yych = *++p; - if (yych <= 0x7F) - goto yy741; - if (yych <= 0x9F) - goto yy740; - goto yy741; - yy748: + yy705: ++p; yych = *p; if (yybm[0 + yych] & 1) { - goto yy748; + goto yy705; } if (yych <= ' ') { if (yych <= 0x08) - goto yy741; + goto yy707; if (yych <= '\r') - goto yy761; - if (yych <= 0x1F) - goto yy741; - goto yy761; + goto yy719; + if (yych >= ' ') + goto yy719; } else { if (yych <= '/') { - if (yych <= '.') - goto yy741; - goto yy763; + if (yych >= '/') + goto yy721; } else { if (yych == '>') - goto yy755; - goto yy741; + goto yy713; } } - yy750: + yy707: + p = marker; + if (yyaccept == 0) { + goto yy703; + } else { + goto yy717; + } + yy708: yych = *++p; if (yych <= '@') - goto yy741; + goto yy707; if (yych <= 'Z') - goto yy751; + goto yy709; if (yych <= '`') - goto yy741; + goto yy707; if (yych >= '{') - goto yy741; - yy751: + goto yy707; + yy709: ++p; yych = *p; if (yybm[0 + yych] & 2) { - goto yy753; + goto yy711; } if (yych <= '=') { if (yych <= '-') { if (yych <= ',') - goto yy741; - goto yy751; + goto yy707; + goto yy709; } else { if (yych <= '/') - goto yy741; + goto yy707; if (yych <= '9') - goto yy751; - goto yy741; + goto yy709; + goto yy707; } } else { if (yych <= 'Z') { if (yych <= '>') - goto yy755; + goto yy713; if (yych <= '@') - goto yy741; - goto yy751; + goto yy707; + goto yy709; } else { if (yych <= '`') - goto yy741; + goto yy707; if (yych <= 'z') - goto yy751; - goto yy741; + goto yy709; + goto yy707; } } - yy753: + yy711: ++p; yych = *p; if (yybm[0 + yych] & 2) { - goto yy753; + goto yy711; } if (yych != '>') - goto yy741; - yy755: + goto yy707; + yy713: ++p; yych = *p; if (yybm[0 + yych] & 4) { - goto yy755; + goto yy713; } if (yych <= 0x08) - goto yy741; + goto yy707; if (yych <= '\n') - goto yy757; + goto yy715; if (yych <= '\v') - goto yy741; + goto yy707; if (yych <= '\r') - goto yy760; - goto yy741; - yy757: + goto yy718; + goto yy707; + yy715: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0 + yych] & 4) { - goto yy755; + goto yy713; } if (yych <= 0x08) - goto yy759; + goto yy717; if (yych <= '\n') - goto yy757; + goto yy715; if (yych <= '\v') - goto yy759; + goto yy717; if (yych <= '\r') - goto yy760; - yy759 : { return 7; } - yy760: + goto yy718; + yy717 : { return 7; } + yy718: yych = *++p; - goto yy759; - yy761: + goto yy717; + yy719: ++p; yych = *p; if (yych <= ':') { if (yych <= ' ') { if (yych <= 0x08) - goto yy741; + goto yy707; if (yych <= '\r') - goto yy761; + goto yy719; if (yych <= 0x1F) - goto yy741; - goto yy761; + goto yy707; + goto yy719; } else { if (yych == '/') - goto yy763; + goto yy721; if (yych <= '9') - goto yy741; - goto yy764; + goto yy707; + goto yy722; } } else { if (yych <= 'Z') { if (yych == '>') - goto yy755; + goto yy713; if (yych <= '@') - goto yy741; - goto yy764; + goto yy707; + goto yy722; } else { if (yych <= '_') { if (yych <= '^') - goto yy741; - goto yy764; + goto yy707; + goto yy722; } else { if (yych <= '`') - goto yy741; + goto yy707; if (yych <= 'z') - goto yy764; - goto yy741; + goto yy722; + goto yy707; } } } - yy763: + yy721: yych = *++p; if (yych == '>') - goto yy755; - goto yy741; - yy764: + goto yy713; + goto yy707; + yy722: ++p; yych = *p; if (yybm[0 + yych] & 16) { - goto yy764; + goto yy722; } if (yych <= ',') { if (yych <= '\r') { if (yych <= 0x08) - goto yy741; + goto yy707; } else { if (yych != ' ') - goto yy741; + goto yy707; } } else { if (yych <= '<') { if (yych <= '/') - goto yy763; - goto yy741; + goto yy721; + goto yy707; } else { if (yych <= '=') - goto yy768; + goto yy726; if (yych <= '>') - goto yy755; - goto yy741; + goto yy713; + goto yy707; } } - yy766: + yy724: ++p; yych = *p; if (yych <= '<') { if (yych <= ' ') { if (yych <= 0x08) - goto yy741; + goto yy707; if (yych <= '\r') - goto yy766; + goto yy724; if (yych <= 0x1F) - goto yy741; - goto yy766; + goto yy707; + goto yy724; } else { if (yych <= '/') { if (yych <= '.') - goto yy741; - goto yy763; + goto yy707; + goto yy721; } else { if (yych == ':') - goto yy764; - goto yy741; + goto yy722; + goto yy707; } } } else { if (yych <= 'Z') { if (yych <= '=') - goto yy768; + goto yy726; if (yych <= '>') - goto yy755; + goto yy713; if (yych <= '@') - goto yy741; - goto yy764; + goto yy707; + goto yy722; } else { if (yych <= '_') { if (yych <= '^') - goto yy741; - goto yy764; + goto yy707; + goto yy722; } else { if (yych <= '`') - goto yy741; + goto yy707; if (yych <= 'z') - goto yy764; - goto yy741; + goto yy722; + goto yy707; } } } - yy768: + yy726: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy770; + goto yy728; } if (yych <= 0xE0) { if (yych <= '"') { if (yych <= 0x00) - goto yy741; + goto yy707; if (yych >= '!') - goto yy781; + goto yy739; } else { if (yych <= '\'') - goto yy779; + goto yy737; if (yych <= 0xC1) - goto yy741; + goto yy707; if (yych <= 0xDF) - goto yy772; - goto yy773; + goto yy730; + goto yy731; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy778; - goto yy774; + goto yy736; + goto yy732; } else { if (yych <= 0xF0) - goto yy775; + goto yy733; if (yych <= 0xF3) - goto yy776; + goto yy734; if (yych <= 0xF4) - goto yy777; - goto yy741; + goto yy735; + goto yy707; } } ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy770; + goto yy728; } if (yych <= 0xDF) { if (yych <= '\'') { if (yych <= 0x00) - goto yy741; + goto yy707; if (yych <= ' ') - goto yy804; + goto yy762; if (yych <= '"') - goto yy781; - goto yy779; + goto yy739; + goto yy737; } else { if (yych == '>') - goto yy755; + goto yy713; if (yych <= 0xC1) - goto yy741; - goto yy772; + goto yy707; + goto yy730; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy773; + goto yy731; if (yych == 0xED) - goto yy778; - goto yy774; + goto yy736; + goto yy732; } else { if (yych <= 0xF0) - goto yy775; + goto yy733; if (yych <= 0xF3) - goto yy776; + goto yy734; if (yych <= 0xF4) - goto yy777; - goto yy741; + goto yy735; + goto yy707; } } - yy770: + yy728: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy770; + goto yy728; } if (yych <= 0xE0) { if (yych <= '=') { if (yych <= 0x00) - goto yy741; + goto yy707; if (yych <= ' ') - goto yy798; - goto yy741; + goto yy756; + goto yy707; } else { if (yych <= '>') - goto yy755; + goto yy713; if (yych <= 0xC1) - goto yy741; + goto yy707; if (yych >= 0xE0) - goto yy773; + goto yy731; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy778; - goto yy774; + goto yy736; + goto yy732; } else { if (yych <= 0xF0) - goto yy775; + goto yy733; if (yych <= 0xF3) - goto yy776; + goto yy734; if (yych <= 0xF4) - goto yy777; - goto yy741; + goto yy735; + goto yy707; } } - yy772: + yy730: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy770; - goto yy741; - yy773: + goto yy728; + goto yy707; + yy731: ++p; yych = *p; if (yych <= 0x9F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy772; - goto yy741; - yy774: + goto yy730; + goto yy707; + yy732: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy772; - goto yy741; - yy775: + goto yy730; + goto yy707; + yy733: ++p; yych = *p; if (yych <= 0x8F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy774; - goto yy741; - yy776: + goto yy732; + goto yy707; + yy734: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy774; - goto yy741; - yy777: + goto yy732; + goto yy707; + yy735: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0x8F) - goto yy774; - goto yy741; - yy778: + goto yy732; + goto yy707; + yy736: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0x9F) - goto yy772; - goto yy741; - yy779: + goto yy730; + goto yy707; + yy737: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy779; + goto yy737; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy741; + goto yy707; if (yych <= '\'') - goto yy790; - goto yy741; + goto yy748; + goto yy707; } else { if (yych <= 0xDF) - goto yy791; + goto yy749; if (yych <= 0xE0) - goto yy792; - goto yy793; + goto yy750; + goto yy751; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy797; + goto yy755; if (yych <= 0xEF) - goto yy793; - goto yy794; + goto yy751; + goto yy752; } else { if (yych <= 0xF3) - goto yy795; + goto yy753; if (yych <= 0xF4) - goto yy796; - goto yy741; + goto yy754; + goto yy707; } } - yy781: + yy739: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy781; + goto yy739; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy741; + goto yy707; if (yych <= '"') - goto yy790; - goto yy741; + goto yy748; + goto yy707; } else { if (yych <= 0xDF) - goto yy783; + goto yy741; if (yych <= 0xE0) - goto yy784; - goto yy785; + goto yy742; + goto yy743; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy789; + goto yy747; if (yych <= 0xEF) - goto yy785; - goto yy786; + goto yy743; + goto yy744; } else { if (yych <= 0xF3) - goto yy787; + goto yy745; if (yych <= 0xF4) - goto yy788; - goto yy741; + goto yy746; + goto yy707; } } - yy783: + yy741: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy781; - goto yy741; - yy784: + goto yy739; + goto yy707; + yy742: ++p; yych = *p; if (yych <= 0x9F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy783; - goto yy741; - yy785: + goto yy741; + goto yy707; + yy743: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy783; - goto yy741; - yy786: - ++p; + goto yy741; + goto yy707; + yy744: + ++p; yych = *p; if (yych <= 0x8F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy785; - goto yy741; - yy787: + goto yy743; + goto yy707; + yy745: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy785; - goto yy741; - yy788: + goto yy743; + goto yy707; + yy746: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0x8F) - goto yy785; - goto yy741; - yy789: + goto yy743; + goto yy707; + yy747: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0x9F) - goto yy783; - goto yy741; - yy790: + goto yy741; + goto yy707; + yy748: ++p; yych = *p; if (yych <= ' ') { if (yych <= 0x08) - goto yy741; + goto yy707; if (yych <= '\r') - goto yy761; + goto yy719; if (yych <= 0x1F) - goto yy741; - goto yy761; + goto yy707; + goto yy719; } else { if (yych <= '/') { if (yych <= '.') - goto yy741; - goto yy763; + goto yy707; + goto yy721; } else { if (yych == '>') - goto yy755; - goto yy741; + goto yy713; + goto yy707; } } - yy791: + yy749: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy779; - goto yy741; - yy792: + goto yy737; + goto yy707; + yy750: ++p; yych = *p; if (yych <= 0x9F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy791; - goto yy741; - yy793: + goto yy749; + goto yy707; + yy751: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy791; - goto yy741; - yy794: + goto yy749; + goto yy707; + yy752: ++p; yych = *p; if (yych <= 0x8F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy793; - goto yy741; - yy795: + goto yy751; + goto yy707; + yy753: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0xBF) - goto yy793; - goto yy741; - yy796: + goto yy751; + goto yy707; + yy754: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0x8F) - goto yy793; - goto yy741; - yy797: + goto yy751; + goto yy707; + yy755: ++p; yych = *p; if (yych <= 0x7F) - goto yy741; + goto yy707; if (yych <= 0x9F) - goto yy791; - goto yy741; - yy798: + goto yy749; + goto yy707; + yy756: ++p; yych = *p; if (yych <= '@') { if (yych <= '"') { if (yych <= '\r') { if (yych <= 0x00) - goto yy741; + goto yy707; if (yych <= 0x08) - goto yy770; - goto yy798; + goto yy728; + goto yy756; } else { if (yych == ' ') - goto yy798; + goto yy756; if (yych <= '!') - goto yy770; - goto yy741; + goto yy728; + goto yy707; } } else { if (yych <= ':') { if (yych == '\'') - goto yy741; + goto yy707; if (yych <= '9') - goto yy770; + goto yy728; } else { if (yych <= ';') - goto yy770; + goto yy728; if (yych <= '=') - goto yy741; + goto yy707; if (yych <= '>') - goto yy755; - goto yy770; + goto yy713; + goto yy728; } } } else { if (yych <= 0xDF) { if (yych <= '`') { if (yych <= 'Z') - goto yy800; + goto yy758; if (yych <= '^') - goto yy770; + goto yy728; if (yych >= '`') - goto yy741; + goto yy707; } else { if (yych <= 'z') - goto yy800; + goto yy758; if (yych <= 0x7F) - goto yy770; + goto yy728; if (yych <= 0xC1) - goto yy741; - goto yy772; + goto yy707; + goto yy730; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy773; + goto yy731; if (yych == 0xED) - goto yy778; - goto yy774; + goto yy736; + goto yy732; } else { if (yych <= 0xF0) - goto yy775; + goto yy733; if (yych <= 0xF3) - goto yy776; + goto yy734; if (yych <= 0xF4) - goto yy777; - goto yy741; + goto yy735; + goto yy707; } } } - yy800: + yy758: ++p; yych = *p; if (yych <= '>') { if (yych <= '&') { if (yych <= 0x1F) { if (yych <= 0x00) - goto yy741; + goto yy707; if (yych <= 0x08) - goto yy770; + goto yy728; if (yych >= 0x0E) - goto yy770; + goto yy728; } else { if (yych <= ' ') - goto yy802; + goto yy760; if (yych == '"') - goto yy741; - goto yy770; + goto yy707; + goto yy728; } } else { if (yych <= '/') { if (yych <= '\'') - goto yy741; + goto yy707; if (yych <= ',') - goto yy770; + goto yy728; if (yych <= '.') - goto yy800; - goto yy770; + goto yy758; + goto yy728; } else { if (yych <= ';') { if (yych <= ':') - goto yy800; - goto yy770; + goto yy758; + goto yy728; } else { if (yych <= '<') - goto yy741; + goto yy707; if (yych <= '=') - goto yy768; - goto yy755; + goto yy726; + goto yy713; } } } @@ -13049,1700 +12435,196 @@ bufsize_t _scan_html_block_start_7(const unsigned char *p) { if (yych <= 0xC1) { if (yych <= '_') { if (yych <= '@') - goto yy770; + goto yy728; if (yych <= 'Z') - goto yy800; + goto yy758; if (yych <= '^') - goto yy770; - goto yy800; + goto yy728; + goto yy758; } else { if (yych <= '`') - goto yy741; + goto yy707; if (yych <= 'z') - goto yy800; + goto yy758; if (yych <= 0x7F) - goto yy770; - goto yy741; + goto yy728; + goto yy707; } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy772; + goto yy730; if (yych <= 0xE0) - goto yy773; + goto yy731; if (yych <= 0xEC) - goto yy774; - goto yy778; + goto yy732; + goto yy736; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy774; - goto yy775; + goto yy732; + goto yy733; } else { if (yych <= 0xF3) - goto yy776; + goto yy734; if (yych <= 0xF4) - goto yy777; - goto yy741; + goto yy735; + goto yy707; } } } } - yy802: + yy760: ++p; yych = *p; if (yych <= '@') { if (yych <= '&') { if (yych <= 0x1F) { if (yych <= 0x00) - goto yy741; + goto yy707; if (yych <= 0x08) - goto yy770; + goto yy728; if (yych <= '\r') - goto yy802; - goto yy770; + goto yy760; + goto yy728; } else { if (yych <= ' ') - goto yy802; + goto yy760; if (yych == '"') - goto yy741; - goto yy770; + goto yy707; + goto yy728; } } else { if (yych <= ';') { if (yych <= '\'') - goto yy741; + goto yy707; if (yych == ':') - goto yy800; - goto yy770; + goto yy758; + goto yy728; } else { if (yych <= '<') - goto yy741; + goto yy707; if (yych <= '=') - goto yy768; + goto yy726; if (yych <= '>') - goto yy755; - goto yy770; + goto yy713; + goto yy728; } } } else { if (yych <= 0xDF) { if (yych <= '`') { if (yych <= 'Z') - goto yy800; + goto yy758; if (yych <= '^') - goto yy770; + goto yy728; if (yych <= '_') - goto yy800; - goto yy741; + goto yy758; + goto yy707; } else { if (yych <= 'z') - goto yy800; + goto yy758; if (yych <= 0x7F) - goto yy770; + goto yy728; if (yych <= 0xC1) - goto yy741; - goto yy772; + goto yy707; + goto yy730; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy773; + goto yy731; if (yych == 0xED) - goto yy778; - goto yy774; + goto yy736; + goto yy732; } else { if (yych <= 0xF0) - goto yy775; + goto yy733; if (yych <= 0xF3) - goto yy776; + goto yy734; if (yych <= 0xF4) - goto yy777; - goto yy741; + goto yy735; + goto yy707; } } } - yy804: + yy762: ++p; yych = *p; if (yych <= '@') { if (yych <= '"') { if (yych <= '\r') { if (yych <= 0x00) - goto yy741; + goto yy707; if (yych <= 0x08) - goto yy770; - goto yy804; + goto yy728; + goto yy762; } else { if (yych == ' ') - goto yy804; + goto yy762; if (yych <= '!') - goto yy770; - goto yy781; + goto yy728; + goto yy739; } } else { if (yych <= ':') { if (yych == '\'') - goto yy779; + goto yy737; if (yych <= '9') - goto yy770; - goto yy800; + goto yy728; + goto yy758; } else { if (yych <= ';') - goto yy770; + goto yy728; if (yych <= '=') - goto yy741; + goto yy707; if (yych <= '>') - goto yy755; - goto yy770; + goto yy713; + goto yy728; } } } else { if (yych <= 0xDF) { - if (yych <= '`') { - if (yych <= 'Z') - goto yy800; - if (yych <= '^') - goto yy770; - if (yych <= '_') - goto yy800; - goto yy741; - } else { - if (yych <= 'z') - goto yy800; - if (yych <= 0x7F) - goto yy770; - if (yych <= 0xC1) - goto yy741; - goto yy772; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy773; - if (yych == 0xED) - goto yy778; - goto yy774; - } else { - if (yych <= 0xF0) - goto yy775; - if (yych <= 0xF3) - goto yy776; - if (yych <= 0xF4) - goto yy777; - goto yy741; - } - } - } - } -} - -// Try to match an HTML block end line of type 1 -bufsize_t _scan_html_block_end_1(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[] = { - 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 64, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 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, - }; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= ';') { - if (yych != '\n') - goto yy809; - } else { - if (yych <= '<') - goto yy810; - if (yych <= 0x7F) - goto yy809; - if (yych >= 0xC2) - goto yy811; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy813; - if (yych == 0xED) - goto yy818; - goto yy814; - } else { - if (yych <= 0xF0) - goto yy815; - if (yych <= 0xF3) - goto yy816; - if (yych <= 0xF4) - goto yy817; - } - } - yy808 : { return 0; } - yy809: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych == '\n') - goto yy808; - goto yy823; - } else { - if (yych <= 0xC1) - goto yy808; - if (yych <= 0xF4) - goto yy823; - goto yy808; - } - yy810: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= '/') { - if (yych == '\n') - goto yy808; - if (yych <= '.') - goto yy823; - goto yy819; - } else { - if (yych <= 0x7F) - goto yy823; - if (yych <= 0xC1) - goto yy808; - if (yych <= 0xF4) - goto yy823; - goto yy808; - } - yy811: - yych = *++p; - if (yych <= 0x7F) - goto yy812; - if (yych <= 0xBF) - goto yy809; - yy812: - p = marker; - if (yyaccept == 0) { - goto yy808; - } else { - goto yy840; - } - yy813: - yych = *++p; - if (yych <= 0x9F) - goto yy812; - if (yych <= 0xBF) - goto yy811; - goto yy812; - yy814: - yych = *++p; - if (yych <= 0x7F) - goto yy812; - if (yych <= 0xBF) - goto yy811; - goto yy812; - yy815: - yych = *++p; - if (yych <= 0x8F) - goto yy812; - if (yych <= 0xBF) - goto yy814; - goto yy812; - yy816: - yych = *++p; - if (yych <= 0x7F) - goto yy812; - if (yych <= 0xBF) - goto yy814; - goto yy812; - yy817: - yych = *++p; - if (yych <= 0x7F) - goto yy812; - if (yych <= 0x8F) - goto yy814; - goto yy812; - yy818: - yych = *++p; - if (yych <= 0x7F) - goto yy812; - if (yych <= 0x9F) - goto yy811; - goto yy812; - yy819: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 's') { - if (yych <= 'R') { - if (yych <= '\n') { - if (yych <= '\t') - goto yy822; - goto yy812; - } else { - if (yych == 'P') - goto yy831; - goto yy822; - } - } else { - if (yych <= 'o') { - if (yych <= 'S') - goto yy832; - goto yy822; - } else { - if (yych <= 'p') - goto yy831; - if (yych <= 'r') - goto yy822; - goto yy832; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) - goto yy822; - goto yy812; - } else { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - goto yy826; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy830; - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - yy820: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xDF) { - if (yych <= '.') { - if (yych == '\n') - goto yy812; - } else { - if (yych <= '/') - goto yy819; - if (yych <= 0x7F) - goto yy822; - if (yych <= 0xC1) - goto yy812; - goto yy824; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy825; - if (yych == 0xED) - goto yy830; - goto yy826; - } else { - if (yych <= 0xF0) - goto yy827; - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - yy822: - ++p; - yych = *p; - yy823: - if (yybm[0 + yych] & 128) { - goto yy822; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') - goto yy812; - if (yych <= '<') - goto yy820; - goto yy812; - } else { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - goto yy826; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy830; - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - yy824: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy812; - if (yych <= 0xBF) - goto yy822; - goto yy812; - yy825: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy812; - if (yych <= 0xBF) - goto yy824; - goto yy812; - yy826: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy812; - if (yych <= 0xBF) - goto yy824; - goto yy812; - yy827: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy812; - if (yych <= 0xBF) - goto yy826; - goto yy812; - yy828: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy812; - if (yych <= 0xBF) - goto yy826; - goto yy812; - yy829: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy812; - if (yych <= 0x8F) - goto yy826; - goto yy812; - yy830: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy812; - if (yych <= 0x9F) - goto yy824; - goto yy812; - yy831: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xC1) { - if (yych <= 'R') { - if (yych == '\n') - goto yy812; - if (yych <= 'Q') - goto yy822; - goto yy843; - } else { - if (yych == 'r') - goto yy843; - if (yych <= 0x7F) - goto yy822; - goto yy812; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - if (yych <= 0xEC) - goto yy826; - goto yy830; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - yy832: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 't') { - if (yych <= 'S') { - if (yych <= '\n') { - if (yych <= '\t') - goto yy822; - goto yy812; - } else { - if (yych == 'C') - goto yy834; - goto yy822; - } - } else { - if (yych <= 'b') { - if (yych >= 'U') - goto yy822; - } else { - if (yych <= 'c') - goto yy834; - if (yych <= 's') - goto yy822; - } - } - } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) - goto yy822; - goto yy812; - } else { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - goto yy826; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy830; - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xC1) { - if (yych <= 'Y') { - if (yych == '\n') - goto yy812; - if (yych <= 'X') - goto yy822; - goto yy841; - } else { - if (yych == 'y') - goto yy841; - if (yych <= 0x7F) - goto yy822; - goto yy812; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - if (yych <= 0xEC) - goto yy826; - goto yy830; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - yy834: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xC1) { - if (yych <= 'R') { - if (yych == '\n') - goto yy812; - if (yych <= 'Q') - goto yy822; - } else { - if (yych == 'r') - goto yy835; - if (yych <= 0x7F) - goto yy822; - goto yy812; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - if (yych <= 0xEC) - goto yy826; - goto yy830; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - yy835: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xC1) { - if (yych <= 'I') { - if (yych == '\n') - goto yy812; - if (yych <= 'H') - goto yy822; - } else { - if (yych == 'i') - goto yy836; - if (yych <= 0x7F) - goto yy822; - goto yy812; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - if (yych <= 0xEC) - goto yy826; - goto yy830; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - yy836: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xC1) { - if (yych <= 'P') { - if (yych == '\n') - goto yy812; - if (yych <= 'O') - goto yy822; - } else { - if (yych == 'p') - goto yy837; - if (yych <= 0x7F) - goto yy822; - goto yy812; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - if (yych <= 0xEC) - goto yy826; - goto yy830; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - yy837: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xC1) { - if (yych <= 'T') { - if (yych == '\n') - goto yy812; - if (yych <= 'S') - goto yy822; - } else { - if (yych == 't') - goto yy838; - if (yych <= 0x7F) - goto yy822; - goto yy812; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - if (yych <= 0xEC) - goto yy826; - goto yy830; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - yy838: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xDF) { - if (yych <= '=') { - if (yych == '\n') - goto yy812; - goto yy822; - } else { - if (yych <= '>') - goto yy839; - if (yych <= 0x7F) - goto yy822; - if (yych <= 0xC1) - goto yy812; - goto yy824; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy825; - if (yych == 0xED) - goto yy830; - goto yy826; - } else { - if (yych <= 0xF0) - goto yy827; - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - yy839: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0 + yych] & 128) { - goto yy822; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') - goto yy840; - if (yych <= '<') - goto yy820; - } else { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - goto yy826; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy830; - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - } - } - yy840 : { return (bufsize_t)(p - start); } - yy841: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xC1) { - if (yych <= 'L') { - if (yych == '\n') - goto yy812; - if (yych <= 'K') - goto yy822; - } else { - if (yych == 'l') - goto yy842; - if (yych <= 0x7F) - goto yy822; - goto yy812; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - if (yych <= 0xEC) - goto yy826; - goto yy830; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - yy842: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xC1) { - if (yych <= 'E') { - if (yych == '\n') - goto yy812; - if (yych <= 'D') - goto yy822; - goto yy838; - } else { - if (yych == 'e') - goto yy838; - if (yych <= 0x7F) - goto yy822; - goto yy812; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - if (yych <= 0xEC) - goto yy826; - goto yy830; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - yy843: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy820; - } - if (yych <= 0xC1) { - if (yych <= 'E') { - if (yych == '\n') - goto yy812; - if (yych <= 'D') - goto yy822; - goto yy838; - } else { - if (yych == 'e') - goto yy838; - if (yych <= 0x7F) - goto yy822; - goto yy812; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy824; - if (yych <= 0xE0) - goto yy825; - if (yych <= 0xEC) - goto yy826; - goto yy830; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy826; - goto yy827; - } else { - if (yych <= 0xF3) - goto yy828; - if (yych <= 0xF4) - goto yy829; - goto yy812; - } - } - } - } -} - -// Try to match an HTML block end line of type 2 -bufsize_t _scan_html_block_end_2(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[] = { - 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 64, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 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, - }; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= ',') { - if (yych != '\n') - goto yy847; - } else { - if (yych <= '-') - goto yy848; - if (yych <= 0x7F) - goto yy847; - if (yych >= 0xC2) - goto yy849; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy851; - if (yych == 0xED) - goto yy856; - goto yy852; - } else { - if (yych <= 0xF0) - goto yy853; - if (yych <= 0xF3) - goto yy854; - if (yych <= 0xF4) - goto yy855; - } - } - yy846 : { return 0; } - yy847: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych == '\n') - goto yy846; - goto yy860; - } else { - if (yych <= 0xC1) - goto yy846; - if (yych <= 0xF4) - goto yy860; - goto yy846; - } - yy848: - yyaccept = 0; - yych = *(marker = ++p); - if (yybm[0 + yych] & 64) { - goto yy857; - } - if (yych <= 0x7F) { - if (yych == '\n') - goto yy846; - goto yy860; - } else { - if (yych <= 0xC1) - goto yy846; - if (yych <= 0xF4) - goto yy860; - goto yy846; - } - yy849: - yych = *++p; - if (yych <= 0x7F) - goto yy850; - if (yych <= 0xBF) - goto yy847; - yy850: - p = marker; - if (yyaccept == 0) { - goto yy846; - } else { - goto yy870; - } - yy851: - yych = *++p; - if (yych <= 0x9F) - goto yy850; - if (yych <= 0xBF) - goto yy849; - goto yy850; - yy852: - yych = *++p; - if (yych <= 0x7F) - goto yy850; - if (yych <= 0xBF) - goto yy849; - goto yy850; - yy853: - yych = *++p; - if (yych <= 0x8F) - goto yy850; - if (yych <= 0xBF) - goto yy852; - goto yy850; - yy854: - yych = *++p; - if (yych <= 0x7F) - goto yy850; - if (yych <= 0xBF) - goto yy852; - goto yy850; - yy855: - yych = *++p; - if (yych <= 0x7F) - goto yy850; - if (yych <= 0x8F) - goto yy852; - goto yy850; - yy856: - yych = *++p; - if (yych <= 0x7F) - goto yy850; - if (yych <= 0x9F) - goto yy849; - goto yy850; - yy857: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy857; - } - if (yych <= 0xDF) { - if (yych <= '=') { - if (yych == '\n') - goto yy850; - } else { - if (yych <= '>') - goto yy869; - if (yych <= 0x7F) - goto yy859; - if (yych <= 0xC1) - goto yy850; - goto yy861; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy862; - if (yych == 0xED) - goto yy867; - goto yy863; - } else { - if (yych <= 0xF0) - goto yy864; - if (yych <= 0xF3) - goto yy865; - if (yych <= 0xF4) - goto yy866; - goto yy850; - } - } - yy859: - ++p; - yych = *p; - yy860: - if (yybm[0 + yych] & 128) { - goto yy859; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') - goto yy850; - if (yych <= '-') - goto yy868; - goto yy850; - } else { - if (yych <= 0xDF) - goto yy861; - if (yych <= 0xE0) - goto yy862; - goto yy863; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy867; - if (yych <= 0xEF) - goto yy863; - goto yy864; - } else { - if (yych <= 0xF3) - goto yy865; - if (yych <= 0xF4) - goto yy866; - goto yy850; - } - } - yy861: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy850; - if (yych <= 0xBF) - goto yy859; - goto yy850; - yy862: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy850; - if (yych <= 0xBF) - goto yy861; - goto yy850; - yy863: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy850; - if (yych <= 0xBF) - goto yy861; - goto yy850; - yy864: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy850; - if (yych <= 0xBF) - goto yy863; - goto yy850; - yy865: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy850; - if (yych <= 0xBF) - goto yy863; - goto yy850; - yy866: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy850; - if (yych <= 0x8F) - goto yy863; - goto yy850; - yy867: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy850; - if (yych <= 0x9F) - goto yy861; - goto yy850; - yy868: - ++p; - yych = *p; - if (yybm[0 + yych] & 128) { - goto yy859; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') - goto yy850; - if (yych <= '-') - goto yy857; - goto yy850; - } else { - if (yych <= 0xDF) - goto yy861; - if (yych <= 0xE0) - goto yy862; - goto yy863; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy867; - if (yych <= 0xEF) - goto yy863; - goto yy864; - } else { - if (yych <= 0xF3) - goto yy865; - if (yych <= 0xF4) - goto yy866; - goto yy850; - } - } - yy869: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0 + yych] & 128) { - goto yy859; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') - goto yy870; - if (yych <= '-') - goto yy868; - } else { - if (yych <= 0xDF) - goto yy861; - if (yych <= 0xE0) - goto yy862; - goto yy863; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy867; - if (yych <= 0xEF) - goto yy863; - goto yy864; - } else { - if (yych <= 0xF3) - goto yy865; - if (yych <= 0xF4) - goto yy866; - } - } - yy870 : { return (bufsize_t)(p - start); } - } -} - -// Try to match an HTML block end line of type 3 -bufsize_t _scan_html_block_end_3(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[] = { - 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 64, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 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, - }; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= '>') { - if (yych != '\n') - goto yy874; - } else { - if (yych <= '?') - goto yy875; - if (yych <= 0x7F) - goto yy874; - if (yych >= 0xC2) - goto yy876; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy878; - if (yych == 0xED) - goto yy883; - goto yy879; - } else { - if (yych <= 0xF0) - goto yy880; - if (yych <= 0xF3) - goto yy881; - if (yych <= 0xF4) - goto yy882; - } - } - yy873 : { return 0; } - yy874: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych == '\n') - goto yy873; - goto yy889; - } else { - if (yych <= 0xC1) - goto yy873; - if (yych <= 0xF4) - goto yy889; - goto yy873; - } - yy875: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= '>') { - if (yych == '\n') - goto yy873; - if (yych <= '=') - goto yy889; - goto yy884; - } else { - if (yych <= 0x7F) - goto yy889; - if (yych <= 0xC1) - goto yy873; - if (yych <= 0xF4) - goto yy889; - goto yy873; - } - yy876: - yych = *++p; - if (yych <= 0x7F) - goto yy877; - if (yych <= 0xBF) - goto yy874; - yy877: - p = marker; - if (yyaccept == 0) { - goto yy873; - } else { - goto yy885; - } - yy878: - yych = *++p; - if (yych <= 0x9F) - goto yy877; - if (yych <= 0xBF) - goto yy876; - goto yy877; - yy879: - yych = *++p; - if (yych <= 0x7F) - goto yy877; - if (yych <= 0xBF) - goto yy876; - goto yy877; - yy880: - yych = *++p; - if (yych <= 0x8F) - goto yy877; - if (yych <= 0xBF) - goto yy879; - goto yy877; - yy881: - yych = *++p; - if (yych <= 0x7F) - goto yy877; - if (yych <= 0xBF) - goto yy879; - goto yy877; - yy882: - yych = *++p; - if (yych <= 0x7F) - goto yy877; - if (yych <= 0x8F) - goto yy879; - goto yy877; - yy883: - yych = *++p; - if (yych <= 0x7F) - goto yy877; - if (yych <= 0x9F) - goto yy876; - goto yy877; - yy884: - yyaccept = 1; - marker = ++p; - yych = *p; - if (yybm[0 + yych] & 128) { - goto yy888; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') - goto yy885; - if (yych <= '?') - goto yy886; - } else { - if (yych <= 0xDF) - goto yy890; - if (yych <= 0xE0) - goto yy891; - goto yy892; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy896; - if (yych <= 0xEF) - goto yy892; - goto yy893; - } else { - if (yych <= 0xF3) - goto yy894; - if (yych <= 0xF4) - goto yy895; - } - } - yy885 : { return (bufsize_t)(p - start); } - yy886: - ++p; - yych = *p; - if (yybm[0 + yych] & 64) { - goto yy886; - } - if (yych <= 0xDF) { - if (yych <= '=') { - if (yych == '\n') - goto yy877; - } else { - if (yych <= '>') - goto yy884; - if (yych <= 0x7F) - goto yy888; - if (yych <= 0xC1) - goto yy877; - goto yy890; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy891; - if (yych == 0xED) - goto yy896; - goto yy892; - } else { - if (yych <= 0xF0) - goto yy893; - if (yych <= 0xF3) - goto yy894; - if (yych <= 0xF4) - goto yy895; - goto yy877; - } - } - yy888: - ++p; - yych = *p; - yy889: - if (yybm[0 + yych] & 128) { - goto yy888; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') - goto yy877; - if (yych <= '?') - goto yy886; - goto yy877; - } else { - if (yych <= 0xDF) - goto yy890; - if (yych <= 0xE0) - goto yy891; - goto yy892; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy896; - if (yych <= 0xEF) - goto yy892; - goto yy893; - } else { - if (yych <= 0xF3) - goto yy894; - if (yych <= 0xF4) - goto yy895; - goto yy877; - } - } - yy890: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy877; - if (yych <= 0xBF) - goto yy888; - goto yy877; - yy891: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy877; - if (yych <= 0xBF) - goto yy890; - goto yy877; - yy892: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy877; - if (yych <= 0xBF) - goto yy890; - goto yy877; - yy893: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy877; - if (yych <= 0xBF) - goto yy892; - goto yy877; - yy894: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy877; - if (yych <= 0xBF) - goto yy892; - goto yy877; - yy895: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy877; - if (yych <= 0x8F) - goto yy892; - goto yy877; - yy896: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy877; - if (yych <= 0x9F) - goto yy890; - goto yy877; + if (yych <= '`') { + if (yych <= 'Z') + goto yy758; + if (yych <= '^') + goto yy728; + if (yych <= '_') + goto yy758; + goto yy707; + } else { + if (yych <= 'z') + goto yy758; + if (yych <= 0x7F) + goto yy728; + if (yych <= 0xC1) + goto yy707; + goto yy730; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy731; + if (yych == 0xED) + goto yy736; + goto yy732; + } else { + if (yych <= 0xF0) + goto yy733; + if (yych <= 0xF3) + goto yy734; + if (yych <= 0xF4) + goto yy735; + goto yy707; + } + } + } } } -// Try to match an HTML block end line of type 4 -bufsize_t _scan_html_block_end_4(const unsigned char *p) { +// Try to match an HTML block end line of type 1 +bufsize_t _scan_html_block_end_1(const unsigned char *p) { const unsigned char *marker = NULL; const unsigned char *start = p; @@ -14750,2696 +12632,2244 @@ bufsize_t _scan_html_block_end_4(const unsigned char *p) { unsigned char yych; unsigned int yyaccept = 0; static const unsigned char yybm[] = { - 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 64, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 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, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 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, }; - yych = *(marker = p); + yych = *p; if (yych <= 0xDF) { - if (yych <= '=') { + if (yych <= ';') { + if (yych <= 0x00) + goto yy766; if (yych != '\n') - goto yy900; + goto yy768; } else { - if (yych <= '>') - goto yy901; + if (yych <= '<') + goto yy769; if (yych <= 0x7F) - goto yy900; + goto yy768; if (yych >= 0xC2) - goto yy903; + goto yy770; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy905; + goto yy771; if (yych == 0xED) - goto yy910; - goto yy906; + goto yy773; + goto yy772; } else { if (yych <= 0xF0) - goto yy907; + goto yy774; if (yych <= 0xF3) - goto yy908; + goto yy775; if (yych <= 0xF4) - goto yy909; + goto yy776; } } - yy899 : { return 0; } - yy900: + yy766: + ++p; + yy767 : { return 0; } + yy768: yyaccept = 0; yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych == '\n') - goto yy899; - goto yy914; + if (yych <= '\n') { + if (yych <= 0x00) + goto yy767; + if (yych <= '\t') + goto yy781; + goto yy767; } else { + if (yych <= 0x7F) + goto yy781; if (yych <= 0xC1) - goto yy899; + goto yy767; if (yych <= 0xF4) - goto yy914; - goto yy899; + goto yy781; + goto yy767; } - yy901: - yyaccept = 1; + yy769: + yyaccept = 0; yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych != '\n') - goto yy914; + if (yych <= '.') { + if (yych <= 0x00) + goto yy767; + if (yych == '\n') + goto yy767; + goto yy781; } else { - if (yych <= 0xC1) - goto yy902; - if (yych <= 0xF4) - goto yy914; + if (yych <= 0x7F) { + if (yych <= '/') + goto yy789; + goto yy781; + } else { + if (yych <= 0xC1) + goto yy767; + if (yych <= 0xF4) + goto yy781; + goto yy767; + } } - yy902 : { return (bufsize_t)(p - start); } - yy903: - yych = *++p; + yy770: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy904; + goto yy767; if (yych <= 0xBF) - goto yy900; - yy904: - p = marker; - if (yyaccept == 0) { - goto yy899; - } else { - goto yy902; - } - yy905: - yych = *++p; + goto yy780; + goto yy767; + yy771: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x9F) - goto yy904; + goto yy767; if (yych <= 0xBF) - goto yy903; - goto yy904; - yy906: - yych = *++p; + goto yy779; + goto yy767; + yy772: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy904; + goto yy767; if (yych <= 0xBF) - goto yy903; - goto yy904; - yy907: - yych = *++p; + goto yy779; + goto yy767; + yy773: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy767; + if (yych <= 0x9F) + goto yy779; + goto yy767; + yy774: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x8F) - goto yy904; + goto yy767; if (yych <= 0xBF) - goto yy906; - goto yy904; - yy908: - yych = *++p; + goto yy777; + goto yy767; + yy775: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy904; + goto yy767; if (yych <= 0xBF) - goto yy906; - goto yy904; - yy909: - yych = *++p; - if (yych <= 0x7F) - goto yy904; - if (yych <= 0x8F) - goto yy906; - goto yy904; - yy910: - yych = *++p; + goto yy777; + goto yy767; + yy776: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy904; - if (yych <= 0x9F) - goto yy903; - goto yy904; - yy911: - yyaccept = 1; - marker = ++p; + goto yy767; + if (yych >= 0x90) + goto yy767; + yy777: + ++p; yych = *p; - if (yybm[0 + yych] & 128) { - goto yy913; - } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') - goto yy902; - if (yych <= '>') - goto yy911; - goto yy902; - } else { - if (yych <= 0xDF) - goto yy915; - if (yych <= 0xE0) - goto yy916; - goto yy917; - } + if (yych <= 0x7F) + goto yy778; + if (yych <= 0xBF) + goto yy779; + yy778: + p = marker; + if (yyaccept == 0) { + goto yy767; } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy921; - if (yych <= 0xEF) - goto yy917; - goto yy918; - } else { - if (yych <= 0xF3) - goto yy919; - if (yych <= 0xF4) - goto yy920; - goto yy902; - } + goto yy795; } - yy913: + yy779: ++p; yych = *p; - yy914: - if (yybm[0 + yych] & 128) { - goto yy913; + if (yych <= 0x7F) + goto yy778; + if (yych >= 0xC0) + goto yy778; + yy780: + ++p; + yych = *p; + yy781: + if (yybm[0 + yych] & 64) { + goto yy780; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy904; - if (yych <= '>') - goto yy911; - goto yy904; + goto yy778; + if (yych >= '=') + goto yy778; } else { if (yych <= 0xDF) - goto yy915; + goto yy779; if (yych <= 0xE0) - goto yy916; - goto yy917; + goto yy784; + goto yy777; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy921; + goto yy788; if (yych <= 0xEF) - goto yy917; - goto yy918; + goto yy777; + goto yy785; } else { if (yych <= 0xF3) - goto yy919; + goto yy786; if (yych <= 0xF4) - goto yy920; - goto yy904; + goto yy787; + goto yy778; } } - yy915: + yy782: ++p; yych = *p; - if (yych <= 0x7F) - goto yy904; - if (yych <= 0xBF) - goto yy913; - goto yy904; - yy916: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy904; - if (yych <= 0xBF) - goto yy915; - goto yy904; - yy917: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy904; - if (yych <= 0xBF) - goto yy915; - goto yy904; - yy918: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy904; - if (yych <= 0xBF) - goto yy917; - goto yy904; - yy919: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy904; - if (yych <= 0xBF) - goto yy917; - goto yy904; - yy920: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy904; - if (yych <= 0x8F) - goto yy917; - goto yy904; - yy921: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy904; - if (yych <= 0x9F) - goto yy915; - goto yy904; - } -} - -// Try to match an HTML block end line of type 5 -bufsize_t _scan_html_block_end_5(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[] = { - 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 64, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 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, - }; - yych = *(marker = p); + if (yybm[0 + yych] & 128) { + goto yy782; + } if (yych <= 0xDF) { - if (yych <= '\\') { - if (yych != '\n') - goto yy925; + if (yych <= '.') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; } else { - if (yych <= ']') - goto yy926; + if (yych <= '/') + goto yy789; if (yych <= 0x7F) - goto yy925; - if (yych >= 0xC2) - goto yy927; + goto yy780; + if (yych <= 0xC1) + goto yy778; + goto yy779; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy929; + goto yy784; if (yych == 0xED) - goto yy934; - goto yy930; + goto yy788; + goto yy777; } else { if (yych <= 0xF0) - goto yy931; + goto yy785; if (yych <= 0xF3) - goto yy932; + goto yy786; if (yych <= 0xF4) - goto yy933; + goto yy787; + goto yy778; } } - yy924 : { return 0; } - yy925: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0x7F) { - if (yych == '\n') - goto yy924; - goto yy938; - } else { - if (yych <= 0xC1) - goto yy924; - if (yych <= 0xF4) - goto yy938; - goto yy924; - } - yy926: - yyaccept = 0; - yych = *(marker = ++p); - if (yybm[0 + yych] & 64) { - goto yy935; - } - if (yych <= 0x7F) { - if (yych == '\n') - goto yy924; - goto yy938; - } else { - if (yych <= 0xC1) - goto yy924; - if (yych <= 0xF4) - goto yy938; - goto yy924; - } - yy927: - yych = *++p; - if (yych <= 0x7F) - goto yy928; - if (yych <= 0xBF) - goto yy925; - yy928: - p = marker; - if (yyaccept == 0) { - goto yy924; - } else { - goto yy948; - } - yy929: - yych = *++p; + yy784: + ++p; + yych = *p; if (yych <= 0x9F) - goto yy928; + goto yy778; if (yych <= 0xBF) - goto yy927; - goto yy928; - yy930: - yych = *++p; - if (yych <= 0x7F) - goto yy928; - if (yych <= 0xBF) - goto yy927; - goto yy928; - yy931: - yych = *++p; + goto yy779; + goto yy778; + yy785: + ++p; + yych = *p; if (yych <= 0x8F) - goto yy928; + goto yy778; if (yych <= 0xBF) - goto yy930; - goto yy928; - yy932: - yych = *++p; + goto yy777; + goto yy778; + yy786: + ++p; + yych = *p; if (yych <= 0x7F) - goto yy928; + goto yy778; if (yych <= 0xBF) - goto yy930; - goto yy928; - yy933: - yych = *++p; + goto yy777; + goto yy778; + yy787: + ++p; + yych = *p; if (yych <= 0x7F) - goto yy928; + goto yy778; if (yych <= 0x8F) - goto yy930; - goto yy928; - yy934: - yych = *++p; + goto yy777; + goto yy778; + yy788: + ++p; + yych = *p; if (yych <= 0x7F) - goto yy928; + goto yy778; if (yych <= 0x9F) - goto yy927; - goto yy928; - yy935: + goto yy779; + goto yy778; + yy789: ++p; yych = *p; - if (yybm[0 + yych] & 64) { - goto yy935; + if (yybm[0 + yych] & 128) { + goto yy782; } - if (yych <= 0xDF) { - if (yych <= '=') { - if (yych == '\n') - goto yy928; + if (yych <= 's') { + if (yych <= 'P') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy778; + goto yy780; + } else { + if (yych <= '\n') + goto yy778; + if (yych <= 'O') + goto yy780; + goto yy791; + } } else { - if (yych <= '>') - goto yy947; - if (yych <= 0x7F) - goto yy937; - if (yych <= 0xC1) - goto yy928; - goto yy939; + if (yych <= 'o') { + if (yych != 'S') + goto yy780; + } else { + if (yych <= 'p') + goto yy791; + if (yych <= 'r') + goto yy780; + } } } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy940; - if (yych == 0xED) - goto yy945; - goto yy941; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) + goto yy780; + goto yy778; + } else { + if (yych <= 0xDF) + goto yy779; + if (yych <= 0xE0) + goto yy784; + goto yy777; + } } else { - if (yych <= 0xF0) - goto yy942; - if (yych <= 0xF3) - goto yy943; - if (yych <= 0xF4) - goto yy944; - goto yy928; + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy788; + if (yych <= 0xEF) + goto yy777; + goto yy785; + } else { + if (yych <= 0xF3) + goto yy786; + if (yych <= 0xF4) + goto yy787; + goto yy778; + } } } - yy937: ++p; yych = *p; - yy938: if (yybm[0 + yych] & 128) { - goto yy937; + goto yy782; } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') - goto yy928; - if (yych <= ']') - goto yy946; - goto yy928; + if (yych <= 't') { + if (yych <= 'C') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy778; + goto yy780; + } else { + if (yych <= '\n') + goto yy778; + if (yych <= 'B') + goto yy780; + goto yy796; + } + } else { + if (yych <= 'b') { + if (yych == 'T') + goto yy797; + goto yy780; + } else { + if (yych <= 'c') + goto yy796; + if (yych <= 's') + goto yy780; + goto yy797; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) + goto yy780; + goto yy778; + } else { + if (yych <= 0xDF) + goto yy779; + if (yych <= 0xE0) + goto yy784; + goto yy777; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy788; + if (yych <= 0xEF) + goto yy777; + goto yy785; + } else { + if (yych <= 0xF3) + goto yy786; + if (yych <= 0xF4) + goto yy787; + goto yy778; + } + } + } + yy791: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy782; + } + if (yych <= 0xC1) { + if (yych <= 'Q') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; } else { + if (yych <= 'q') { + if (yych >= 'S') + goto yy780; + } else { + if (yych <= 'r') + goto yy792; + if (yych <= 0x7F) + goto yy780; + goto yy778; + } + } + } else { + if (yych <= 0xED) { if (yych <= 0xDF) - goto yy939; + goto yy779; if (yych <= 0xE0) - goto yy940; - goto yy941; + goto yy784; + if (yych <= 0xEC) + goto yy777; + goto yy788; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy777; + goto yy785; + } else { + if (yych <= 0xF3) + goto yy786; + if (yych <= 0xF4) + goto yy787; + goto yy778; + } + } + } + yy792: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy782; + } + if (yych <= 0xC1) { + if (yych <= 'D') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; + } else { + if (yych <= 'd') { + if (yych >= 'F') + goto yy780; + } else { + if (yych <= 'e') + goto yy793; + if (yych <= 0x7F) + goto yy780; + goto yy778; + } } } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy945; - if (yych <= 0xEF) - goto yy941; - goto yy942; + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy779; + if (yych <= 0xE0) + goto yy784; + if (yych <= 0xEC) + goto yy777; + goto yy788; } else { - if (yych <= 0xF3) - goto yy943; - if (yych <= 0xF4) - goto yy944; - goto yy928; + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy777; + goto yy785; + } else { + if (yych <= 0xF3) + goto yy786; + if (yych <= 0xF4) + goto yy787; + goto yy778; + } } } - yy939: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy928; - if (yych <= 0xBF) - goto yy937; - goto yy928; - yy940: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy928; - if (yych <= 0xBF) - goto yy939; - goto yy928; - yy941: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy928; - if (yych <= 0xBF) - goto yy939; - goto yy928; - yy942: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy928; - if (yych <= 0xBF) - goto yy941; - goto yy928; - yy943: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy928; - if (yych <= 0xBF) - goto yy941; - goto yy928; - yy944: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy928; - if (yych <= 0x8F) - goto yy941; - goto yy928; - yy945: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy928; - if (yych <= 0x9F) - goto yy939; - goto yy928; - yy946: + yy793: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy937; + goto yy782; } - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\n') - goto yy928; - if (yych <= ']') - goto yy935; - goto yy928; + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; } else { - if (yych <= 0xDF) - goto yy939; - if (yych <= 0xE0) - goto yy940; - goto yy941; + if (yych <= '>') + goto yy794; + if (yych <= 0x7F) + goto yy780; + if (yych <= 0xC1) + goto yy778; + goto yy779; } } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy945; - if (yych <= 0xEF) - goto yy941; - goto yy942; + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy784; + if (yych == 0xED) + goto yy788; + goto yy777; } else { + if (yych <= 0xF0) + goto yy785; if (yych <= 0xF3) - goto yy943; + goto yy786; if (yych <= 0xF4) - goto yy944; - goto yy928; + goto yy787; + goto yy778; } } - yy947: + yy794: yyaccept = 1; marker = ++p; yych = *p; - if (yybm[0 + yych] & 128) { - goto yy937; + if (yybm[0 + yych] & 64) { + goto yy780; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= '\n') - goto yy948; - if (yych <= ']') - goto yy946; + goto yy795; + if (yych <= '<') + goto yy782; } else { if (yych <= 0xDF) - goto yy939; + goto yy779; if (yych <= 0xE0) - goto yy940; - goto yy941; + goto yy784; + goto yy777; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy945; + goto yy788; if (yych <= 0xEF) - goto yy941; - goto yy942; + goto yy777; + goto yy785; } else { if (yych <= 0xF3) - goto yy943; + goto yy786; if (yych <= 0xF4) - goto yy944; + goto yy787; } } - yy948 : { return (bufsize_t)(p - start); } - } -} - -// 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. -bufsize_t _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, 128, 128, 128, 128, 128, 128, 128, 128, 0, 8, 128, 128, 8, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 8, 224, 224, 224, 224, 224, 224, 224, 128, 128, - 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, - 224, 224, 224, 224, 32, 224, 32, 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, 224, 224, 224, 16, 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, 224, 224, 224, 224, 224, 224, 224, - 224, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); - if (yych <= '[') { - if (yych <= ' ') { - if (yych <= '\f') { - if (yych == '\n') - goto yy952; - goto yy968; - } else { - if (yych <= '\r') - goto yy954; - if (yych <= 0x1F) - goto yy968; - goto yy954; - } + yy795 : { return (bufsize_t)(p - start); } + yy796: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy782; + } + if (yych <= 0xC1) { + if (yych <= 'Q') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; } else { - if (yych <= ')') { - if (yych <= '\'') - goto yy956; - if (yych <= '(') - goto yy966; - goto yy968; + if (yych <= 'q') { + if (yych <= 'R') + goto yy800; + goto yy780; } else { - if (yych == '<') - goto yy955; - goto yy956; + if (yych <= 'r') + goto yy800; + if (yych <= 0x7F) + goto yy780; + goto yy778; } } } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') - goto yy965; - if (yych <= 0x7F) - goto yy956; - } else { - if (yych <= 0xDF) - goto yy957; - if (yych <= 0xE0) - goto yy959; - goto yy960; - } + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy779; + if (yych <= 0xE0) + goto yy784; + if (yych <= 0xEC) + goto yy777; + goto yy788; } else { if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy964; if (yych <= 0xEF) - goto yy960; - goto yy961; + goto yy777; + goto yy785; } else { if (yych <= 0xF3) - goto yy962; + goto yy786; if (yych <= 0xF4) - goto yy963; + goto yy787; + goto yy778; } } } - yy951 : { return (bufsize_t)(p - start); } - yy952: - yyaccept = 0; - marker = ++p; + yy797: + ++p; yych = *p; - yy953: - if (yybm[0 + yych] & 8) { - goto yy952; + if (yybm[0 + yych] & 128) { + goto yy782; } - if (yych <= 0x7F) { - if (yych <= ')') { - if (yych <= 0x1F) - goto yy951; - if (yych <= '\'') - goto yy980; - if (yych <= '(') - goto yy971; - goto yy951; + if (yych <= 0xC1) { + if (yych <= 'X') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; } else { - if (yych <= '<') { - if (yych <= ';') - goto yy980; - goto yy1016; + if (yych <= 'x') { + if (yych >= 'Z') + goto yy780; } else { - if (yych == '\\') - goto yy982; - goto yy980; + if (yych <= 'y') + goto yy798; + if (yych <= 0x7F) + goto yy780; + goto yy778; } } } else { if (yych <= 0xED) { - if (yych <= 0xDF) { - if (yych <= 0xC1) - goto yy951; - goto yy983; - } else { - if (yych <= 0xE0) - goto yy984; - if (yych <= 0xEC) - goto yy985; - goto yy989; - } + if (yych <= 0xDF) + goto yy779; + if (yych <= 0xE0) + goto yy784; + if (yych <= 0xEC) + goto yy777; + goto yy788; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy985; - goto yy986; + goto yy777; + goto yy785; } else { if (yych <= 0xF3) - goto yy987; + goto yy786; if (yych <= 0xF4) - goto yy988; - goto yy951; + goto yy787; + goto yy778; } } } - yy954: - yyaccept = 0; - yych = *(marker = ++p); - goto yy953; - yy955: - yyaccept = 0; - yych = *(marker = ++p); - if (yybm[0 + yych] & 64) { - goto yy1016; + yy798: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy782; } - if (yych <= '>') { - if (yych <= '\r') { - if (yych <= 0x08) { - if (yych <= 0x00) - goto yy951; - goto yy1029; - } else { - if (yych <= '\n') - goto yy951; - if (yych <= '\f') - goto yy1029; - goto yy951; - } + if (yych <= 0xC1) { + if (yych <= 'K') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; } else { - if (yych <= '(') { - if (yych <= 0x1F) - goto yy1029; - if (yych <= ' ') - goto yy951; - goto yy1027; + if (yych <= 'k') { + if (yych >= 'M') + goto yy780; } else { - if (yych <= ')') - goto yy1029; - if (yych <= '<') - goto yy980; - goto yy1018; + if (yych <= 'l') + goto yy799; + if (yych <= 0x7F) + goto yy780; + goto yy778; } } } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') - goto yy1015; - goto yy951; - } else { - if (yych <= 0xDF) - goto yy1020; - if (yych <= 0xE0) - goto yy1021; - goto yy1022; - } + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy779; + if (yych <= 0xE0) + goto yy784; + if (yych <= 0xEC) + goto yy777; + goto yy788; } else { if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1026; if (yych <= 0xEF) - goto yy1022; - goto yy1023; + goto yy777; + goto yy785; } else { if (yych <= 0xF3) - goto yy1024; + goto yy786; if (yych <= 0xF4) - goto yy1025; - goto yy951; + goto yy787; + goto yy778; } } } - yy956: - yyaccept = 0; - yych = *(marker = ++p); - goto yy981; - yy957: - yych = *++p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy956; - yy958: - p = marker; - if (yyaccept <= 1) { - if (yyaccept == 0) { - goto yy951; - } else { - goto yy967; - } - } else { - goto yy1019; + yy799: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy782; } - yy959: - yych = *++p; - if (yych <= 0x9F) - goto yy958; - if (yych <= 0xBF) - goto yy957; - goto yy958; - yy960: - yych = *++p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy957; - goto yy958; - yy961: - yych = *++p; - if (yych <= 0x8F) - goto yy958; - if (yych <= 0xBF) - goto yy960; - goto yy958; - yy962: - yych = *++p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy960; - goto yy958; - yy963: - yych = *++p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0x8F) - goto yy960; - goto yy958; - yy964: - yych = *++p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0x9F) - goto yy957; - goto yy958; - yy965: - yyaccept = 0; - yych = *(marker = ++p); - if (yych <= 0xDF) { - if (yych <= 0x1F) { - if (yych <= 0x08) - goto yy980; - if (yych <= '\r') - goto yy951; - goto yy980; + if (yych <= 0xC1) { + if (yych <= 'D') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; } else { - if (yych <= ' ') - goto yy951; - if (yych <= 0x7F) - goto yy980; - if (yych <= 0xC1) - goto yy951; - goto yy990; + if (yych <= 'd') { + if (yych <= 'E') + goto yy793; + goto yy780; + } else { + if (yych <= 'e') + goto yy793; + if (yych <= 0x7F) + goto yy780; + goto yy778; + } } } else { - if (yych <= 0xEF) { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy779; if (yych <= 0xE0) - goto yy991; - if (yych == 0xED) - goto yy996; - goto yy992; + goto yy784; + if (yych <= 0xEC) + goto yy777; + goto yy788; } else { - if (yych <= 0xF0) - goto yy993; - if (yych <= 0xF3) - goto yy994; - if (yych <= 0xF4) - goto yy995; - goto yy951; + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy777; + goto yy785; + } else { + if (yych <= 0xF3) + goto yy786; + if (yych <= 0xF4) + goto yy787; + goto yy778; + } } } - yy966: - yyaccept = 1; - yych = *(marker = ++p); - if (yych <= '(') { - if (yych <= ' ') - goto yy967; - if (yych <= '\'') - goto yy972; - } else { - if (yych <= 0x7F) - goto yy972; - if (yych <= 0xC1) - goto yy967; - if (yych <= 0xF4) - goto yy972; - } - yy967 : { return 0; } - yy968: - yych = *++p; - goto yy967; - yy969: + yy800: ++p; yych = *p; - if (yybm[0 + yych] & 16) { - goto yy969; + if (yybm[0 + yych] & 128) { + goto yy782; } - if (yych <= 0xE0) { - if (yych <= ')') { - if (yych <= ' ') - goto yy958; - if (yych >= ')') - goto yy997; + if (yych <= 0xC1) { + if (yych <= 'H') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; } else { - if (yych <= 0x7F) - goto yy971; - if (yych <= 0xC1) - goto yy958; - if (yych <= 0xDF) - goto yy973; - goto yy974; + if (yych <= 'h') { + if (yych >= 'J') + goto yy780; + } else { + if (yych <= 'i') + goto yy801; + if (yych <= 0x7F) + goto yy780; + goto yy778; + } } } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy979; - goto yy975; + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy779; + if (yych <= 0xE0) + goto yy784; + if (yych <= 0xEC) + goto yy777; + goto yy788; } else { - if (yych <= 0xF0) - goto yy976; - if (yych <= 0xF3) - goto yy977; - if (yych <= 0xF4) - goto yy978; - goto yy958; + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy777; + goto yy785; + } else { + if (yych <= 0xF3) + goto yy786; + if (yych <= 0xF4) + goto yy787; + goto yy778; + } } } - yy971: + yy801: ++p; yych = *p; - yy972: - if (yybm[0 + yych] & 32) { - goto yy971; + if (yybm[0 + yych] & 128) { + goto yy782; } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '(') - goto yy958; - if (yych <= ')') - goto yy980; - goto yy969; + if (yych <= 0xC1) { + if (yych <= 'O') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; } else { - if (yych <= 0xC1) - goto yy958; - if (yych >= 0xE0) - goto yy974; + if (yych <= 'o') { + if (yych >= 'Q') + goto yy780; + } else { + if (yych <= 'p') + goto yy802; + if (yych <= 0x7F) + goto yy780; + goto yy778; + } } } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy979; - goto yy975; + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy779; + if (yych <= 0xE0) + goto yy784; + if (yych <= 0xEC) + goto yy777; + goto yy788; } else { - if (yych <= 0xF0) - goto yy976; - if (yych <= 0xF3) - goto yy977; - if (yych <= 0xF4) - goto yy978; - goto yy958; + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy777; + goto yy785; + } else { + if (yych <= 0xF3) + goto yy786; + if (yych <= 0xF4) + goto yy787; + goto yy778; + } } } - yy973: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy971; - goto yy958; - yy974: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy958; - if (yych <= 0xBF) - goto yy973; - goto yy958; - yy975: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy973; - goto yy958; - yy976: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy958; - if (yych <= 0xBF) - goto yy975; - goto yy958; - yy977: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy975; - goto yy958; - yy978: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0x8F) - goto yy975; - goto yy958; - yy979: + yy802: ++p; yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0x9F) - goto yy973; - goto yy958; - yy980: - yyaccept = 0; - marker = ++p; - yych = *p; - yy981: + if (yybm[0 + yych] & 128) { + goto yy782; + } if (yych <= 0xC1) { - if (yych <= ')') { - if (yych <= ' ') - goto yy951; - if (yych <= '\'') - goto yy980; - if (yych <= '(') - goto yy971; - goto yy951; + if (yych <= 'S') { + if (yych <= 0x00) + goto yy778; + if (yych == '\n') + goto yy778; + goto yy780; } else { - if (yych == '\\') - goto yy982; - if (yych <= 0x7F) - goto yy980; - goto yy951; + if (yych <= 's') { + if (yych <= 'T') + goto yy793; + goto yy780; + } else { + if (yych <= 't') + goto yy793; + if (yych <= 0x7F) + goto yy780; + goto yy778; + } } } else { if (yych <= 0xED) { if (yych <= 0xDF) - goto yy983; + goto yy779; if (yych <= 0xE0) - goto yy984; + goto yy784; if (yych <= 0xEC) - goto yy985; - goto yy989; + goto yy777; + goto yy788; } else { if (yych <= 0xF0) { if (yych <= 0xEF) - goto yy985; - goto yy986; + goto yy777; + goto yy785; } else { if (yych <= 0xF3) - goto yy987; + goto yy786; if (yych <= 0xF4) - goto yy988; - goto yy951; + goto yy787; + goto yy778; } } } - yy982: - yyaccept = 0; - marker = ++p; + } +} + +// Try to match an HTML block end line of type 2 +bufsize_t _scan_html_block_end_2(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, 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 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, + }; yych = *p; if (yych <= 0xDF) { - if (yych <= 0x1F) { - if (yych <= 0x08) - goto yy980; - if (yych <= '\r') - goto yy951; - goto yy980; + if (yych <= ',') { + if (yych <= 0x00) + goto yy805; + if (yych != '\n') + goto yy807; } else { - if (yych <= ' ') - goto yy951; + if (yych <= '-') + goto yy808; if (yych <= 0x7F) - goto yy980; - if (yych <= 0xC1) - goto yy951; - goto yy990; + goto yy807; + if (yych >= 0xC2) + goto yy809; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy991; + goto yy810; if (yych == 0xED) - goto yy996; - goto yy992; + goto yy812; + goto yy811; } else { if (yych <= 0xF0) - goto yy993; + goto yy813; if (yych <= 0xF3) - goto yy994; + goto yy814; if (yych <= 0xF4) - goto yy995; - goto yy951; + goto yy815; } } - yy983: + yy805: ++p; - yych = *p; + yy806 : { return 0; } + yy807: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy806; + if (yych <= '\t') + goto yy820; + goto yy806; + } else { + if (yych <= 0x7F) + goto yy820; + if (yych <= 0xC1) + goto yy806; + if (yych <= 0xF4) + goto yy820; + goto yy806; + } + yy808: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy827; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy806; + if (yych <= '\t') + goto yy820; + goto yy806; + } else { + if (yych <= 0x7F) + goto yy820; + if (yych <= 0xC1) + goto yy806; + if (yych <= 0xF4) + goto yy820; + goto yy806; + } + yy809: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; + goto yy806; if (yych <= 0xBF) - goto yy980; - goto yy958; - yy984: - ++p; - yych = *p; + goto yy819; + goto yy806; + yy810: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x9F) - goto yy958; - if (yych <= 0xBF) - goto yy983; - goto yy958; - yy985: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy983; - goto yy958; - yy986: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy958; + goto yy806; if (yych <= 0xBF) - goto yy985; - goto yy958; - yy987: - ++p; - yych = *p; + goto yy818; + goto yy806; + yy811: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; + goto yy806; if (yych <= 0xBF) - goto yy985; - goto yy958; - yy988: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0x8F) - goto yy985; - goto yy958; - yy989: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0x9F) - goto yy983; - goto yy958; - yy990: - ++p; - yych = *p; + goto yy818; + goto yy806; + yy812: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy980; - goto yy958; - yy991: - ++p; - yych = *p; + goto yy806; if (yych <= 0x9F) - goto yy958; + goto yy818; + goto yy806; + yy813: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x8F) + goto yy806; if (yych <= 0xBF) - goto yy990; - goto yy958; - yy992: - ++p; - yych = *p; + goto yy816; + goto yy806; + yy814: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy990; - goto yy958; - yy993: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy958; + goto yy806; if (yych <= 0xBF) - goto yy992; - goto yy958; - yy994: + goto yy816; + goto yy806; + yy815: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy806; + if (yych >= 0x90) + goto yy806; + yy816: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy817; if (yych <= 0xBF) - goto yy992; - goto yy958; - yy995: + goto yy818; + yy817: + p = marker; + if (yyaccept == 0) { + goto yy806; + } else { + goto yy830; + } + yy818: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; - if (yych <= 0x8F) - goto yy992; - goto yy958; - yy996: + goto yy817; + if (yych >= 0xC0) + goto yy817; + yy819: ++p; yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0x9F) - goto yy990; - goto yy958; - yy997: - yyaccept = 0; - marker = ++p; - yych = *p; - yy998: - if (yych <= 0xC1) { - if (yych <= ')') { - if (yych <= ' ') - goto yy951; - if (yych <= '\'') - goto yy997; - if (yych <= '(') - goto yy971; - goto yy980; + yy820: + if (yybm[0 + yych] & 64) { + goto yy819; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy817; + if (yych >= '.') + goto yy817; } else { - if (yych == '\\') - goto yy999; - if (yych <= 0x7F) - goto yy997; - goto yy951; - } - } else { - if (yych <= 0xED) { if (yych <= 0xDF) - goto yy1000; + goto yy818; if (yych <= 0xE0) - goto yy1001; - if (yych <= 0xEC) - goto yy1002; - goto yy1006; + goto yy822; + goto yy816; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy826; + if (yych <= 0xEF) + goto yy816; + goto yy823; } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy1002; - goto yy1003; - } else { - if (yych <= 0xF3) - goto yy1004; - if (yych <= 0xF4) - goto yy1005; - goto yy951; - } + if (yych <= 0xF3) + goto yy824; + if (yych <= 0xF4) + goto yy825; + goto yy817; } } - yy999: - yyaccept = 0; - marker = ++p; + yy821: + ++p; yych = *p; - if (yych <= 0xC1) { - if (yych <= ' ') { - if (yych <= 0x08) - goto yy980; - if (yych <= '\r') - goto yy951; - if (yych <= 0x1F) - goto yy980; - goto yy951; + if (yybm[0 + yych] & 64) { + goto yy819; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy817; + if (yych <= '-') + goto yy827; + goto yy817; } else { - if (yych == '\\') - goto yy1007; - if (yych <= 0x7F) - goto yy997; - goto yy951; + if (yych <= 0xDF) + goto yy818; + if (yych >= 0xE1) + goto yy816; } } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy1008; - if (yych <= 0xE0) - goto yy1009; - if (yych <= 0xEC) - goto yy1010; - goto yy1014; + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy826; + if (yych <= 0xEF) + goto yy816; + goto yy823; } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy1010; - goto yy1011; - } else { - if (yych <= 0xF3) - goto yy1012; - if (yych <= 0xF4) - goto yy1013; - goto yy951; - } + if (yych <= 0xF3) + goto yy824; + if (yych <= 0xF4) + goto yy825; + goto yy817; } } - yy1000: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy997; - goto yy958; - yy1001: + yy822: ++p; yych = *p; if (yych <= 0x9F) - goto yy958; - if (yych <= 0xBF) - goto yy1000; - goto yy958; - yy1002: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; + goto yy817; if (yych <= 0xBF) - goto yy1000; - goto yy958; - yy1003: + goto yy818; + goto yy817; + yy823: ++p; yych = *p; if (yych <= 0x8F) - goto yy958; + goto yy817; if (yych <= 0xBF) - goto yy1002; - goto yy958; - yy1004: + goto yy816; + goto yy817; + yy824: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy817; if (yych <= 0xBF) - goto yy1002; - goto yy958; - yy1005: + goto yy816; + goto yy817; + yy825: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy817; if (yych <= 0x8F) - goto yy1002; - goto yy958; - yy1006: + goto yy816; + goto yy817; + yy826: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy817; if (yych <= 0x9F) - goto yy1000; - goto yy958; - yy1007: - yyaccept = 0; + goto yy818; + goto yy817; + yy827: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy827; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy817; + if (yych == '\n') + goto yy817; + goto yy819; + } else { + if (yych <= '>') + goto yy829; + if (yych <= 0x7F) + goto yy819; + if (yych <= 0xC1) + goto yy817; + goto yy818; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy822; + if (yych == 0xED) + goto yy826; + goto yy816; + } else { + if (yych <= 0xF0) + goto yy823; + if (yych <= 0xF3) + goto yy824; + if (yych <= 0xF4) + goto yy825; + goto yy817; + } + } + yy829: + yyaccept = 1; marker = ++p; yych = *p; + if (yybm[0 + yych] & 64) { + goto yy819; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy830; + if (yych <= '-') + goto yy821; + } else { + if (yych <= 0xDF) + goto yy818; + if (yych <= 0xE0) + goto yy822; + goto yy816; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy826; + if (yych <= 0xEF) + goto yy816; + goto yy823; + } else { + if (yych <= 0xF3) + goto yy824; + if (yych <= 0xF4) + goto yy825; + } + } + yy830 : { return (bufsize_t)(p - start); } + } +} + +// Try to match an HTML block end line of type 3 +bufsize_t _scan_html_block_end_3(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, 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 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, + }; + yych = *p; if (yych <= 0xDF) { - if (yych <= '[') { - if (yych <= ' ') - goto yy951; - if (yych == '(') - goto yy971; - goto yy997; + if (yych <= '>') { + if (yych <= 0x00) + goto yy833; + if (yych != '\n') + goto yy835; } else { - if (yych <= '\\') - goto yy999; + if (yych <= '?') + goto yy836; if (yych <= 0x7F) - goto yy997; - if (yych <= 0xC1) - goto yy951; - goto yy1000; + goto yy835; + if (yych >= 0xC2) + goto yy837; } } else { if (yych <= 0xEF) { if (yych <= 0xE0) - goto yy1001; + goto yy838; if (yych == 0xED) - goto yy1006; - goto yy1002; + goto yy840; + goto yy839; } else { if (yych <= 0xF0) - goto yy1003; + goto yy841; if (yych <= 0xF3) - goto yy1004; + goto yy842; if (yych <= 0xF4) - goto yy1005; - goto yy951; + goto yy843; } } - yy1008: + yy833: ++p; - yych = *p; + yy834 : { return 0; } + yy835: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy834; + if (yych <= '\t') + goto yy848; + goto yy834; + } else { + if (yych <= 0x7F) + goto yy848; + if (yych <= 0xC1) + goto yy834; + if (yych <= 0xF4) + goto yy848; + goto yy834; + } + yy836: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '=') { + if (yych <= 0x00) + goto yy834; + if (yych == '\n') + goto yy834; + goto yy848; + } else { + if (yych <= 0x7F) { + if (yych <= '>') + goto yy856; + goto yy848; + } else { + if (yych <= 0xC1) + goto yy834; + if (yych <= 0xF4) + goto yy848; + goto yy834; + } + } + yy837: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; + goto yy834; if (yych <= 0xBF) - goto yy997; - goto yy958; - yy1009: - ++p; - yych = *p; + goto yy847; + goto yy834; + yy838: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x9F) - goto yy958; + goto yy834; if (yych <= 0xBF) - goto yy1008; - goto yy958; - yy1010: - ++p; - yych = *p; + goto yy846; + goto yy834; + yy839: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; + goto yy834; if (yych <= 0xBF) - goto yy1008; - goto yy958; - yy1011: - ++p; - yych = *p; + goto yy846; + goto yy834; + yy840: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy834; + if (yych <= 0x9F) + goto yy846; + goto yy834; + yy841: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x8F) - goto yy958; + goto yy834; if (yych <= 0xBF) - goto yy1010; - goto yy958; - yy1012: - ++p; - yych = *p; + goto yy844; + goto yy834; + yy842: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; + goto yy834; if (yych <= 0xBF) - goto yy1010; - goto yy958; - yy1013: + goto yy844; + goto yy834; + yy843: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy834; + if (yych >= 0x90) + goto yy834; + yy844: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; - if (yych <= 0x8F) - goto yy1010; - goto yy958; - yy1014: + goto yy845; + if (yych <= 0xBF) + goto yy846; + yy845: + p = marker; + if (yyaccept == 0) { + goto yy834; + } else { + goto yy857; + } + yy846: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; - if (yych <= 0x9F) - goto yy1008; - goto yy958; - yy1015: - yyaccept = 0; - marker = ++p; + goto yy845; + if (yych >= 0xC0) + goto yy845; + yy847: + ++p; yych = *p; - if (yych <= '\\') { - if (yych <= '\r') { - if (yych <= 0x08) { - if (yych <= 0x00) - goto yy980; - } else { - if (yych <= '\n') - goto yy951; - if (yych <= '\f') - goto yy1029; - goto yy951; - } + yy848: + if (yybm[0 + yych] & 64) { + goto yy847; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy845; + if (yych >= '@') + goto yy845; } else { - if (yych <= '=') { - if (yych == ' ') - goto yy951; - } else { - if (yych <= '>') - goto yy1073; - if (yych >= '\\') - goto yy1074; - } + if (yych <= 0xDF) + goto yy846; + if (yych <= 0xE0) + goto yy851; + goto yy844; } } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych >= 0x80) - goto yy951; - } else { - if (yych <= 0xDF) - goto yy1075; - if (yych <= 0xE0) - goto yy1076; - goto yy1077; - } + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy855; + if (yych <= 0xEF) + goto yy844; + goto yy852; } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1081; - if (yych <= 0xEF) - goto yy1077; - goto yy1078; - } else { - if (yych <= 0xF3) - goto yy1079; - if (yych <= 0xF4) - goto yy1080; - goto yy951; - } + if (yych <= 0xF3) + goto yy853; + if (yych <= 0xF4) + goto yy854; + goto yy845; } } - yy1016: - yyaccept = 0; - marker = ++p; + yy849: + ++p; yych = *p; - if (yybm[0 + yych] & 64) { - goto yy1016; + if (yybm[0 + yych] & 128) { + goto yy849; } - if (yych <= '>') { - if (yych <= '\r') { - if (yych <= 0x08) { - if (yych <= 0x00) - goto yy951; - goto yy1029; - } else { - if (yych <= '\n') - goto yy951; - if (yych <= '\f') - goto yy1029; - goto yy951; - } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy845; + if (yych == '\n') + goto yy845; + goto yy847; } else { - if (yych <= '(') { - if (yych <= 0x1F) - goto yy1029; - if (yych <= ' ') - goto yy951; - goto yy1027; - } else { - if (yych <= ')') - goto yy1029; - if (yych <= '<') - goto yy980; - } + if (yych <= '>') + goto yy856; + if (yych <= 0x7F) + goto yy847; + if (yych <= 0xC1) + goto yy845; + goto yy846; } } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') - goto yy1015; - goto yy951; - } else { - if (yych <= 0xDF) - goto yy1020; - if (yych <= 0xE0) - goto yy1021; - goto yy1022; - } + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy851; + if (yych == 0xED) + goto yy855; + goto yy844; } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1026; - if (yych <= 0xEF) - goto yy1022; - goto yy1023; - } else { - if (yych <= 0xF3) - goto yy1024; - if (yych <= 0xF4) - goto yy1025; - goto yy951; - } + if (yych <= 0xF0) + goto yy852; + if (yych <= 0xF3) + goto yy853; + if (yych <= 0xF4) + goto yy854; + goto yy845; } } - yy1018: - yyaccept = 2; - yych = *(marker = ++p); - if (yych <= ')') { - if (yych <= ' ') - goto yy1019; - if (yych <= '(') - goto yy981; - } else { - if (yych <= 0x7F) - goto yy981; - if (yych <= 0xC1) - goto yy1019; - if (yych <= 0xF4) - goto yy981; - } - yy1019 : { return (bufsize_t)(p - start); } - yy1020: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy1016; - goto yy958; - yy1021: + yy851: ++p; yych = *p; if (yych <= 0x9F) - goto yy958; + goto yy845; if (yych <= 0xBF) - goto yy1020; - goto yy958; - yy1022: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy1020; - goto yy958; - yy1023: + goto yy846; + goto yy845; + yy852: ++p; yych = *p; if (yych <= 0x8F) - goto yy958; + goto yy845; if (yych <= 0xBF) - goto yy1022; - goto yy958; - yy1024: + goto yy844; + goto yy845; + yy853: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy845; if (yych <= 0xBF) - goto yy1022; - goto yy958; - yy1025: + goto yy844; + goto yy845; + yy854: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy845; if (yych <= 0x8F) - goto yy1022; - goto yy958; - yy1026: + goto yy844; + goto yy845; + yy855: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy845; if (yych <= 0x9F) - goto yy1020; - goto yy958; - yy1027: - ++p; + goto yy846; + goto yy845; + yy856: + yyaccept = 1; + marker = ++p; yych = *p; - if (yych <= '=') { - if (yych <= 0x1F) { - if (yych <= '\n') { - if (yych <= 0x00) - goto yy958; - if (yych >= '\t') - goto yy958; - } else { - if (yych == '\r') - goto yy958; - } + if (yybm[0 + yych] & 64) { + goto yy847; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy857; + if (yych <= '?') + goto yy849; } else { - if (yych <= '(') { - if (yych <= ' ') - goto yy958; - if (yych <= '\'') - goto yy1027; - } else { - if (yych <= ')') - goto yy1016; - if (yych == '<') - goto yy971; - goto yy1027; - } + if (yych <= 0xDF) + goto yy846; + if (yych <= 0xE0) + goto yy851; + goto yy844; } } else { - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '>') - goto yy1042; - if (yych <= '[') - goto yy1027; - goto yy1043; - } else { - if (yych <= 0x7F) - goto yy1027; - if (yych <= 0xC1) - goto yy958; - if (yych <= 0xDF) - goto yy1045; - goto yy1046; - } + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy855; + if (yych <= 0xEF) + goto yy844; + goto yy852; } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy1051; - goto yy1047; - } else { - if (yych <= 0xF0) - goto yy1048; - if (yych <= 0xF3) - goto yy1049; - if (yych <= 0xF4) - goto yy1050; - goto yy958; - } + if (yych <= 0xF3) + goto yy853; + if (yych <= 0xF4) + goto yy854; } } - yy1029: - ++p; + yy857 : { return (bufsize_t)(p - start); } + } +} + +// Try to match an HTML block end line of type 4 +bufsize_t _scan_html_block_end_4(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, 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 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, + }; yych = *p; - if (yybm[0 + yych] & 128) { - goto yy1029; - } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '<') - goto yy958; - if (yych >= '?') - goto yy1032; + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy860; + if (yych != '\n') + goto yy862; } else { - if (yych <= 0xC1) - goto yy958; - if (yych <= 0xDF) - goto yy1034; - goto yy1035; + if (yych <= '>') + goto yy863; + if (yych <= 0x7F) + goto yy862; + if (yych >= 0xC2) + goto yy865; } } else { if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy866; if (yych == 0xED) - goto yy1040; - goto yy1036; + goto yy868; + goto yy867; } else { if (yych <= 0xF0) - goto yy1037; + goto yy869; if (yych <= 0xF3) - goto yy1038; + goto yy870; if (yych <= 0xF4) - goto yy1039; - goto yy958; + goto yy871; } } - yy1031: - yych = *++p; - goto yy1019; - yy1032: + yy860: ++p; - yych = *p; - if (yych <= '\\') { - if (yych <= '\r') { - if (yych <= 0x08) { - if (yych <= 0x00) - goto yy958; - goto yy1029; - } else { - if (yych <= '\n') - goto yy958; - if (yych <= '\f') - goto yy1029; - goto yy958; - } - } else { - if (yych <= '=') { - if (yych == ' ') - goto yy958; - goto yy1029; - } else { - if (yych <= '>') - goto yy1041; - if (yych <= '[') - goto yy1029; - goto yy1032; - } - } + yy861 : { return 0; } + yy862: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy861; + if (yych <= '\t') + goto yy876; + goto yy861; } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) - goto yy1029; - goto yy958; - } else { - if (yych <= 0xDF) - goto yy1034; - if (yych <= 0xE0) - goto yy1035; - goto yy1036; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1040; - if (yych <= 0xEF) - goto yy1036; - goto yy1037; - } else { - if (yych <= 0xF3) - goto yy1038; - if (yych <= 0xF4) - goto yy1039; - goto yy958; - } - } + if (yych <= 0x7F) + goto yy876; + if (yych <= 0xC1) + goto yy861; + if (yych <= 0xF4) + goto yy876; + goto yy861; } - yy1034: - ++p; - yych = *p; + yy863: + yyaccept = 1; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy864; + if (yych <= '\t') + goto yy876; + } else { + if (yych <= 0x7F) + goto yy876; + if (yych <= 0xC1) + goto yy864; + if (yych <= 0xF4) + goto yy876; + } + yy864 : { return (bufsize_t)(p - start); } + yy865: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; + goto yy861; if (yych <= 0xBF) - goto yy1029; - goto yy958; - yy1035: - ++p; - yych = *p; + goto yy875; + goto yy861; + yy866: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x9F) - goto yy958; + goto yy861; if (yych <= 0xBF) - goto yy1034; - goto yy958; - yy1036: - ++p; - yych = *p; + goto yy874; + goto yy861; + yy867: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; + goto yy861; if (yych <= 0xBF) - goto yy1034; - goto yy958; - yy1037: - ++p; - yych = *p; + goto yy874; + goto yy861; + yy868: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy861; + if (yych <= 0x9F) + goto yy874; + goto yy861; + yy869: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x8F) - goto yy958; + goto yy861; if (yych <= 0xBF) - goto yy1036; - goto yy958; - yy1038: - ++p; - yych = *p; + goto yy872; + goto yy861; + yy870: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; + goto yy861; if (yych <= 0xBF) - goto yy1036; - goto yy958; - yy1039: + goto yy872; + goto yy861; + yy871: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy861; + if (yych >= 0x90) + goto yy861; + yy872: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; - if (yych <= 0x8F) - goto yy1036; - goto yy958; - yy1040: + goto yy873; + if (yych <= 0xBF) + goto yy874; + yy873: + p = marker; + if (yyaccept == 0) { + goto yy861; + } else { + goto yy864; + } + yy874: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; - if (yych <= 0x9F) - goto yy1034; - goto yy958; - yy1041: - yyaccept = 2; - marker = ++p; + goto yy873; + if (yych >= 0xC0) + goto yy873; + yy875: + ++p; yych = *p; - if (yybm[0 + yych] & 128) { - goto yy1029; + yy876: + if (yybm[0 + yych] & 64) { + goto yy875; } - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '<') - goto yy1019; - if (yych <= '>') - goto yy1031; - goto yy1032; + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy873; + if (yych >= '?') + goto yy873; } else { - if (yych <= 0xC1) - goto yy1019; if (yych <= 0xDF) - goto yy1034; - goto yy1035; + goto yy874; + if (yych <= 0xE0) + goto yy879; + goto yy872; } } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy1040; - goto yy1036; + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy883; + if (yych <= 0xEF) + goto yy872; + goto yy880; } else { - if (yych <= 0xF0) - goto yy1037; if (yych <= 0xF3) - goto yy1038; + goto yy881; if (yych <= 0xF4) - goto yy1039; - goto yy1019; - } - } - yy1042: - yyaccept = 2; - yych = *(marker = ++p); - if (yych <= '(') { - if (yych <= ' ') - goto yy1019; - if (yych <= '\'') - goto yy972; - goto yy1019; - } else { - if (yych <= 0x7F) - goto yy972; - if (yych <= 0xC1) - goto yy1019; - if (yych <= 0xF4) - goto yy972; - goto yy1019; + goto yy882; + goto yy873; + } } - yy1043: - ++p; + yy877: + yyaccept = 1; + marker = ++p; yych = *p; - if (yych <= '[') { - if (yych <= 0x1F) { - if (yych <= '\n') { - if (yych <= 0x00) - goto yy958; - if (yych <= 0x08) - goto yy1029; - goto yy958; - } else { - if (yych == '\r') - goto yy958; - goto yy1029; - } + if (yybm[0 + yych] & 64) { + goto yy875; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy864; + if (yych <= '>') + goto yy877; + goto yy864; } else { - if (yych <= ')') { - if (yych <= ' ') - goto yy958; - if (yych <= '(') - goto yy1027; - goto yy1052; - } else { - if (yych == '>') - goto yy1054; - goto yy1027; - } + if (yych <= 0xDF) + goto yy874; + if (yych >= 0xE1) + goto yy872; } } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') - goto yy1043; - if (yych <= 0x7F) - goto yy1027; - goto yy958; - } else { - if (yych <= 0xDF) - goto yy1045; - if (yych <= 0xE0) - goto yy1046; - goto yy1047; - } + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy883; + if (yych <= 0xEF) + goto yy872; + goto yy880; } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1051; - if (yych <= 0xEF) - goto yy1047; - goto yy1048; - } else { - if (yych <= 0xF3) - goto yy1049; - if (yych <= 0xF4) - goto yy1050; - goto yy958; - } + if (yych <= 0xF3) + goto yy881; + if (yych <= 0xF4) + goto yy882; + goto yy864; } } - yy1045: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy1027; - goto yy958; - yy1046: + yy879: ++p; yych = *p; if (yych <= 0x9F) - goto yy958; - if (yych <= 0xBF) - goto yy1045; - goto yy958; - yy1047: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; + goto yy873; if (yych <= 0xBF) - goto yy1045; - goto yy958; - yy1048: + goto yy874; + goto yy873; + yy880: ++p; yych = *p; if (yych <= 0x8F) - goto yy958; + goto yy873; if (yych <= 0xBF) - goto yy1047; - goto yy958; - yy1049: + goto yy872; + goto yy873; + yy881: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy873; if (yych <= 0xBF) - goto yy1047; - goto yy958; - yy1050: + goto yy872; + goto yy873; + yy882: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy873; if (yych <= 0x8F) - goto yy1047; - goto yy958; - yy1051: + goto yy872; + goto yy873; + yy883: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy873; if (yych <= 0x9F) - goto yy1045; - goto yy958; - yy1052: - yyaccept = 0; - marker = ++p; + goto yy874; + goto yy873; + } +} + +// Try to match an HTML block end line of type 5 +bufsize_t _scan_html_block_end_5(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, 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 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, + }; yych = *p; - if (yych <= '=') { - if (yych <= 0x1F) { - if (yych <= '\n') { - if (yych <= 0x00) - goto yy951; - if (yych <= 0x08) - goto yy1029; - goto yy951; - } else { - if (yych == '\r') - goto yy951; - goto yy1029; - } + if (yych <= 0xDF) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy886; + if (yych != '\n') + goto yy888; } else { - if (yych <= '(') { - if (yych <= ' ') - goto yy951; - if (yych <= '\'') - goto yy1052; - goto yy1027; - } else { - if (yych <= ')') - goto yy1016; - if (yych == '<') - goto yy997; - goto yy1052; - } + if (yych <= ']') + goto yy889; + if (yych <= 0x7F) + goto yy888; + if (yych >= 0xC2) + goto yy890; } } else { - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '>') - goto yy1055; - if (yych <= '[') - goto yy1052; - goto yy1056; - } else { - if (yych <= 0x7F) - goto yy1052; - if (yych <= 0xC1) - goto yy951; - if (yych <= 0xDF) - goto yy1057; - goto yy1058; - } + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy891; + if (yych == 0xED) + goto yy893; + goto yy892; } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy1063; - goto yy1059; - } else { - if (yych <= 0xF0) - goto yy1060; - if (yych <= 0xF3) - goto yy1061; - if (yych <= 0xF4) - goto yy1062; - goto yy951; - } + if (yych <= 0xF0) + goto yy894; + if (yych <= 0xF3) + goto yy895; + if (yych <= 0xF4) + goto yy896; } } - yy1054: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yych <= '=') { - if (yych <= 0x1F) { - if (yych <= '\n') { - if (yych <= 0x00) - goto yy1019; - if (yych <= 0x08) - goto yy1029; - goto yy1019; - } else { - if (yych == '\r') - goto yy1019; - goto yy1029; - } - } else { - if (yych <= '(') { - if (yych <= ' ') - goto yy1019; - if (yych <= '\'') - goto yy1027; - goto yy1029; - } else { - if (yych <= ')') - goto yy1016; - if (yych == '<') - goto yy971; - goto yy1027; - } - } + yy886: + ++p; + yy887 : { return 0; } + yy888: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy887; + if (yych <= '\t') + goto yy901; + goto yy887; } else { - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '>') - goto yy1042; - if (yych <= '[') - goto yy1027; - goto yy1043; - } else { - if (yych <= 0x7F) - goto yy1027; - if (yych <= 0xC1) - goto yy1019; - if (yych <= 0xDF) - goto yy1045; - goto yy1046; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy1051; - goto yy1047; - } else { - if (yych <= 0xF0) - goto yy1048; - if (yych <= 0xF3) - goto yy1049; - if (yych <= 0xF4) - goto yy1050; - goto yy1019; - } - } + if (yych <= 0x7F) + goto yy901; + if (yych <= 0xC1) + goto yy887; + if (yych <= 0xF4) + goto yy901; + goto yy887; } - yy1055: - yyaccept = 2; - yych = *(marker = ++p); - if (yych <= ' ') - goto yy1019; - if (yych <= 0x7F) - goto yy998; - if (yych <= 0xC1) - goto yy1019; - if (yych <= 0xF4) - goto yy998; - goto yy1019; - yy1056: + yy889: yyaccept = 0; - marker = ++p; - yych = *p; - if (yych <= '\\') { - if (yych <= '\r') { - if (yych <= 0x08) { - if (yych <= 0x00) - goto yy980; - goto yy1016; - } else { - if (yych <= '\n') - goto yy951; - if (yych <= '\f') - goto yy1029; - goto yy951; - } - } else { - if (yych <= '=') { - if (yych <= 0x1F) - goto yy1016; - if (yych <= ' ') - goto yy951; - goto yy1052; - } else { - if (yych <= '>') - goto yy1064; - if (yych <= '[') - goto yy1052; - goto yy1065; - } - } + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy908; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy887; + if (yych <= '\t') + goto yy901; + goto yy887; } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= 0x7F) - goto yy1052; - goto yy951; - } else { - if (yych <= 0xDF) - goto yy1066; - if (yych <= 0xE0) - goto yy1067; - goto yy1068; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1072; - if (yych <= 0xEF) - goto yy1068; - goto yy1069; - } else { - if (yych <= 0xF3) - goto yy1070; - if (yych <= 0xF4) - goto yy1071; - goto yy951; - } - } + if (yych <= 0x7F) + goto yy901; + if (yych <= 0xC1) + goto yy887; + if (yych <= 0xF4) + goto yy901; + goto yy887; } - yy1057: - ++p; - yych = *p; + yy890: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy887; + if (yych <= 0xBF) + goto yy900; + goto yy887; + yy891: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x9F) + goto yy887; + if (yych <= 0xBF) + goto yy899; + goto yy887; + yy892: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy887; + if (yych <= 0xBF) + goto yy899; + goto yy887; + yy893: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy1052; - goto yy958; - yy1058: - ++p; - yych = *p; + goto yy887; if (yych <= 0x9F) - goto yy958; + goto yy899; + goto yy887; + yy894: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x8F) + goto yy887; if (yych <= 0xBF) - goto yy1057; - goto yy958; - yy1059: - ++p; - yych = *p; + goto yy897; + goto yy887; + yy895: + yyaccept = 0; + yych = *(marker = ++p); if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy1057; - goto yy958; - yy1060: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy958; + goto yy887; if (yych <= 0xBF) - goto yy1059; - goto yy958; - yy1061: + goto yy897; + goto yy887; + yy896: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy887; + if (yych >= 0x90) + goto yy887; + yy897: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy898; if (yych <= 0xBF) - goto yy1059; - goto yy958; - yy1062: + goto yy899; + yy898: + p = marker; + if (yyaccept == 0) { + goto yy887; + } else { + goto yy911; + } + yy899: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; - if (yych <= 0x8F) - goto yy1059; - goto yy958; - yy1063: + goto yy898; + if (yych >= 0xC0) + goto yy898; + yy900: ++p; yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0x9F) - goto yy1057; - goto yy958; - yy1064: - yyaccept = 2; - marker = ++p; - yych = *p; - if (yych <= '=') { - if (yych <= 0x1F) { - if (yych <= '\n') { - if (yych <= 0x00) - goto yy1019; - if (yych <= 0x08) - goto yy1029; - goto yy1019; - } else { - if (yych == '\r') - goto yy1019; - goto yy1029; - } + yy901: + if (yybm[0 + yych] & 64) { + goto yy900; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy898; + if (yych >= '^') + goto yy898; } else { - if (yych <= '(') { - if (yych <= ' ') - goto yy1019; - if (yych <= '\'') - goto yy1052; - goto yy1027; - } else { - if (yych <= ')') - goto yy1016; - if (yych == '<') - goto yy997; - goto yy1052; - } + if (yych <= 0xDF) + goto yy899; + if (yych <= 0xE0) + goto yy903; + goto yy897; } } else { - if (yych <= 0xE0) { - if (yych <= '\\') { - if (yych <= '>') - goto yy1055; - if (yych <= '[') - goto yy1052; - goto yy1056; - } else { - if (yych <= 0x7F) - goto yy1052; - if (yych <= 0xC1) - goto yy1019; - if (yych <= 0xDF) - goto yy1057; - goto yy1058; - } + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy907; + if (yych <= 0xEF) + goto yy897; + goto yy904; } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy1063; - goto yy1059; - } else { - if (yych <= 0xF0) - goto yy1060; - if (yych <= 0xF3) - goto yy1061; - if (yych <= 0xF4) - goto yy1062; - goto yy1019; - } + if (yych <= 0xF3) + goto yy905; + if (yych <= 0xF4) + goto yy906; + goto yy898; } } - yy1065: - yyaccept = 0; - marker = ++p; + yy902: + ++p; yych = *p; - if (yych <= '[') { - if (yych <= 0x1F) { - if (yych <= '\n') { - if (yych <= 0x00) - goto yy951; - if (yych <= 0x08) - goto yy1029; - goto yy951; - } else { - if (yych == '\r') - goto yy951; - goto yy1029; - } + if (yybm[0 + yych] & 64) { + goto yy900; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy898; + if (yych <= ']') + goto yy908; + goto yy898; } else { - if (yych <= '(') { - if (yych <= ' ') - goto yy951; - if (yych <= '\'') - goto yy1052; - goto yy1027; - } else { - if (yych == '>') - goto yy1064; - goto yy1052; - } + if (yych <= 0xDF) + goto yy899; + if (yych >= 0xE1) + goto yy897; } } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') - goto yy1056; - if (yych <= 0x7F) - goto yy1052; - goto yy951; - } else { - if (yych <= 0xDF) - goto yy1057; - if (yych <= 0xE0) - goto yy1058; - goto yy1059; - } + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy907; + if (yych <= 0xEF) + goto yy897; + goto yy904; } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1063; - if (yych <= 0xEF) - goto yy1059; - goto yy1060; - } else { - if (yych <= 0xF3) - goto yy1061; - if (yych <= 0xF4) - goto yy1062; - goto yy951; - } + if (yych <= 0xF3) + goto yy905; + if (yych <= 0xF4) + goto yy906; + goto yy898; } } - yy1066: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy1052; - goto yy958; - yy1067: + yy903: ++p; yych = *p; if (yych <= 0x9F) - goto yy958; - if (yych <= 0xBF) - goto yy1066; - goto yy958; - yy1068: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; + goto yy898; if (yych <= 0xBF) - goto yy1066; - goto yy958; - yy1069: + goto yy899; + goto yy898; + yy904: ++p; yych = *p; if (yych <= 0x8F) - goto yy958; + goto yy898; if (yych <= 0xBF) - goto yy1068; - goto yy958; - yy1070: + goto yy897; + goto yy898; + yy905: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy898; if (yych <= 0xBF) - goto yy1068; - goto yy958; - yy1071: + goto yy897; + goto yy898; + yy906: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy898; if (yych <= 0x8F) - goto yy1068; - goto yy958; - yy1072: + goto yy897; + goto yy898; + yy907: ++p; yych = *p; if (yych <= 0x7F) - goto yy958; + goto yy898; if (yych <= 0x9F) - goto yy1066; - goto yy958; - yy1073: - yyaccept = 2; - marker = ++p; + goto yy899; + goto yy898; + yy908: + ++p; yych = *p; - if (yybm[0 + yych] & 64) { - goto yy1016; + if (yybm[0 + yych] & 128) { + goto yy908; } - if (yych <= '>') { - if (yych <= '\r') { - if (yych <= 0x08) { - if (yych <= 0x00) - goto yy1019; - goto yy1029; - } else { - if (yych <= '\n') - goto yy1019; - if (yych <= '\f') - goto yy1029; - goto yy1019; - } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy898; + if (yych == '\n') + goto yy898; + goto yy900; } else { - if (yych <= '(') { - if (yych <= 0x1F) - goto yy1029; - if (yych <= ' ') - goto yy1019; - goto yy1027; - } else { - if (yych <= ')') - goto yy1029; - if (yych <= '<') - goto yy980; - goto yy1018; - } + if (yych <= '>') + goto yy910; + if (yych <= 0x7F) + goto yy900; + if (yych <= 0xC1) + goto yy898; + goto yy899; } } else { - if (yych <= 0xEC) { - if (yych <= 0xC1) { - if (yych <= '\\') - goto yy1015; - goto yy1019; - } else { - if (yych <= 0xDF) - goto yy1020; - if (yych <= 0xE0) - goto yy1021; - goto yy1022; - } + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy903; + if (yych == 0xED) + goto yy907; + goto yy897; } else { - if (yych <= 0xF0) { - if (yych <= 0xED) - goto yy1026; - if (yych <= 0xEF) - goto yy1022; - goto yy1023; - } else { - if (yych <= 0xF3) - goto yy1024; - if (yych <= 0xF4) - goto yy1025; - goto yy1019; - } + if (yych <= 0xF0) + goto yy904; + if (yych <= 0xF3) + goto yy905; + if (yych <= 0xF4) + goto yy906; + goto yy898; } } - yy1074: - yyaccept = 0; + yy910: + yyaccept = 1; marker = ++p; yych = *p; - if (yych <= '>') { - if (yych <= 0x1F) { - if (yych <= '\n') { - if (yych <= 0x00) - goto yy951; - if (yych <= 0x08) - goto yy1029; - goto yy951; - } else { - if (yych == '\r') - goto yy951; - goto yy1029; - } + if (yybm[0 + yych] & 64) { + goto yy900; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy911; + if (yych <= ']') + goto yy902; } else { - if (yych <= '(') { - if (yych <= ' ') - goto yy951; - if (yych <= '\'') - goto yy1016; - goto yy1027; - } else { - if (yych <= ')') - goto yy1029; - if (yych <= '=') - goto yy1016; - goto yy1073; - } + if (yych <= 0xDF) + goto yy899; + if (yych <= 0xE0) + goto yy903; + goto yy897; } } else { - if (yych <= 0xE0) { - if (yych <= 0x7F) { - if (yych == '\\') - goto yy1015; - goto yy1016; - } else { - if (yych <= 0xC1) - goto yy951; - if (yych <= 0xDF) - goto yy1020; - goto yy1021; - } - } else { - if (yych <= 0xEF) { - if (yych == 0xED) - goto yy1026; - goto yy1022; - } else { - if (yych <= 0xF0) - goto yy1023; - if (yych <= 0xF3) - goto yy1024; - if (yych <= 0xF4) - goto yy1025; - goto yy951; - } + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy907; + if (yych <= 0xEF) + goto yy897; + goto yy904; + } else { + if (yych <= 0xF3) + goto yy905; + if (yych <= 0xF4) + goto yy906; } } - yy1075: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy1016; - goto yy958; - yy1076: - ++p; - yych = *p; - if (yych <= 0x9F) - goto yy958; - if (yych <= 0xBF) - goto yy1075; - goto yy958; - yy1077: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy1075; - goto yy958; - yy1078: - ++p; - yych = *p; - if (yych <= 0x8F) - goto yy958; - if (yych <= 0xBF) - goto yy1077; - goto yy958; - yy1079: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0xBF) - goto yy1077; - goto yy958; - yy1080: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0x8F) - goto yy1077; - goto yy958; - yy1081: - ++p; - yych = *p; - if (yych <= 0x7F) - goto yy958; - if (yych <= 0x9F) - goto yy1075; - goto yy958; + yy911 : { return (bufsize_t)(p - start); } } } @@ -17474,644 +14904,561 @@ bufsize_t _scan_link_title(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - yych = *(marker = p); - if (yych <= 0xC1) { - if (yych <= '"') { - if (yych == '\n') - goto yy1084; - if (yych <= '!') - goto yy1088; - goto yy1085; - } else { - if (yych <= '\'') { - if (yych <= '&') - goto yy1088; - goto yy1086; - } else { - if (yych <= '(') - goto yy1087; - if (yych <= 0x7F) - goto yy1088; - } - } + yych = *p; + if (yych <= '&') { + if (yych == '"') + goto yy916; } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy1089; - if (yych <= 0xE0) - goto yy1091; - if (yych <= 0xEC) - goto yy1092; - goto yy1096; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy1092; - goto yy1093; - } else { - if (yych <= 0xF3) - goto yy1094; - if (yych <= 0xF4) - goto yy1095; - } - } + if (yych <= '\'') + goto yy917; + if (yych <= '(') + goto yy918; } - yy1084 : { return 0; } - yy1085: + ++p; + yy915 : { return 0; } + yy916: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x00) - goto yy1084; + goto yy915; if (yych <= 0x7F) - goto yy1128; + goto yy951; if (yych <= 0xC1) - goto yy1084; + goto yy915; if (yych <= 0xF4) - goto yy1128; - goto yy1084; - yy1086: + goto yy951; + goto yy915; + yy917: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x00) - goto yy1084; + goto yy915; if (yych <= 0x7F) - goto yy1114; + goto yy937; if (yych <= 0xC1) - goto yy1084; + goto yy915; if (yych <= 0xF4) - goto yy1114; - goto yy1084; - yy1087: + goto yy937; + goto yy915; + yy918: yyaccept = 0; yych = *(marker = ++p); if (yych <= 0x00) - goto yy1084; + goto yy915; if (yych <= 0x7F) - goto yy1100; + goto yy923; if (yych <= 0xC1) - goto yy1084; + goto yy915; if (yych <= 0xF4) - goto yy1100; - goto yy1084; - yy1088: - yych = *++p; - goto yy1084; - yy1089: - yych = *++p; - if (yych <= 0x7F) - goto yy1090; - if (yych <= 0xBF) - goto yy1088; - yy1090: - p = marker; - if (yyaccept <= 1) { - if (yyaccept == 0) { - goto yy1084; - } else { - goto yy1109; - } - } else { - if (yyaccept == 2) { - goto yy1123; - } else { - goto yy1137; - } - } - yy1091: - yych = *++p; - if (yych <= 0x9F) - goto yy1090; - if (yych <= 0xBF) - goto yy1089; - goto yy1090; - yy1092: - yych = *++p; - if (yych <= 0x7F) - goto yy1090; - if (yych <= 0xBF) - goto yy1089; - goto yy1090; - yy1093: - yych = *++p; - if (yych <= 0x8F) - goto yy1090; - if (yych <= 0xBF) - goto yy1092; - goto yy1090; - yy1094: - yych = *++p; - if (yych <= 0x7F) - goto yy1090; - if (yych <= 0xBF) - goto yy1092; - goto yy1090; - yy1095: - yych = *++p; - if (yych <= 0x7F) - goto yy1090; - if (yych <= 0x8F) - goto yy1092; - goto yy1090; - yy1096: - yych = *++p; - if (yych <= 0x7F) - goto yy1090; - if (yych <= 0x9F) - goto yy1089; - goto yy1090; - yy1097: + goto yy923; + goto yy915; + yy919: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1099; + goto yy922; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1090; + goto yy921; if (yych <= ')') - goto yy1110; - goto yy1097; + goto yy933; + goto yy919; } else { if (yych <= 0xC1) - goto yy1090; + goto yy921; if (yych <= 0xDF) - goto yy1101; - goto yy1102; + goto yy924; + goto yy925; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1107; - goto yy1103; + goto yy930; + goto yy926; } else { if (yych <= 0xF0) - goto yy1104; + goto yy927; if (yych <= 0xF3) - goto yy1105; + goto yy928; if (yych <= 0xF4) - goto yy1106; - goto yy1090; + goto yy929; + } + } + yy921: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy915; + } else { + goto yy932; + } + } else { + if (yyaccept == 2) { + goto yy946; + } else { + goto yy960; } } - yy1099: + yy922: ++p; yych = *p; - yy1100: + yy923: if (yybm[0 + yych] & 32) { - goto yy1099; + goto yy922; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1090; + goto yy921; if (yych <= ')') - goto yy1108; - goto yy1097; + goto yy931; + goto yy919; } else { if (yych <= 0xC1) - goto yy1090; + goto yy921; if (yych >= 0xE0) - goto yy1102; + goto yy925; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1107; - goto yy1103; + goto yy930; + goto yy926; } else { if (yych <= 0xF0) - goto yy1104; + goto yy927; if (yych <= 0xF3) - goto yy1105; + goto yy928; if (yych <= 0xF4) - goto yy1106; - goto yy1090; + goto yy929; + goto yy921; } } - yy1101: + yy924: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1099; - goto yy1090; - yy1102: + goto yy922; + goto yy921; + yy925: ++p; yych = *p; if (yych <= 0x9F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1101; - goto yy1090; - yy1103: + goto yy924; + goto yy921; + yy926: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1101; - goto yy1090; - yy1104: + goto yy924; + goto yy921; + yy927: ++p; yych = *p; if (yych <= 0x8F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1103; - goto yy1090; - yy1105: + goto yy926; + goto yy921; + yy928: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1103; - goto yy1090; - yy1106: + goto yy926; + goto yy921; + yy929: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0x8F) - goto yy1103; - goto yy1090; - yy1107: + goto yy926; + goto yy921; + yy930: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0x9F) - goto yy1101; - goto yy1090; - yy1108: + goto yy924; + goto yy921; + yy931: ++p; - yy1109 : { return (bufsize_t)(p - start); } - yy1110: + yy932 : { return (bufsize_t)(p - start); } + yy933: yyaccept = 1; marker = ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1099; + goto yy922; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1109; + goto yy932; if (yych <= ')') - goto yy1108; - goto yy1097; + goto yy931; + goto yy919; } else { if (yych <= 0xC1) - goto yy1109; + goto yy932; if (yych <= 0xDF) - goto yy1101; - goto yy1102; + goto yy924; + goto yy925; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1107; - goto yy1103; + goto yy930; + goto yy926; } else { if (yych <= 0xF0) - goto yy1104; + goto yy927; if (yych <= 0xF3) - goto yy1105; + goto yy928; if (yych <= 0xF4) - goto yy1106; - goto yy1109; + goto yy929; + goto yy932; } } - yy1111: + yy934: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1113; + goto yy936; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1090; + goto yy921; if (yych <= '\'') - goto yy1124; - goto yy1111; + goto yy947; + goto yy934; } else { if (yych <= 0xC1) - goto yy1090; + goto yy921; if (yych <= 0xDF) - goto yy1115; - goto yy1116; + goto yy938; + goto yy939; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1121; - goto yy1117; + goto yy944; + goto yy940; } else { if (yych <= 0xF0) - goto yy1118; + goto yy941; if (yych <= 0xF3) - goto yy1119; + goto yy942; if (yych <= 0xF4) - goto yy1120; - goto yy1090; + goto yy943; + goto yy921; } } - yy1113: + yy936: ++p; yych = *p; - yy1114: + yy937: if (yybm[0 + yych] & 64) { - goto yy1113; + goto yy936; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1090; + goto yy921; if (yych <= '\'') - goto yy1122; - goto yy1111; + goto yy945; + goto yy934; } else { if (yych <= 0xC1) - goto yy1090; + goto yy921; if (yych >= 0xE0) - goto yy1116; + goto yy939; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1121; - goto yy1117; + goto yy944; + goto yy940; } else { if (yych <= 0xF0) - goto yy1118; + goto yy941; if (yych <= 0xF3) - goto yy1119; + goto yy942; if (yych <= 0xF4) - goto yy1120; - goto yy1090; + goto yy943; + goto yy921; } } - yy1115: + yy938: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1113; - goto yy1090; - yy1116: + goto yy936; + goto yy921; + yy939: ++p; yych = *p; if (yych <= 0x9F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1115; - goto yy1090; - yy1117: + goto yy938; + goto yy921; + yy940: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1115; - goto yy1090; - yy1118: + goto yy938; + goto yy921; + yy941: ++p; yych = *p; if (yych <= 0x8F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1117; - goto yy1090; - yy1119: + goto yy940; + goto yy921; + yy942: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1117; - goto yy1090; - yy1120: + goto yy940; + goto yy921; + yy943: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0x8F) - goto yy1117; - goto yy1090; - yy1121: + goto yy940; + goto yy921; + yy944: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0x9F) - goto yy1115; - goto yy1090; - yy1122: + goto yy938; + goto yy921; + yy945: ++p; - yy1123 : { return (bufsize_t)(p - start); } - yy1124: + yy946 : { return (bufsize_t)(p - start); } + yy947: yyaccept = 2; marker = ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1113; + goto yy936; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1123; + goto yy946; if (yych <= '\'') - goto yy1122; - goto yy1111; + goto yy945; + goto yy934; } else { if (yych <= 0xC1) - goto yy1123; + goto yy946; if (yych <= 0xDF) - goto yy1115; - goto yy1116; + goto yy938; + goto yy939; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1121; - goto yy1117; + goto yy944; + goto yy940; } else { if (yych <= 0xF0) - goto yy1118; + goto yy941; if (yych <= 0xF3) - goto yy1119; + goto yy942; if (yych <= 0xF4) - goto yy1120; - goto yy1123; + goto yy943; + goto yy946; } } - yy1125: + yy948: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1127; + goto yy950; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1090; + goto yy921; if (yych <= '"') - goto yy1138; - goto yy1125; + goto yy961; + goto yy948; } else { if (yych <= 0xC1) - goto yy1090; + goto yy921; if (yych <= 0xDF) - goto yy1129; - goto yy1130; + goto yy952; + goto yy953; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1135; - goto yy1131; + goto yy958; + goto yy954; } else { if (yych <= 0xF0) - goto yy1132; + goto yy955; if (yych <= 0xF3) - goto yy1133; + goto yy956; if (yych <= 0xF4) - goto yy1134; - goto yy1090; + goto yy957; + goto yy921; } } - yy1127: + yy950: ++p; yych = *p; - yy1128: + yy951: if (yybm[0 + yych] & 128) { - goto yy1127; + goto yy950; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1090; + goto yy921; if (yych <= '"') - goto yy1136; - goto yy1125; + goto yy959; + goto yy948; } else { if (yych <= 0xC1) - goto yy1090; + goto yy921; if (yych >= 0xE0) - goto yy1130; + goto yy953; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1135; - goto yy1131; + goto yy958; + goto yy954; } else { if (yych <= 0xF0) - goto yy1132; + goto yy955; if (yych <= 0xF3) - goto yy1133; + goto yy956; if (yych <= 0xF4) - goto yy1134; - goto yy1090; + goto yy957; + goto yy921; } } - yy1129: + yy952: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1127; - goto yy1090; - yy1130: + goto yy950; + goto yy921; + yy953: ++p; yych = *p; if (yych <= 0x9F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1129; - goto yy1090; - yy1131: + goto yy952; + goto yy921; + yy954: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1129; - goto yy1090; - yy1132: + goto yy952; + goto yy921; + yy955: ++p; yych = *p; if (yych <= 0x8F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1131; - goto yy1090; - yy1133: + goto yy954; + goto yy921; + yy956: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0xBF) - goto yy1131; - goto yy1090; - yy1134: + goto yy954; + goto yy921; + yy957: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0x8F) - goto yy1131; - goto yy1090; - yy1135: + goto yy954; + goto yy921; + yy958: ++p; yych = *p; if (yych <= 0x7F) - goto yy1090; + goto yy921; if (yych <= 0x9F) - goto yy1129; - goto yy1090; - yy1136: + goto yy952; + goto yy921; + yy959: ++p; - yy1137 : { return (bufsize_t)(p - start); } - yy1138: + yy960 : { return (bufsize_t)(p - start); } + yy961: yyaccept = 3; marker = ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1127; + goto yy950; } if (yych <= 0xE0) { if (yych <= '\\') { if (yych <= 0x00) - goto yy1137; + goto yy960; if (yych <= '"') - goto yy1136; - goto yy1125; + goto yy959; + goto yy948; } else { if (yych <= 0xC1) - goto yy1137; + goto yy960; if (yych <= 0xDF) - goto yy1129; - goto yy1130; + goto yy952; + goto yy953; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1135; - goto yy1131; + goto yy958; + goto yy954; } else { if (yych <= 0xF0) - goto yy1132; + goto yy955; if (yych <= 0xF3) - goto yy1133; + goto yy956; if (yych <= 0xF4) - goto yy1134; - goto yy1137; + goto yy957; + goto yy960; } } } @@ -18119,7 +15466,6 @@ bufsize_t _scan_link_title(const unsigned char *p) { // Match space characters, including newlines. bufsize_t _scan_spacechars(const unsigned char *p) { - const unsigned char *marker = NULL; const unsigned char *start = p; { @@ -18139,108 +15485,29 @@ bufsize_t _scan_spacechars(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); - if (yych <= 0xC1) { - if (yych <= '\r') { - if (yych <= 0x08) - goto yy1145; - if (yych == '\n') - goto yy1143; - goto yy1142; - } else { - if (yych == ' ') - goto yy1142; - if (yych <= 0x7F) - goto yy1145; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy1147; - if (yych <= 0xE0) - goto yy1149; - if (yych <= 0xEC) - goto yy1150; - goto yy1154; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy1150; - goto yy1151; - } else { - if (yych <= 0xF3) - goto yy1152; - if (yych <= 0xF4) - goto yy1153; - } - } - } - yy1141 : { return (bufsize_t)(p - start); } - yy1142: - yych = *++p; - goto yy1144; - yy1143: - ++p; yych = *p; - yy1144: - if (yybm[0 + yych] & 128) { - goto yy1143; - } - goto yy1141; - yy1145: + if (yych <= 0x08) + goto yy964; + if (yych <= '\r') + goto yy966; + if (yych == ' ') + goto yy966; + yy964: ++p; { return 0; } - yy1147: - yych = *++p; - if (yych <= 0x7F) - goto yy1148; - if (yych <= 0xBF) - goto yy1145; - yy1148: - p = marker; - goto yy1141; - yy1149: - yych = *++p; - if (yych <= 0x9F) - goto yy1148; - if (yych <= 0xBF) - goto yy1147; - goto yy1148; - yy1150: - yych = *++p; - if (yych <= 0x7F) - goto yy1148; - if (yych <= 0xBF) - goto yy1147; - goto yy1148; - yy1151: - yych = *++p; - if (yych <= 0x8F) - goto yy1148; - if (yych <= 0xBF) - goto yy1150; - goto yy1148; - yy1152: - yych = *++p; - if (yych <= 0x7F) - goto yy1148; - if (yych <= 0xBF) - goto yy1150; - goto yy1148; - yy1153: - yych = *++p; - if (yych <= 0x7F) - goto yy1148; - if (yych <= 0x8F) - goto yy1150; - goto yy1148; - yy1154: + yy966: ++p; - if ((yych = *p) <= 0x7F) - goto yy1148; - if (yych <= 0x9F) - goto yy1147; - goto yy1148; + yych = *p; + goto yy969; + yy967 : { return (bufsize_t)(p - start); } + yy968: + ++p; + yych = *p; + yy969: + if (yybm[0 + yych] & 128) { + goto yy968; + } + goto yy967; } } @@ -18265,403 +15532,263 @@ bufsize_t _scan_atx_heading_start(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); - if (yych <= 0xDF) { - if (yych <= '"') { - if (yych != '\n') - goto yy1159; - } else { - if (yych <= '#') - goto yy1158; - if (yych <= 0x7F) - goto yy1159; - if (yych >= 0xC2) - goto yy1160; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy1162; - if (yych == 0xED) - goto yy1167; - goto yy1163; - } else { - if (yych <= 0xF0) - goto yy1164; - if (yych <= 0xF3) - goto yy1165; - if (yych <= 0xF4) - goto yy1166; - } - } - yy1157 : { return 0; } - yy1158: + yych = *p; + if (yych == '#') + goto yy974; + ++p; + yy973 : { return 0; } + yy974: yych = *(marker = ++p); if (yybm[0 + yych] & 128) { - goto yy1170; + goto yy977; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1157; - if (yych <= '\n') - goto yy1168; - goto yy1157; + goto yy973; + if (yych >= '\v') + goto yy973; } else { if (yych <= '\r') - goto yy1168; + goto yy975; if (yych == '#') - goto yy1172; - goto yy1157; + goto yy979; + goto yy973; } - yy1159: - yych = *++p; - goto yy1157; - yy1160: - yych = *++p; - if (yych <= 0x7F) - goto yy1161; - if (yych <= 0xBF) - goto yy1159; - yy1161: - p = marker; - goto yy1157; - yy1162: - yych = *++p; - if (yych <= 0x9F) - goto yy1161; - if (yych <= 0xBF) - goto yy1160; - goto yy1161; - yy1163: - yych = *++p; - if (yych <= 0x7F) - goto yy1161; - if (yych <= 0xBF) - goto yy1160; - goto yy1161; - yy1164: - yych = *++p; - if (yych <= 0x8F) - goto yy1161; - if (yych <= 0xBF) - goto yy1163; - goto yy1161; - yy1165: - yych = *++p; - if (yych <= 0x7F) - goto yy1161; - if (yych <= 0xBF) - goto yy1163; - goto yy1161; - yy1166: - yych = *++p; - if (yych <= 0x7F) - goto yy1161; - if (yych <= 0x8F) - goto yy1163; - goto yy1161; - yy1167: - yych = *++p; - if (yych <= 0x7F) - goto yy1161; - if (yych <= 0x9F) - goto yy1160; - goto yy1161; - yy1168: + yy975: ++p; - yy1169 : { return (bufsize_t)(p - start); } - yy1170: + yy976 : { return (bufsize_t)(p - start); } + yy977: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1170; + goto yy977; } - goto yy1169; - yy1172: + goto yy976; + yy979: yych = *++p; if (yybm[0 + yych] & 128) { - goto yy1170; + goto yy977; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1161; + goto yy980; if (yych <= '\n') - goto yy1168; - goto yy1161; + goto yy975; } else { if (yych <= '\r') - goto yy1168; - if (yych != '#') - goto yy1161; + goto yy975; + if (yych == '#') + goto yy981; } + yy980: + p = marker; + goto yy973; + yy981: yych = *++p; if (yybm[0 + yych] & 128) { - goto yy1170; + goto yy977; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1161; + goto yy980; if (yych <= '\n') - goto yy1168; - goto yy1161; + goto yy975; + goto yy980; } else { if (yych <= '\r') - goto yy1168; + goto yy975; if (yych != '#') - goto yy1161; + goto yy980; } yych = *++p; if (yybm[0 + yych] & 128) { - goto yy1170; + goto yy977; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1161; + goto yy980; if (yych <= '\n') - goto yy1168; - goto yy1161; + goto yy975; + goto yy980; } else { if (yych <= '\r') - goto yy1168; + goto yy975; if (yych != '#') - goto yy1161; + goto yy980; } yych = *++p; if (yybm[0 + yych] & 128) { - goto yy1170; + goto yy977; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1161; + goto yy980; if (yych <= '\n') - goto yy1168; - goto yy1161; + goto yy975; + goto yy980; } else { if (yych <= '\r') - goto yy1168; + goto yy975; if (yych != '#') - goto yy1161; + goto yy980; } ++p; if (yybm[0 + (yych = *p)] & 128) { - goto yy1170; - } - if (yych <= 0x08) - goto yy1161; - if (yych <= '\n') - goto yy1168; - if (yych == '\r') - goto yy1168; - goto yy1161; - } -} - -// Match setext heading line. Return 1 for level-1 heading, -// 2 for level-2, 0 for no match. -bufsize_t _scan_setext_heading_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 = *(marker = p); - if (yych <= 0xC1) { - if (yych <= '-') { - if (yych == '\n') - goto yy1179; - if (yych <= ',') - goto yy1182; - goto yy1181; - } else { - if (yych == '=') - goto yy1180; - if (yych <= 0x7F) - goto yy1182; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy1183; - if (yych <= 0xE0) - goto yy1185; - if (yych <= 0xEC) - goto yy1186; - goto yy1190; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy1186; - goto yy1187; - } else { - if (yych <= 0xF3) - goto yy1188; - if (yych <= 0xF4) - goto yy1189; - } - } + goto yy977; } - yy1179 : { return 0; } - yy1180: + if (yych <= 0x08) + goto yy980; + if (yych <= '\n') + goto yy975; + if (yych == '\r') + goto yy975; + goto yy980; + } +} + +// Match setext heading line. Return 1 for level-1 heading, +// 2 for level-2, 0 for no match. +bufsize_t _scan_setext_heading_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, 32, 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, 128, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 == '-') + goto yy989; + if (yych == '=') + goto yy990; + ++p; + yy988 : { return 0; } + yy989: yych = *(marker = ++p); if (yybm[0 + yych] & 128) { - goto yy1201; + goto yy1002; } if (yych <= '\f') { - if (yych == '\n') - goto yy1199; - goto yy1179; + if (yych <= 0x08) + goto yy988; + if (yych <= '\n') + goto yy999; + goto yy988; } else { if (yych <= '\r') - goto yy1199; + goto yy999; if (yych == ' ') - goto yy1197; - goto yy1179; + goto yy999; + goto yy988; } - yy1181: + yy990: yych = *(marker = ++p); - if (yybm[0 + yych] & 32) { - goto yy1191; + if (yybm[0 + yych] & 64) { + goto yy996; } if (yych <= '\f') { - if (yych == '\n') - goto yy1193; - goto yy1179; + if (yych <= 0x08) + goto yy988; + if (yych <= '\n') + goto yy992; + goto yy988; } else { if (yych <= '\r') - goto yy1193; - if (yych == '-') - goto yy1195; - goto yy1179; + goto yy992; + if (yych == ' ') + goto yy992; + goto yy988; } - yy1182: - yych = *++p; - goto yy1179; - yy1183: - yych = *++p; - if (yych <= 0x7F) - goto yy1184; - if (yych <= 0xBF) - goto yy1182; - yy1184: - p = marker; - goto yy1179; - yy1185: - yych = *++p; - if (yych <= 0x9F) - goto yy1184; - if (yych <= 0xBF) - goto yy1183; - goto yy1184; - yy1186: - yych = *++p; - if (yych <= 0x7F) - goto yy1184; - if (yych <= 0xBF) - goto yy1183; - goto yy1184; - yy1187: - yych = *++p; - if (yych <= 0x8F) - goto yy1184; - if (yych <= 0xBF) - goto yy1186; - goto yy1184; - yy1188: - yych = *++p; - if (yych <= 0x7F) - goto yy1184; - if (yych <= 0xBF) - goto yy1186; - goto yy1184; - yy1189: - yych = *++p; - if (yych <= 0x7F) - goto yy1184; - if (yych <= 0x8F) - goto yy1186; - goto yy1184; - yy1190: - yych = *++p; - if (yych <= 0x7F) - goto yy1184; - if (yych <= 0x9F) - goto yy1183; - goto yy1184; - yy1191: + yy991: ++p; yych = *p; + yy992: if (yybm[0 + yych] & 32) { - goto yy1191; + goto yy991; } - if (yych == '\n') - goto yy1193; - if (yych != '\r') - goto yy1184; - yy1193: + if (yych <= 0x08) + goto yy993; + if (yych <= '\n') + goto yy994; + if (yych == '\r') + goto yy994; + yy993: + p = marker; + goto yy988; + yy994: ++p; - { return 2; } - yy1195: + { return 1; } + yy996: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1191; + goto yy991; } if (yych <= '\f') { - if (yych == '\n') - goto yy1193; - goto yy1184; + if (yych <= 0x08) + goto yy993; + if (yych <= '\n') + goto yy994; + goto yy993; } else { if (yych <= '\r') - goto yy1193; - if (yych == '-') - goto yy1195; - goto yy1184; + goto yy994; + if (yych == '=') + goto yy996; + goto yy993; } - yy1197: + yy998: ++p; yych = *p; + yy999: if (yych <= '\f') { - if (yych != '\n') - goto yy1184; + if (yych <= 0x08) + goto yy993; + if (yych <= '\t') + goto yy998; + if (yych >= '\v') + goto yy993; } else { if (yych <= '\r') - goto yy1199; + goto yy1000; if (yych == ' ') - goto yy1197; - goto yy1184; + goto yy998; + goto yy993; } - yy1199: + yy1000: ++p; - { return 1; } - yy1201: + { return 2; } + yy1002: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1201; + goto yy1002; } if (yych <= '\f') { - if (yych == '\n') - goto yy1199; - goto yy1184; + if (yych <= 0x08) + goto yy993; + if (yych <= '\t') + goto yy998; + if (yych <= '\n') + goto yy1000; + goto yy993; } else { if (yych <= '\r') - goto yy1199; + goto yy1000; if (yych == ' ') - goto yy1197; - goto yy1184; + goto yy998; + goto yy993; } } } @@ -18678,9 +15805,9 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { static const unsigned char yybm[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 128, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 128, 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, 64, 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, @@ -18690,335 +15817,251 @@ bufsize_t _scan_thematic_break(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); - if (yych <= 0x7F) { - if (yych <= '*') { - if (yych == '\n') - goto yy1205; - if (yych <= ')') - goto yy1209; - goto yy1206; - } else { - if (yych <= '-') { - if (yych <= ',') - goto yy1209; - goto yy1208; - } else { - if (yych == '_') - goto yy1207; - goto yy1209; - } - } + yych = *p; + if (yych <= ',') { + if (yych == '*') + goto yy1008; } else { - if (yych <= 0xED) { - if (yych <= 0xDF) { - if (yych >= 0xC2) - goto yy1210; - } else { - if (yych <= 0xE0) - goto yy1212; - if (yych <= 0xEC) - goto yy1213; - goto yy1217; - } - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy1213; - goto yy1214; - } else { - if (yych <= 0xF3) - goto yy1215; - if (yych <= 0xF4) - goto yy1216; - } - } + if (yych <= '-') + goto yy1009; + if (yych == '_') + goto yy1010; } - yy1205 : { return 0; } - yy1206: + ++p; + yy1007 : { return 0; } + yy1008: yych = *(marker = ++p); if (yych <= 0x1F) { if (yych == '\t') - goto yy1238; - goto yy1205; + goto yy1032; + goto yy1007; } else { if (yych <= ' ') - goto yy1238; + goto yy1032; if (yych == '*') - goto yy1240; - goto yy1205; + goto yy1034; + goto yy1007; } - yy1207: + yy1009: yych = *(marker = ++p); if (yych <= 0x1F) { if (yych == '\t') - goto yy1228; - goto yy1205; + goto yy1022; + goto yy1007; } else { if (yych <= ' ') - goto yy1228; - if (yych == '_') - goto yy1230; - goto yy1205; + goto yy1022; + if (yych == '-') + goto yy1024; + goto yy1007; } - yy1208: + yy1010: yych = *(marker = ++p); if (yybm[0 + yych] & 16) { - goto yy1218; + goto yy1011; } - if (yych == '-') - goto yy1220; - goto yy1205; - yy1209: - yych = *++p; - goto yy1205; - yy1210: - yych = *++p; - if (yych <= 0x7F) - goto yy1211; - if (yych <= 0xBF) - goto yy1209; - yy1211: - p = marker; - goto yy1205; - yy1212: - yych = *++p; - if (yych <= 0x9F) - goto yy1211; - if (yych <= 0xBF) - goto yy1210; - goto yy1211; - yy1213: - yych = *++p; - if (yych <= 0x7F) - goto yy1211; - if (yych <= 0xBF) - goto yy1210; - goto yy1211; - yy1214: - yych = *++p; - if (yych <= 0x8F) - goto yy1211; - if (yych <= 0xBF) - goto yy1213; - goto yy1211; - yy1215: - yych = *++p; - if (yych <= 0x7F) - goto yy1211; - if (yych <= 0xBF) - goto yy1213; - goto yy1211; - yy1216: - yych = *++p; - if (yych <= 0x7F) - goto yy1211; - if (yych <= 0x8F) - goto yy1213; - goto yy1211; - yy1217: - yych = *++p; - if (yych <= 0x7F) - goto yy1211; - if (yych <= 0x9F) - goto yy1210; - goto yy1211; - yy1218: + if (yych == '_') + goto yy1014; + goto yy1007; + yy1011: ++p; yych = *p; if (yybm[0 + yych] & 16) { - goto yy1218; + goto yy1011; } - if (yych != '-') - goto yy1211; - yy1220: + if (yych == '_') + goto yy1014; + yy1013: + p = marker; + goto yy1007; + yy1014: ++p; yych = *p; if (yych <= 0x1F) { if (yych == '\t') - goto yy1220; - goto yy1211; + goto yy1014; + goto yy1013; } else { if (yych <= ' ') - goto yy1220; - if (yych != '-') - goto yy1211; + goto yy1014; + if (yych != '_') + goto yy1013; } - yy1222: + yy1016: ++p; yych = *p; if (yych <= '\r') { if (yych <= '\t') { if (yych <= 0x08) - goto yy1211; - goto yy1222; + goto yy1013; + goto yy1016; } else { if (yych <= '\n') - goto yy1224; + goto yy1018; if (yych <= '\f') - goto yy1211; + goto yy1013; } } else { if (yych <= ' ') { if (yych <= 0x1F) - goto yy1211; - goto yy1222; + goto yy1013; + goto yy1016; } else { - if (yych == '-') - goto yy1226; - goto yy1211; + if (yych == '_') + goto yy1020; + goto yy1013; } } - yy1224: + yy1018: ++p; { return (bufsize_t)(p - start); } - yy1226: + yy1020: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1226; + goto yy1020; } if (yych <= 0x08) - goto yy1211; + goto yy1013; if (yych <= '\n') - goto yy1224; + goto yy1018; if (yych == '\r') - goto yy1224; - goto yy1211; - yy1228: + goto yy1018; + goto yy1013; + yy1022: ++p; yych = *p; if (yych <= 0x1F) { if (yych == '\t') - goto yy1228; - goto yy1211; + goto yy1022; + goto yy1013; } else { if (yych <= ' ') - goto yy1228; - if (yych != '_') - goto yy1211; + goto yy1022; + if (yych != '-') + goto yy1013; } - yy1230: + yy1024: ++p; yych = *p; if (yych <= 0x1F) { if (yych == '\t') - goto yy1230; - goto yy1211; + goto yy1024; + goto yy1013; } else { if (yych <= ' ') - goto yy1230; - if (yych != '_') - goto yy1211; + goto yy1024; + if (yych != '-') + goto yy1013; } - yy1232: + yy1026: ++p; yych = *p; if (yych <= '\r') { if (yych <= '\t') { if (yych <= 0x08) - goto yy1211; - goto yy1232; + goto yy1013; + goto yy1026; } else { if (yych <= '\n') - goto yy1234; + goto yy1028; if (yych <= '\f') - goto yy1211; + goto yy1013; } } else { if (yych <= ' ') { if (yych <= 0x1F) - goto yy1211; - goto yy1232; + goto yy1013; + goto yy1026; } else { - if (yych == '_') - goto yy1236; - goto yy1211; + if (yych == '-') + goto yy1030; + goto yy1013; } } - yy1234: + yy1028: ++p; { return (bufsize_t)(p - start); } - yy1236: + yy1030: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1236; + goto yy1030; } if (yych <= 0x08) - goto yy1211; + goto yy1013; if (yych <= '\n') - goto yy1234; + goto yy1028; if (yych == '\r') - goto yy1234; - goto yy1211; - yy1238: + goto yy1028; + goto yy1013; + yy1032: ++p; yych = *p; if (yych <= 0x1F) { if (yych == '\t') - goto yy1238; - goto yy1211; + goto yy1032; + goto yy1013; } else { if (yych <= ' ') - goto yy1238; + goto yy1032; if (yych != '*') - goto yy1211; + goto yy1013; } - yy1240: + yy1034: ++p; yych = *p; if (yych <= 0x1F) { if (yych == '\t') - goto yy1240; - goto yy1211; + goto yy1034; + goto yy1013; } else { if (yych <= ' ') - goto yy1240; + goto yy1034; if (yych != '*') - goto yy1211; + goto yy1013; } - yy1242: + yy1036: ++p; yych = *p; if (yych <= '\r') { if (yych <= '\t') { if (yych <= 0x08) - goto yy1211; - goto yy1242; + goto yy1013; + goto yy1036; } else { if (yych <= '\n') - goto yy1244; + goto yy1038; if (yych <= '\f') - goto yy1211; + goto yy1013; } } else { if (yych <= ' ') { if (yych <= 0x1F) - goto yy1211; - goto yy1242; + goto yy1013; + goto yy1036; } else { if (yych == '*') - goto yy1246; - goto yy1211; + goto yy1040; + goto yy1013; } } - yy1244: + yy1038: ++p; { return (bufsize_t)(p - start); } - yy1246: + yy1040: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1246; + goto yy1040; } if (yych <= 0x08) - goto yy1211; + goto yy1013; if (yych <= '\n') - goto yy1244; + goto yy1038; if (yych == '\r') - goto yy1244; - goto yy1211; + goto yy1038; + goto yy1013; } } @@ -19050,378 +16093,294 @@ bufsize_t _scan_open_code_fence(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - yych = *(marker = p); - if (yych <= 0xC1) { - if (yych <= '`') { - if (yych == '\n') - goto yy1250; - if (yych <= '_') - goto yy1253; - goto yy1251; - } else { - if (yych == '~') - goto yy1252; - if (yych <= 0x7F) - goto yy1253; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy1254; - if (yych <= 0xE0) - goto yy1256; - if (yych <= 0xEC) - goto yy1257; - goto yy1261; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy1257; - goto yy1258; - } else { - if (yych <= 0xF3) - goto yy1259; - if (yych <= 0xF4) - goto yy1260; - } - } - } - yy1250 : { return 0; } - yy1251: + yych = *p; + if (yych == '`') + goto yy1046; + if (yych == '~') + goto yy1047; + ++p; + yy1045 : { return 0; } + yy1046: yych = *(marker = ++p); if (yych == '`') - goto yy1276; - goto yy1250; - yy1252: + goto yy1063; + goto yy1045; + yy1047: yych = *(marker = ++p); - if (yych == '~') - goto yy1262; - goto yy1250; - yy1253: - yych = *++p; - goto yy1250; - yy1254: - yych = *++p; - if (yych <= 0x7F) - goto yy1255; - if (yych <= 0xBF) - goto yy1253; - yy1255: - p = marker; - goto yy1250; - yy1256: - yych = *++p; - if (yych <= 0x9F) - goto yy1255; - if (yych <= 0xBF) - goto yy1254; - goto yy1255; - yy1257: - yych = *++p; - if (yych <= 0x7F) - goto yy1255; - if (yych <= 0xBF) - goto yy1254; - goto yy1255; - yy1258: - yych = *++p; - if (yych <= 0x8F) - goto yy1255; - if (yych <= 0xBF) - goto yy1257; - goto yy1255; - yy1259: - yych = *++p; - if (yych <= 0x7F) - goto yy1255; - if (yych <= 0xBF) - goto yy1257; - goto yy1255; - yy1260: - yych = *++p; - if (yych <= 0x7F) - goto yy1255; - if (yych <= 0x8F) - goto yy1257; - goto yy1255; - yy1261: - yych = *++p; - if (yych <= 0x7F) - goto yy1255; - if (yych <= 0x9F) - goto yy1254; - goto yy1255; - yy1262: + if (yych != '~') + goto yy1045; yych = *++p; if (yybm[0 + yych] & 16) { - goto yy1263; + goto yy1050; } - goto yy1255; - yy1263: + yy1049: + p = marker; + goto yy1045; + yy1050: ++p; yych = *p; marker = p; if (yybm[0 + yych] & 32) { - goto yy1265; + goto yy1052; } if (yych <= 0xE0) { if (yych <= '~') { if (yych <= 0x00) - goto yy1255; + goto yy1049; if (yych <= '\r') - goto yy1274; - goto yy1263; + goto yy1061; + goto yy1050; } else { if (yych <= 0xC1) - goto yy1255; + goto yy1049; if (yych <= 0xDF) - goto yy1267; - goto yy1268; + goto yy1054; + goto yy1055; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1273; - goto yy1269; + goto yy1060; + goto yy1056; } else { if (yych <= 0xF0) - goto yy1270; + goto yy1057; if (yych <= 0xF3) - goto yy1271; + goto yy1058; if (yych <= 0xF4) - goto yy1272; - goto yy1255; + goto yy1059; + goto yy1049; } } - yy1265: + yy1052: ++p; yych = *p; if (yybm[0 + yych] & 32) { - goto yy1265; + goto yy1052; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1255; + goto yy1049; if (yych <= '\r') - goto yy1274; - goto yy1255; + goto yy1061; + goto yy1049; } else { if (yych <= 0xDF) - goto yy1267; + goto yy1054; if (yych <= 0xE0) - goto yy1268; - goto yy1269; + goto yy1055; + goto yy1056; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1273; + goto yy1060; if (yych <= 0xEF) - goto yy1269; - goto yy1270; + goto yy1056; + goto yy1057; } else { if (yych <= 0xF3) - goto yy1271; + goto yy1058; if (yych <= 0xF4) - goto yy1272; - goto yy1255; + goto yy1059; + goto yy1049; } } - yy1267: + yy1054: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1049; if (yych <= 0xBF) - goto yy1265; - goto yy1255; - yy1268: + goto yy1052; + goto yy1049; + yy1055: ++p; yych = *p; if (yych <= 0x9F) - goto yy1255; + goto yy1049; if (yych <= 0xBF) - goto yy1267; - goto yy1255; - yy1269: + goto yy1054; + goto yy1049; + yy1056: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1049; if (yych <= 0xBF) - goto yy1267; - goto yy1255; - yy1270: + goto yy1054; + goto yy1049; + yy1057: ++p; yych = *p; if (yych <= 0x8F) - goto yy1255; + goto yy1049; if (yych <= 0xBF) - goto yy1269; - goto yy1255; - yy1271: + goto yy1056; + goto yy1049; + yy1058: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1049; if (yych <= 0xBF) - goto yy1269; - goto yy1255; - yy1272: + goto yy1056; + goto yy1049; + yy1059: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1049; if (yych <= 0x8F) - goto yy1269; - goto yy1255; - yy1273: + goto yy1056; + goto yy1049; + yy1060: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1049; if (yych <= 0x9F) - goto yy1267; - goto yy1255; - yy1274: + goto yy1054; + goto yy1049; + yy1061: ++p; p = marker; { return (bufsize_t)(p - start); } - yy1276: + yy1063: yych = *++p; if (yybm[0 + yych] & 64) { - goto yy1277; + goto yy1064; } - goto yy1255; - yy1277: + goto yy1049; + yy1064: ++p; yych = *p; marker = p; if (yybm[0 + yych] & 128) { - goto yy1279; + goto yy1066; } if (yych <= 0xE0) { if (yych <= '`') { if (yych <= 0x00) - goto yy1255; + goto yy1049; if (yych <= '\r') - goto yy1288; - goto yy1277; + goto yy1075; + goto yy1064; } else { if (yych <= 0xC1) - goto yy1255; + goto yy1049; if (yych <= 0xDF) - goto yy1281; - goto yy1282; + goto yy1068; + goto yy1069; } } else { if (yych <= 0xEF) { if (yych == 0xED) - goto yy1287; - goto yy1283; + goto yy1074; + goto yy1070; } else { if (yych <= 0xF0) - goto yy1284; + goto yy1071; if (yych <= 0xF3) - goto yy1285; + goto yy1072; if (yych <= 0xF4) - goto yy1286; - goto yy1255; + goto yy1073; + goto yy1049; } } - yy1279: + yy1066: ++p; yych = *p; if (yybm[0 + yych] & 128) { - goto yy1279; + goto yy1066; } if (yych <= 0xEC) { if (yych <= 0xC1) { if (yych <= 0x00) - goto yy1255; + goto yy1049; if (yych <= '\r') - goto yy1288; - goto yy1255; + goto yy1075; + goto yy1049; } else { if (yych <= 0xDF) - goto yy1281; + goto yy1068; if (yych <= 0xE0) - goto yy1282; - goto yy1283; + goto yy1069; + goto yy1070; } } else { if (yych <= 0xF0) { if (yych <= 0xED) - goto yy1287; + goto yy1074; if (yych <= 0xEF) - goto yy1283; - goto yy1284; + goto yy1070; + goto yy1071; } else { if (yych <= 0xF3) - goto yy1285; + goto yy1072; if (yych <= 0xF4) - goto yy1286; - goto yy1255; + goto yy1073; + goto yy1049; } } - yy1281: + yy1068: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1049; if (yych <= 0xBF) - goto yy1279; - goto yy1255; - yy1282: + goto yy1066; + goto yy1049; + yy1069: ++p; yych = *p; if (yych <= 0x9F) - goto yy1255; + goto yy1049; if (yych <= 0xBF) - goto yy1281; - goto yy1255; - yy1283: + goto yy1068; + goto yy1049; + yy1070: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1049; if (yych <= 0xBF) - goto yy1281; - goto yy1255; - yy1284: + goto yy1068; + goto yy1049; + yy1071: ++p; yych = *p; if (yych <= 0x8F) - goto yy1255; + goto yy1049; if (yych <= 0xBF) - goto yy1283; - goto yy1255; - yy1285: + goto yy1070; + goto yy1049; + yy1072: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1049; if (yych <= 0xBF) - goto yy1283; - goto yy1255; - yy1286: + goto yy1070; + goto yy1049; + yy1073: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1049; if (yych <= 0x8F) - goto yy1283; - goto yy1255; - yy1287: + goto yy1070; + goto yy1049; + yy1074: ++p; yych = *p; if (yych <= 0x7F) - goto yy1255; + goto yy1049; if (yych <= 0x9F) - goto yy1281; - goto yy1255; - yy1288: + goto yy1068; + goto yy1049; + yy1075: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -19449,194 +16408,110 @@ bufsize_t _scan_close_code_fence(const unsigned char *p) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 = *(marker = p); - if (yych <= 0xC1) { - if (yych <= '`') { - if (yych == '\n') - goto yy1292; - if (yych <= '_') - goto yy1295; - goto yy1293; - } else { - if (yych == '~') - goto yy1294; - if (yych <= 0x7F) - goto yy1295; - } - } else { - if (yych <= 0xED) { - if (yych <= 0xDF) - goto yy1296; - if (yych <= 0xE0) - goto yy1298; - if (yych <= 0xEC) - goto yy1299; - goto yy1303; - } else { - if (yych <= 0xF0) { - if (yych <= 0xEF) - goto yy1299; - goto yy1300; - } else { - if (yych <= 0xF3) - goto yy1301; - if (yych <= 0xF4) - goto yy1302; - } - } - } - yy1292 : { return 0; } - yy1293: + yych = *p; + if (yych == '`') + goto yy1081; + if (yych == '~') + goto yy1082; + ++p; + yy1080 : { return 0; } + yy1081: yych = *(marker = ++p); if (yych == '`') - goto yy1311; - goto yy1292; - yy1294: + goto yy1091; + goto yy1080; + yy1082: yych = *(marker = ++p); - if (yych == '~') - goto yy1304; - goto yy1292; - yy1295: - yych = *++p; - goto yy1292; - yy1296: - yych = *++p; - if (yych <= 0x7F) - goto yy1297; - if (yych <= 0xBF) - goto yy1295; - yy1297: - p = marker; - goto yy1292; - yy1298: - yych = *++p; - if (yych <= 0x9F) - goto yy1297; - if (yych <= 0xBF) - goto yy1296; - goto yy1297; - yy1299: - yych = *++p; - if (yych <= 0x7F) - goto yy1297; - if (yych <= 0xBF) - goto yy1296; - goto yy1297; - yy1300: - yych = *++p; - if (yych <= 0x8F) - goto yy1297; - if (yych <= 0xBF) - goto yy1299; - goto yy1297; - yy1301: - yych = *++p; - if (yych <= 0x7F) - goto yy1297; - if (yych <= 0xBF) - goto yy1299; - goto yy1297; - yy1302: - yych = *++p; - if (yych <= 0x7F) - goto yy1297; - if (yych <= 0x8F) - goto yy1299; - goto yy1297; - yy1303: - yych = *++p; - if (yych <= 0x7F) - goto yy1297; - if (yych <= 0x9F) - goto yy1296; - goto yy1297; - yy1304: + if (yych != '~') + goto yy1080; yych = *++p; if (yybm[0 + yych] & 32) { - goto yy1305; + goto yy1085; } - goto yy1297; - yy1305: + yy1084: + p = marker; + goto yy1080; + yy1085: ++p; yych = *p; marker = p; if (yybm[0 + yych] & 64) { - goto yy1307; + goto yy1087; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1297; + goto yy1084; if (yych <= '\n') - goto yy1309; - goto yy1297; + goto yy1089; + goto yy1084; } else { if (yych <= '\r') - goto yy1309; + goto yy1089; if (yych == '~') - goto yy1305; - goto yy1297; + goto yy1085; + goto yy1084; } - yy1307: + yy1087: ++p; yych = *p; if (yybm[0 + yych] & 64) { - goto yy1307; + goto yy1087; } if (yych <= 0x08) - goto yy1297; + goto yy1084; if (yych <= '\n') - goto yy1309; + goto yy1089; if (yych != '\r') - goto yy1297; - yy1309: + goto yy1084; + yy1089: ++p; p = marker; { return (bufsize_t)(p - start); } - yy1311: + yy1091: yych = *++p; if (yybm[0 + yych] & 128) { - goto yy1312; + goto yy1092; } - goto yy1297; - yy1312: + goto yy1084; + yy1092: ++p; yych = *p; marker = p; if (yybm[0 + yych] & 128) { - goto yy1312; + goto yy1092; } if (yych <= '\f') { if (yych <= 0x08) - goto yy1297; + goto yy1084; if (yych <= '\t') - goto yy1314; + goto yy1094; if (yych <= '\n') - goto yy1316; - goto yy1297; + goto yy1096; + goto yy1084; } else { if (yych <= '\r') - goto yy1316; + goto yy1096; if (yych != ' ') - goto yy1297; + goto yy1084; } - yy1314: + yy1094: ++p; yych = *p; if (yych <= '\f') { if (yych <= 0x08) - goto yy1297; + goto yy1084; if (yych <= '\t') - goto yy1314; + goto yy1094; if (yych >= '\v') - goto yy1297; + goto yy1084; } else { if (yych <= '\r') - goto yy1316; + goto yy1096; if (yych == ' ') - goto yy1314; - goto yy1297; + goto yy1094; + goto yy1084; } - yy1316: + yy1096: ++p; p = marker; { return (bufsize_t)(p - start); } @@ -19651,1001 +16526,921 @@ bufsize_t _scan_entity(const unsigned char *p) { { unsigned char yych; - yych = *(marker = p); - if (yych <= 0xDF) { - if (yych <= '%') { - if (yych != '\n') - goto yy1322; - } else { - if (yych <= '&') - goto yy1321; - if (yych <= 0x7F) - goto yy1322; - if (yych >= 0xC2) - goto yy1323; - } - } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy1325; - if (yych == 0xED) - goto yy1330; - goto yy1326; - } else { - if (yych <= 0xF0) - goto yy1327; - if (yych <= 0xF3) - goto yy1328; - if (yych <= 0xF4) - goto yy1329; - } - } - yy1320 : { return 0; } - yy1321: + yych = *p; + if (yych == '&') + goto yy1102; + ++p; + yy1101 : { return 0; } + yy1102: yych = *(marker = ++p); if (yych <= '@') { - if (yych == '#') - goto yy1331; - goto yy1320; + if (yych != '#') + goto yy1101; } else { if (yych <= 'Z') - goto yy1332; + goto yy1105; if (yych <= '`') - goto yy1320; + goto yy1101; if (yych <= 'z') - goto yy1332; - goto yy1320; + goto yy1105; + goto yy1101; } - yy1322: - yych = *++p; - goto yy1320; - yy1323: - yych = *++p; - if (yych <= 0x7F) - goto yy1324; - if (yych <= 0xBF) - goto yy1322; - yy1324: - p = marker; - goto yy1320; - yy1325: - yych = *++p; - if (yych <= 0x9F) - goto yy1324; - if (yych <= 0xBF) - goto yy1323; - goto yy1324; - yy1326: - yych = *++p; - if (yych <= 0x7F) - goto yy1324; - if (yych <= 0xBF) - goto yy1323; - goto yy1324; - yy1327: - yych = *++p; - if (yych <= 0x8F) - goto yy1324; - if (yych <= 0xBF) - goto yy1326; - goto yy1324; - yy1328: - yych = *++p; - if (yych <= 0x7F) - goto yy1324; - if (yych <= 0xBF) - goto yy1326; - goto yy1324; - yy1329: - yych = *++p; - if (yych <= 0x7F) - goto yy1324; - if (yych <= 0x8F) - goto yy1326; - goto yy1324; - yy1330: - yych = *++p; - if (yych <= 0x7F) - goto yy1324; - if (yych <= 0x9F) - goto yy1323; - goto yy1324; - yy1331: yych = *++p; if (yych <= 'W') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1367; - goto yy1324; + goto yy1140; } else { if (yych <= 'X') - goto yy1366; + goto yy1139; if (yych == 'x') - goto yy1366; - goto yy1324; + goto yy1139; } - yy1332: + yy1104: + p = marker; + goto yy1101; + yy1105: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych >= ':') - goto yy1324; + goto yy1104; } else { if (yych <= 'Z') - goto yy1333; + goto yy1106; if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } - yy1333: + yy1106: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1336; + goto yy1109; if (yych <= ':') - goto yy1324; + goto yy1104; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; - goto yy1336; + goto yy1104; + goto yy1109; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych <= 'z') - goto yy1336; - goto yy1324; + goto yy1109; + goto yy1104; } } - yy1334: + yy1107: ++p; { return (bufsize_t)(p - start); } - yy1336: + yy1109: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1337; + goto yy1110; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1337: + yy1110: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1338; + goto yy1111; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1338: + yy1111: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1339; + goto yy1112; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1339: + yy1112: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1340; + goto yy1113; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1340: + yy1113: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1341; + goto yy1114; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1341: + yy1114: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1342; + goto yy1115; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1342: + yy1115: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1343; + goto yy1116; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1343: + yy1116: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1344; + goto yy1117; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1344: + yy1117: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1345; + goto yy1118; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1345: + yy1118: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1346; + goto yy1119; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1346: + yy1119: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1347; + goto yy1120; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1347: + yy1120: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1348; + goto yy1121; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1348: + yy1121: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1349; + goto yy1122; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1349: + yy1122: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1350; + goto yy1123; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1350: + yy1123: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1351; + goto yy1124; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1351: + yy1124: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1352; + goto yy1125; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1352: + yy1125: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1353; + goto yy1126; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1353: + yy1126: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1354; + goto yy1127; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1354: + yy1127: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1355; + goto yy1128; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1355: + yy1128: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1356; + goto yy1129; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1356: + yy1129: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1357; + goto yy1130; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1357: + yy1130: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1358; + goto yy1131; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1358: + yy1131: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1359; + goto yy1132; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1359: + yy1132: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1360; + goto yy1133; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1360: + yy1133: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1361; + goto yy1134; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1361: + yy1134: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1362; + goto yy1135; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1362: + yy1135: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1363; + goto yy1136; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1363: + yy1136: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1364; + goto yy1137; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1364: + yy1137: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1365; + goto yy1138; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'Z') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= '{') - goto yy1324; + goto yy1104; } } - yy1365: + yy1138: yych = *++p; if (yych == ';') - goto yy1334; - goto yy1324; - yy1366: + goto yy1107; + goto yy1104; + yy1139: yych = *++p; if (yych <= '@') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1374; - goto yy1324; + goto yy1147; + goto yy1104; } else { if (yych <= 'F') - goto yy1374; + goto yy1147; if (yych <= '`') - goto yy1324; + goto yy1104; if (yych <= 'f') - goto yy1374; - goto yy1324; + goto yy1147; + goto yy1104; } - yy1367: + yy1140: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1368; + goto yy1141; if (yych == ';') - goto yy1334; - goto yy1324; - yy1368: + goto yy1107; + goto yy1104; + yy1141: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1369; + goto yy1142; if (yych == ';') - goto yy1334; - goto yy1324; - yy1369: + goto yy1107; + goto yy1104; + yy1142: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1370; + goto yy1143; if (yych == ';') - goto yy1334; - goto yy1324; - yy1370: + goto yy1107; + goto yy1104; + yy1143: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1371; + goto yy1144; if (yych == ';') - goto yy1334; - goto yy1324; - yy1371: + goto yy1107; + goto yy1104; + yy1144: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1372; + goto yy1145; if (yych == ';') - goto yy1334; - goto yy1324; - yy1372: + goto yy1107; + goto yy1104; + yy1145: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1373; + goto yy1146; if (yych == ';') - goto yy1334; - goto yy1324; - yy1373: + goto yy1107; + goto yy1104; + yy1146: yych = *++p; if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1365; + goto yy1138; if (yych == ';') - goto yy1334; - goto yy1324; - yy1374: + goto yy1107; + goto yy1104; + yy1147: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1375; + goto yy1148; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= 'g') - goto yy1324; + goto yy1104; } } - yy1375: + yy1148: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1376; + goto yy1149; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= 'g') - goto yy1324; + goto yy1104; } } - yy1376: + yy1149: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1377; + goto yy1150; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= 'g') - goto yy1324; + goto yy1104; } } - yy1377: + yy1150: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1378; + goto yy1151; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= 'g') - goto yy1324; + goto yy1104; } } - yy1378: + yy1151: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1379; + goto yy1152; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= 'g') - goto yy1324; + goto yy1104; } } - yy1379: + yy1152: yych = *++p; if (yych <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1380; + goto yy1153; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; + goto yy1104; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych >= 'g') - goto yy1324; + goto yy1104; } } - yy1380: + yy1153: ++p; if ((yych = *p) <= ';') { if (yych <= '/') - goto yy1324; + goto yy1104; if (yych <= '9') - goto yy1365; + goto yy1138; if (yych <= ':') - goto yy1324; - goto yy1334; + goto yy1104; + goto yy1107; } else { if (yych <= 'F') { if (yych <= '@') - goto yy1324; - goto yy1365; + goto yy1104; + goto yy1138; } else { if (yych <= '`') - goto yy1324; + goto yy1104; if (yych <= 'f') - goto yy1365; - goto yy1324; + goto yy1138; + goto yy1104; } } } @@ -20660,420 +17455,339 @@ bufsize_t _scan_dangerous_url(const unsigned char *p) { { unsigned char yych; unsigned int yyaccept = 0; - yych = *(marker = p); - if (yych <= 'f') { - if (yych <= 'I') { - if (yych <= 'C') { - if (yych != '\n') - goto yy1388; - } else { - if (yych <= 'D') - goto yy1384; - if (yych == 'F') - goto yy1387; - goto yy1388; - } + yych = *p; + if (yych <= 'V') { + if (yych <= 'F') { + if (yych == 'D') + goto yy1158; + if (yych >= 'F') + goto yy1159; } else { - if (yych <= 'V') { - if (yych <= 'J') - goto yy1385; - if (yych <= 'U') - goto yy1388; - goto yy1386; - } else { - if (yych == 'd') - goto yy1384; - if (yych <= 'e') - goto yy1388; - goto yy1387; - } + if (yych == 'J') + goto yy1160; + if (yych >= 'V') + goto yy1161; } } else { - if (yych <= 0xDF) { - if (yych <= 'u') { - if (yych == 'j') - goto yy1385; - goto yy1388; - } else { - if (yych <= 'v') - goto yy1386; - if (yych <= 0x7F) - goto yy1388; - if (yych >= 0xC2) - goto yy1389; - } + if (yych <= 'f') { + if (yych == 'd') + goto yy1158; + if (yych >= 'f') + goto yy1159; } else { - if (yych <= 0xEF) { - if (yych <= 0xE0) - goto yy1391; - if (yych == 0xED) - goto yy1396; - goto yy1392; + if (yych <= 'j') { + if (yych >= 'j') + goto yy1160; } else { - if (yych <= 0xF0) - goto yy1393; - if (yych <= 0xF3) - goto yy1394; - if (yych <= 0xF4) - goto yy1395; + if (yych == 'v') + goto yy1161; } } } - yy1383 : { return 0; } - yy1384: + ++p; + yy1157 : { return 0; } + yy1158: yyaccept = 0; yych = *(marker = ++p); if (yych == 'A') - goto yy1418; + goto yy1184; if (yych == 'a') - goto yy1418; - goto yy1383; - yy1385: + goto yy1184; + goto yy1157; + yy1159: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'I') + goto yy1181; + if (yych == 'i') + goto yy1181; + goto yy1157; + yy1160: yyaccept = 0; yych = *(marker = ++p); if (yych == 'A') - goto yy1409; + goto yy1172; if (yych == 'a') - goto yy1409; - goto yy1383; - yy1386: + goto yy1172; + goto yy1157; + yy1161: yyaccept = 0; yych = *(marker = ++p); if (yych == 'B') - goto yy1402; - if (yych == 'b') - goto yy1402; - goto yy1383; - yy1387: - yyaccept = 0; - yych = *(marker = ++p); - if (yych == 'I') - goto yy1397; - if (yych == 'i') - goto yy1397; - goto yy1383; - yy1388: - yych = *++p; - goto yy1383; - yy1389: + goto yy1162; + if (yych != 'b') + goto yy1157; + yy1162: yych = *++p; - if (yych <= 0x7F) - goto yy1390; - if (yych <= 0xBF) - goto yy1388; - yy1390: + if (yych == 'S') + goto yy1164; + if (yych == 's') + goto yy1164; + yy1163: p = marker; if (yyaccept == 0) { - goto yy1383; + goto yy1157; } else { - goto yy1401; + goto yy1171; } - yy1391: - yych = *++p; - if (yych <= 0x9F) - goto yy1390; - if (yych <= 0xBF) - goto yy1389; - goto yy1390; - yy1392: - yych = *++p; - if (yych <= 0x7F) - goto yy1390; - if (yych <= 0xBF) - goto yy1389; - goto yy1390; - yy1393: - yych = *++p; - if (yych <= 0x8F) - goto yy1390; - if (yych <= 0xBF) - goto yy1392; - goto yy1390; - yy1394: - yych = *++p; - if (yych <= 0x7F) - goto yy1390; - if (yych <= 0xBF) - goto yy1392; - goto yy1390; - yy1395: - yych = *++p; - if (yych <= 0x7F) - goto yy1390; - if (yych <= 0x8F) - goto yy1392; - goto yy1390; - yy1396: - yych = *++p; - if (yych <= 0x7F) - goto yy1390; - if (yych <= 0x9F) - goto yy1389; - goto yy1390; - yy1397: - yych = *++p; - if (yych == 'L') - goto yy1398; - if (yych != 'l') - goto yy1390; - yy1398: - yych = *++p; - if (yych == 'E') - goto yy1399; - if (yych != 'e') - goto yy1390; - yy1399: - yych = *++p; - if (yych != ':') - goto yy1390; - yy1400: - ++p; - yy1401 : { return (bufsize_t)(p - start); } - yy1402: - yych = *++p; - if (yych == 'S') - goto yy1403; - if (yych != 's') - goto yy1390; - yy1403: + yy1164: yych = *++p; if (yych == 'C') - goto yy1404; + goto yy1165; if (yych != 'c') - goto yy1390; - yy1404: + goto yy1163; + yy1165: yych = *++p; if (yych == 'R') - goto yy1405; + goto yy1166; if (yych != 'r') - goto yy1390; - yy1405: + goto yy1163; + yy1166: yych = *++p; if (yych == 'I') - goto yy1406; + goto yy1167; if (yych != 'i') - goto yy1390; - yy1406: + goto yy1163; + yy1167: yych = *++p; if (yych == 'P') - goto yy1407; + goto yy1168; if (yych != 'p') - goto yy1390; - yy1407: + goto yy1163; + yy1168: yych = *++p; if (yych == 'T') - goto yy1408; + goto yy1169; if (yych != 't') - goto yy1390; - yy1408: + goto yy1163; + yy1169: yych = *++p; - if (yych == ':') - goto yy1400; - goto yy1390; - yy1409: + if (yych != ':') + goto yy1163; + yy1170: + ++p; + yy1171 : { return (bufsize_t)(p - start); } + yy1172: yych = *++p; if (yych == 'V') - goto yy1410; + goto yy1173; if (yych != 'v') - goto yy1390; - yy1410: + goto yy1163; + yy1173: yych = *++p; if (yych == 'A') - goto yy1411; + goto yy1174; if (yych != 'a') - goto yy1390; - yy1411: + goto yy1163; + yy1174: yych = *++p; if (yych == 'S') - goto yy1412; + goto yy1175; if (yych != 's') - goto yy1390; - yy1412: + goto yy1163; + yy1175: yych = *++p; if (yych == 'C') - goto yy1413; + goto yy1176; if (yych != 'c') - goto yy1390; - yy1413: + goto yy1163; + yy1176: yych = *++p; if (yych == 'R') - goto yy1414; + goto yy1177; if (yych != 'r') - goto yy1390; - yy1414: + goto yy1163; + yy1177: yych = *++p; if (yych == 'I') - goto yy1415; + goto yy1178; if (yych != 'i') - goto yy1390; - yy1415: + goto yy1163; + yy1178: yych = *++p; if (yych == 'P') - goto yy1416; + goto yy1179; if (yych != 'p') - goto yy1390; - yy1416: + goto yy1163; + yy1179: yych = *++p; if (yych == 'T') - goto yy1417; + goto yy1180; if (yych != 't') - goto yy1390; - yy1417: + goto yy1163; + yy1180: + yych = *++p; + if (yych == ':') + goto yy1170; + goto yy1163; + yy1181: + yych = *++p; + if (yych == 'L') + goto yy1182; + if (yych != 'l') + goto yy1163; + yy1182: + yych = *++p; + if (yych == 'E') + goto yy1183; + if (yych != 'e') + goto yy1163; + yy1183: yych = *++p; if (yych == ':') - goto yy1400; - goto yy1390; - yy1418: + goto yy1170; + goto yy1163; + yy1184: yych = *++p; if (yych == 'T') - goto yy1419; + goto yy1185; if (yych != 't') - goto yy1390; - yy1419: + goto yy1163; + yy1185: yych = *++p; if (yych == 'A') - goto yy1420; + goto yy1186; if (yych != 'a') - goto yy1390; - yy1420: + goto yy1163; + yy1186: yych = *++p; if (yych != ':') - goto yy1390; + goto yy1163; yyaccept = 1; yych = *(marker = ++p); if (yych == 'I') - goto yy1422; + goto yy1188; if (yych != 'i') - goto yy1401; - yy1422: + goto yy1171; + yy1188: yych = *++p; if (yych == 'M') - goto yy1423; + goto yy1189; if (yych != 'm') - goto yy1390; - yy1423: + goto yy1163; + yy1189: yych = *++p; if (yych == 'A') - goto yy1424; + goto yy1190; if (yych != 'a') - goto yy1390; - yy1424: + goto yy1163; + yy1190: yych = *++p; if (yych == 'G') - goto yy1425; + goto yy1191; if (yych != 'g') - goto yy1390; - yy1425: + goto yy1163; + yy1191: yych = *++p; if (yych == 'E') - goto yy1426; + goto yy1192; if (yych != 'e') - goto yy1390; - yy1426: + goto yy1163; + yy1192: yych = *++p; if (yych != '/') - goto yy1390; + goto yy1163; yych = *++p; if (yych <= 'W') { if (yych <= 'J') { if (yych == 'G') - goto yy1429; + goto yy1195; if (yych <= 'I') - goto yy1390; - goto yy1430; + goto yy1163; + goto yy1196; } else { if (yych == 'P') - goto yy1428; + goto yy1194; if (yych <= 'V') - goto yy1390; - goto yy1431; + goto yy1163; + goto yy1197; } } else { if (yych <= 'j') { if (yych == 'g') - goto yy1429; + goto yy1195; if (yych <= 'i') - goto yy1390; - goto yy1430; + goto yy1163; + goto yy1196; } else { if (yych <= 'p') { if (yych <= 'o') - goto yy1390; + goto yy1163; } else { if (yych == 'w') - goto yy1431; - goto yy1390; + goto yy1197; + goto yy1163; } } } - yy1428: + yy1194: yych = *++p; if (yych == 'N') - goto yy1439; + goto yy1205; if (yych == 'n') - goto yy1439; - goto yy1390; - yy1429: + goto yy1205; + goto yy1163; + yy1195: yych = *++p; if (yych == 'I') - goto yy1438; + goto yy1204; if (yych == 'i') - goto yy1438; - goto yy1390; - yy1430: + goto yy1204; + goto yy1163; + yy1196: yych = *++p; if (yych == 'P') - goto yy1436; + goto yy1202; if (yych == 'p') - goto yy1436; - goto yy1390; - yy1431: + goto yy1202; + goto yy1163; + yy1197: yych = *++p; if (yych == 'E') - goto yy1432; + goto yy1198; if (yych != 'e') - goto yy1390; - yy1432: + goto yy1163; + yy1198: yych = *++p; if (yych == 'B') - goto yy1433; + goto yy1199; if (yych != 'b') - goto yy1390; - yy1433: + goto yy1163; + yy1199: yych = *++p; if (yych == 'P') - goto yy1434; + goto yy1200; if (yych != 'p') - goto yy1390; - yy1434: + goto yy1163; + yy1200: ++p; { return 0; } - yy1436: + yy1202: yych = *++p; if (yych == 'E') - goto yy1437; + goto yy1203; if (yych != 'e') - goto yy1390; - yy1437: + goto yy1163; + yy1203: yych = *++p; if (yych == 'G') - goto yy1434; + goto yy1200; if (yych == 'g') - goto yy1434; - goto yy1390; - yy1438: + goto yy1200; + goto yy1163; + yy1204: yych = *++p; if (yych == 'F') - goto yy1434; + goto yy1200; if (yych == 'f') - goto yy1434; - goto yy1390; - yy1439: + goto yy1200; + goto yy1163; + yy1205: ++p; if ((yych = *p) == 'G') - goto yy1434; + goto yy1200; if (yych == 'g') - goto yy1434; - goto yy1390; + goto yy1200; + goto yy1163; } } diff --git a/scanners.h b/scanners.h index 5e3cbe7..207f91a 100644 --- a/scanners.h +++ b/scanners.h @@ -18,7 +18,6 @@ bufsize_t _scan_html_block_end_2(const unsigned char *p); bufsize_t _scan_html_block_end_3(const unsigned char *p); bufsize_t _scan_html_block_end_4(const unsigned char *p); bufsize_t _scan_html_block_end_5(const unsigned char *p); -bufsize_t _scan_link_url(const unsigned char *p); bufsize_t _scan_link_title(const unsigned char *p); bufsize_t _scan_spacechars(const unsigned char *p); bufsize_t _scan_atx_heading_start(const unsigned char *p); @@ -40,7 +39,6 @@ bufsize_t _scan_dangerous_url(const unsigned char *p); #define scan_html_block_end_3(c, n) _scan_at(&_scan_html_block_end_3, c, n) #define scan_html_block_end_4(c, n) _scan_at(&_scan_html_block_end_4, c, n) #define scan_html_block_end_5(c, n) _scan_at(&_scan_html_block_end_5, 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_heading_start(c, n) _scan_at(&_scan_atx_heading_start, c, n) diff --git a/scanners.re b/scanners.re index 52bf5aa..b20a954 100644 --- a/scanners.re +++ b/scanners.re @@ -37,13 +37,13 @@ bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, tagname = [A-Za-z][A-Za-z0-9-]*; - blocktagname = 'address'|'article'|'aside'|'base'|'basefont'|'blockquote'|'body'|'caption'|'center'|'col'|'colgroup'|'dd'|'details'|'dialog'|'dir'|'div'|'dl'|'dt'|'fieldset'|'figcaption'|'figure'|'footer'|'form'|'frame'|'frameset'|'h1'|'head'|'header'|'hr'|'html'|'iframe'|'legend'|'li'|'link'|'main'|'menu'|'menuitem'|'meta'|'nav'|'noframes'|'ol'|'optgroup'|'option'|'p'|'param'|'section'|'source'|'title'|'summary'|'table'|'tbody'|'td'|'tfoot'|'th'|'thead'|'title'|'tr'|'track'|'ul'; + blocktagname = 'address'|'article'|'aside'|'base'|'basefont'|'blockquote'|'body'|'caption'|'center'|'col'|'colgroup'|'dd'|'details'|'dialog'|'dir'|'div'|'dl'|'dt'|'fieldset'|'figcaption'|'figure'|'footer'|'form'|'frame'|'frameset'|'h1'|'h2'|'h3'|'h4'|'h5'|'h6'|'head'|'header'|'hr'|'html'|'iframe'|'legend'|'li'|'link'|'main'|'menu'|'menuitem'|'meta'|'nav'|'noframes'|'ol'|'optgroup'|'option'|'p'|'param'|'section'|'source'|'title'|'summary'|'table'|'tbody'|'td'|'tfoot'|'th'|'thead'|'title'|'tr'|'track'|'ul'; attributename = [a-zA-Z_:][a-zA-Z0-9:._-]*; - unquotedvalue = [^\"'=<>`\x00]+; + unquotedvalue = [^"'=<>`\x00]+; singlequotedvalue = ['][^'\x00]*[']; - doublequotedvalue = [\"][^\"\x00]*[\"]; + doublequotedvalue = ["][^"\x00]*["]; attributevalue = unquotedvalue | singlequotedvalue | doublequotedvalue; @@ -71,7 +71,7 @@ bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, in_single_quotes = ['] (escaped_char|[^'\x00])* [']; in_parens = [(] (escaped_char|[^)\x00])* [)]; - scheme = [A-Za-z ][A-Za-z.+-]{1,31}; + scheme = [A-Za-z][A-Za-z0-9.+-]{1,31}; */ // Try to match a scheme including colon. @@ -81,7 +81,7 @@ bufsize_t _scan_scheme(const unsigned char *p) const unsigned char *start = p; /*!re2c scheme [:] { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } @@ -92,7 +92,7 @@ bufsize_t _scan_autolink_uri(const unsigned char *p) const unsigned char *start = p; /*!re2c scheme [:][^\x00-\x20<>]*[>] { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } @@ -107,7 +107,7 @@ bufsize_t _scan_autolink_email(const unsigned char *p) [a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])? ([.][a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)* [>] { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } @@ -118,7 +118,7 @@ bufsize_t _scan_html_tag(const unsigned char *p) const unsigned char *start = p; /*!re2c htmltag { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } @@ -135,7 +135,7 @@ bufsize_t _scan_html_block_start(const unsigned char *p) ']) { return 6; } - .? { return 0; } + * { return 0; } */ } @@ -146,7 +146,7 @@ bufsize_t _scan_html_block_start_7(const unsigned char *p) const unsigned char *marker = NULL; /*!re2c [<] (opentag | closetag) [\t\n\f ]* [\r\n] { return 7; } - .? { return 0; } + * { return 0; } */ } @@ -156,8 +156,8 @@ bufsize_t _scan_html_block_end_1(const unsigned char *p) const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - .* [<] [/] ('script'|'pre'|'style') [>] { return (bufsize_t)(p - start); } - .? { return 0; } + [^\n\x00]* [<] [/] ('script'|'pre'|'style') [>] { return (bufsize_t)(p - start); } + * { return 0; } */ } @@ -167,8 +167,8 @@ bufsize_t _scan_html_block_end_2(const unsigned char *p) const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - .* '-->' { return (bufsize_t)(p - start); } - .? { return 0; } + [^\n\x00]* '-->' { return (bufsize_t)(p - start); } + * { return 0; } */ } @@ -178,8 +178,8 @@ bufsize_t _scan_html_block_end_3(const unsigned char *p) const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - .* '?>' { return (bufsize_t)(p - start); } - .? { return 0; } + [^\n\x00]* '?>' { return (bufsize_t)(p - start); } + * { return 0; } */ } @@ -189,8 +189,8 @@ bufsize_t _scan_html_block_end_4(const unsigned char *p) const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - .* '>' { return (bufsize_t)(p - start); } - .? { return 0; } + [^\n\x00]* '>' { return (bufsize_t)(p - start); } + * { return 0; } */ } @@ -200,23 +200,8 @@ bufsize_t _scan_html_block_end_5(const unsigned char *p) const unsigned char *marker = NULL; const unsigned char *start = p; /*!re2c - .* ']]>' { return (bufsize_t)(p - start); } - .? { return 0; } -*/ -} - -// 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. -bufsize_t _scan_link_url(const unsigned char *p) -{ - const unsigned char *marker = NULL; - const unsigned char *start = p; -/*!re2c - [ \r\n]* [<] ([^<> \t\r\n\\\x00] | escaped_char | [\\])* [>] { return (bufsize_t)(p - start); } - [ \r\n]* (reg_char+ | escaped_char | [\\] [^() \t\v\f\r\n] | in_parens_nosp)* [\\]? { return (bufsize_t)(p - start); } - .? { return 0; } + [^\n\x00]* ']]>' { return (bufsize_t)(p - start); } + * { return 0; } */ } @@ -231,18 +216,17 @@ bufsize_t _scan_link_title(const unsigned char *p) ["] (escaped_char|[^"\x00])* ["] { return (bufsize_t)(p - start); } ['] (escaped_char|[^'\x00])* ['] { return (bufsize_t)(p - start); } [(] (escaped_char|[^)\x00])* [)] { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } // Match space characters, including newlines. bufsize_t _scan_spacechars(const unsigned char *p) { - const unsigned char *marker = NULL; const unsigned char *start = p; \ /*!re2c - [ \t\v\f\r\n]* { return (bufsize_t)(p - start); } - . { return 0; } + [ \t\v\f\r\n]+ { return (bufsize_t)(p - start); } + * { return 0; } */ } @@ -253,7 +237,7 @@ bufsize_t _scan_atx_heading_start(const unsigned char *p) const unsigned char *start = p; /*!re2c [#]{1,6} ([ \t]+|[\r\n]) { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } @@ -263,9 +247,9 @@ bufsize_t _scan_setext_heading_line(const unsigned char *p) { const unsigned char *marker = NULL; /*!re2c - [=]+ [ ]* [\r\n] { return 1; } - [-]+ [ ]* [\r\n] { return 2; } - .? { return 0; } + [=]+ [ \t]* [\r\n] { return 1; } + [-]+ [ \t]* [\r\n] { return 2; } + * { return 0; } */ } @@ -280,7 +264,7 @@ bufsize_t _scan_thematic_break(const unsigned char *p) ([*][ \t]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } ([_][ \t]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } ([-][ \t]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } @@ -292,7 +276,7 @@ bufsize_t _scan_open_code_fence(const unsigned char *p) /*!re2c [`]{3,} / [^`\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); } [~]{3,} / [^~\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } @@ -304,7 +288,7 @@ bufsize_t _scan_close_code_fence(const unsigned char *p) /*!re2c [`]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); } [~]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } @@ -317,7 +301,7 @@ bufsize_t _scan_entity(const unsigned char *p) /*!re2c [&] ([#] ([Xx][A-Fa-f0-9]{1,8}|[0-9]{1,8}) |[A-Za-z][A-Za-z0-9]{1,31} ) [;] { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } @@ -330,7 +314,7 @@ bufsize_t _scan_dangerous_url(const unsigned char *p) /*!re2c 'data:image/' ('png'|'gif'|'jpeg'|'webp') { return 0; } 'javascript:' | 'vbscript:' | 'file:' | 'data:' { return (bufsize_t)(p - start); } - .? { return 0; } + * { return 0; } */ } From 61d9fae6231667bba618f71af09f87205a146945 Mon Sep 17 00:00:00 2001 From: Adrian Nowicki Date: Sun, 20 Aug 2017 22:39:30 +0200 Subject: [PATCH 25/26] fix build Signed-off-by: Adrian Nowicki --- cmark.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cmark.h b/cmark.h index d1a65aa..5b88f31 100644 --- a/cmark.h +++ b/cmark.h @@ -2,8 +2,8 @@ #define CMARK_H #include -#include -#include +#include "cmark_export.h" +#include "cmark_version.h" #ifdef __cplusplus extern "C" { From 02f705bb035c7d4908e51d5e4ea8a0160b4cf2ce Mon Sep 17 00:00:00 2001 From: Adrian Nowicki Date: Mon, 21 Aug 2017 13:41:31 +0200 Subject: [PATCH 26/26] fix update to 0.28.0 Signed-off-by: Adrian Nowicki --- inlines.c | 14 +++++--------- latex.c | 22 +++++++++++----------- 2 files changed, 16 insertions(+), 20 deletions(-) diff --git a/inlines.c b/inlines.c index 2d7f385..f223baf 100644 --- a/inlines.c +++ b/inlines.c @@ -345,8 +345,7 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open, *can_close = right_flanking && (!left_flanking || cmark_utf8proc_is_punctuation(after_char)); } else if (c == '\'' || c == '"') { - *can_open = left_flanking && !right_flanking && - before_char != ']' && before_char != ')'; + *can_open = left_flanking && !right_flanking; *can_close = right_flanking; } else { *can_open = left_flanking; @@ -616,7 +615,7 @@ static delimiter *S_insert_emph(subject *subj, delimiter *opener, cmark_node *tmp, *tmpnext, *emph; // calculate the actual number of characters used from this closer - use_delims = (closer_num_chars >= 2 && opener_num_chars >= 2) ? 2 : 1; + use_delims = (closer_num_chars >= 2 && opener_num_chars >=2) ? 2 : 1; // remove used characters from associated inlines. opener_num_chars -= use_delims; @@ -822,8 +821,7 @@ static int link_label(subject *subj, cmark_chunk *raw_label) { return 0; } -static bufsize_t manual_scan_link_url_2(cmark_chunk *input, bufsize_t offset, - cmark_chunk *output) { +static bufsize_t manual_scan_link_url_2(cmark_chunk *input, bufsize_t offset, cmark_chunk *output) { bufsize_t i = offset; size_t nb_p = 0; @@ -856,8 +854,7 @@ static bufsize_t manual_scan_link_url_2(cmark_chunk *input, bufsize_t offset, return i - offset; } -static bufsize_t manual_scan_link_url(cmark_chunk *input, bufsize_t offset, - cmark_chunk *output) { +static bufsize_t manual_scan_link_url(cmark_chunk *input, bufsize_t offset, cmark_chunk *output) { bufsize_t i = offset; if (i < input->len && input->data[i] == '<') { @@ -927,8 +924,7 @@ static cmark_node *handle_close_bracket(subject *subj) { // First, look for an inline link. if (peek_char(subj) == '(' && ((sps = scan_spacechars(&subj->input, subj->pos + 1)) > -1) && - ((n = manual_scan_link_url(&subj->input, subj->pos + 1 + sps, - &url_chunk)) > -1)) { + ((n = manual_scan_link_url(&subj->input, subj->pos + 1 + sps, &url_chunk)) > -1)) { // try to parse an explicit link: endurl = subj->pos + 1 + sps + n; diff --git a/latex.c b/latex.c index 0d9517d..f372a13 100644 --- a/latex.c +++ b/latex.c @@ -252,24 +252,24 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node, CR(); list_number = cmark_node_get_list_start(node); if (list_number > 1) { - enumlevel = S_get_enumlevel(node); - // latex normally supports only five levels - if (enumlevel >= 1 && enumlevel <= 5) { + enumlevel = S_get_enumlevel(node); + // latex normally supports only five levels + if (enumlevel >= 1 && enumlevel <= 5) { snprintf(list_number_string, LIST_NUMBER_STRING_SIZE, "%d", list_number); LIT("\\setcounter{enum"); - switch (enumlevel) { - case 1: LIT("i"); break; - case 2: LIT("ii"); break; - case 3: LIT("iii"); break; - case 4: LIT("iv"); break; - case 5: LIT("v"); break; - default: LIT("i"); break; + switch(enumlevel) { + case 1: LIT("i"); break; + case 2: LIT("ii"); break; + case 3: LIT("iii"); break; + case 4: LIT("iv"); break; + case 5: LIT("v"); break; + default: LIT("i"); break; } LIT("}{"); OUT(list_number_string, false, NORMAL); LIT("}"); - } + } CR(); } } else {