diff options
Diffstat (limited to 'cmark/src')
40 files changed, 21224 insertions, 0 deletions
diff --git a/cmark/src/CMakeLists.txt b/cmark/src/CMakeLists.txt new file mode 100644 index 0000000000..523b2cb82b --- /dev/null +++ b/cmark/src/CMakeLists.txt @@ -0,0 +1,100 @@ + +configure_file(cmark_version.h.in + ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h) +configure_file(libcmark.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc + @ONLY) + +add_library(cmark + blocks.c + buffer.c + cmark.c + cmark_ctype.c + commonmark.c + houdini_href_e.c + houdini_html_e.c + houdini_html_u.c + html.c + inlines.c + iterator.c + latex.c + man.c + node.c + references.c + render.c + scanners.c + scanners.re + utf8.c + xml.c) +cmark_add_compile_options(cmark) +set_target_properties(cmark PROPERTIES + OUTPUT_NAME "cmark" + # Avoid name clash between PROGRAM and LIBRARY pdb files. + PDB_NAME libcmark + POSITION_INDEPENDENT_CODE YES + # Include minor version and patch level in soname for now. + SOVERSION ${PROJECT_VERSION} + VERSION ${PROJECT_VERSION}) +if(NOT BUILD_SHARED_LIBS) + target_compile_definitions(cmark PUBLIC + CMARK_STATIC_DEFINE) +endif() +target_include_directories(cmark INTERFACE + $<INSTALL_INTERFACE:include> + $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> + $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>) + +generate_export_header(cmark + BASE_NAME ${PROJECT_NAME}) + +# FIXME(compnerd) this should be removed, but exists solely to allow a migration +# path for OSS Fuzz. +add_custom_target(cmark_static DEPENDS cmark) + +add_executable(cmark_exe + main.c) +cmark_add_compile_options(cmark_exe) +set_target_properties(cmark_exe PROPERTIES + OUTPUT_NAME "cmark" + INSTALL_RPATH "${Base_rpath}") +target_link_libraries(cmark_exe PRIVATE + cmark) + +install(TARGETS cmark_exe cmark + EXPORT cmark-targets + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + ) + +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc + DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) + +install(FILES + cmark.h + ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h + ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} + ) + +# generate cmark-config.cmake and cmark-config-version.cmake files +configure_package_config_file( + "cmarkConfig.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config.cmake" + INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cmark") +write_basic_package_version_file( + "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config-version.cmake" + VERSION ${PROJECT_VERSION} + COMPATIBILITY SameMajorVersion) +# install config and version file +install( + FILES "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config.cmake" + "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config-version.cmake" + DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cmark" +) +# install targets file +install( + EXPORT "cmark-targets" + NAMESPACE "cmark::" + DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cmark" +) diff --git a/cmark/src/blocks.c b/cmark/src/blocks.c new file mode 100644 index 0000000000..292e563bb6 --- /dev/null +++ b/cmark/src/blocks.c @@ -0,0 +1,1345 @@ +/** + * 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 <assert.h> +#include <limits.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> + +#include "cmark_ctype.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 "chunk.h" + +#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 bool S_last_line_blank(const cmark_node *node) { + return (node->flags & CMARK_NODE__LAST_LINE_BLANK) != 0; +} + +static bool S_last_line_checked(const cmark_node *node) { + return (node->flags & CMARK_NODE__LAST_LINE_CHECKED) != 0; +} + +static 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 void S_set_last_line_checked(cmark_node *node) { + node->flags |= CMARK_NODE__LAST_LINE_CHECKED; +} + +static inline bool S_is_line_end_char(char c) { + return (c == '\n' || c == '\r'); +} + +static 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); + +static void S_process_line(cmark_parser *parser, const unsigned char *buffer, + bufsize_t bytes); + +static cmark_node *make_block(cmark_mem *mem, cmark_node_type tag, + int start_line, int start_column) { + cmark_node *e; + + e = (cmark_node *)mem->calloc(1, sizeof(*e)); + e->mem = mem; + 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_mem *mem) { + cmark_node *e = make_block(mem, CMARK_NODE_DOCUMENT, 1, 1); + return e; +} + +cmark_parser *cmark_parser_new_with_mem_into_root(int options, cmark_mem *mem, cmark_node *root) { + cmark_parser *parser = (cmark_parser *)mem->calloc(1, sizeof(cmark_parser)); + parser->mem = mem; + + cmark_strbuf_init(mem, &parser->curline, 256); + cmark_strbuf_init(mem, &parser->linebuf, 0); + cmark_strbuf_init(mem, &parser->content, 0); + + root->flags = CMARK_NODE__OPEN; + + parser->refmap = cmark_reference_map_new(mem); + parser->root = root; + parser->current = root; + parser->line_number = 0; + parser->offset = 0; + parser->column = 0; + parser->first_nonspace = 0; + parser->first_nonspace_column = 0; + parser->thematic_break_kill_pos = 0; + parser->indent = 0; + parser->blank = false; + parser->partially_consumed_tab = false; + parser->last_line_length = 0; + parser->options = options; + parser->last_buffer_ended_with_cr = false; + + return parser; +} + +cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem) { + cmark_node *document = make_document(mem); + return cmark_parser_new_with_mem_into_root(options, mem, document); +} + +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_mem *mem = parser->mem; + cmark_strbuf_free(&parser->curline); + cmark_strbuf_free(&parser->linebuf); + cmark_reference_map_free(parser->refmap); + mem->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, 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 == 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 == CMARK_NODE_PARAGRAPH || + block_type == CMARK_NODE_HEADING || + block_type == CMARK_NODE_CODE_BLOCK); +} + +static 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_chunk *ch, cmark_parser *parser) { + int chars_to_tab; + int i; + 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(&parser->content, ' '); + } + } + cmark_strbuf_put(&parser->content, ch->data + parser->offset, + ch->len - parser->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]; + + 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]; + + 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 +// if needed into lists and sublists. +static bool S_ends_with_blank_line(cmark_node *node) { + if (S_last_line_checked(node)) { + return(S_last_line_blank(node)); + } else if ((S_type(node) == CMARK_NODE_LIST || + S_type(node) == CMARK_NODE_ITEM) && node->last_child) { + S_set_last_line_checked(node); + return(S_ends_with_blank_line(node->last_child)); + } else { + S_set_last_line_checked(node); + return (S_last_line_blank(node)); + } +} + +// returns true if content remains after link defs are resolved. +static bool resolve_reference_link_definitions(cmark_parser *parser) { + bufsize_t pos; + cmark_strbuf *node_content = &parser->content; + cmark_chunk chunk = {node_content->ptr, node_content->size}; + while (chunk.len && chunk.data[0] == '[' && + (pos = cmark_parse_reference_inline(parser->mem, &chunk, + parser->refmap))) { + + chunk.data += pos; + chunk.len -= pos; + } + cmark_strbuf_drop(node_content, (node_content->size - chunk.len)); + return !is_blank(node_content, 0); +} + +static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { + bufsize_t pos; + cmark_node *item; + cmark_node *subitem; + cmark_node *parent; + bool has_content; + + parent = b->parent; + assert(b->flags & + CMARK_NODE__OPEN); // shouldn't call finalize on closed blocks + b->flags &= ~CMARK_NODE__OPEN; + + 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 (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 -= 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; + } + + cmark_strbuf *node_content = &parser->content; + + switch (S_type(b)) { + case CMARK_NODE_PARAGRAPH: + { + has_content = resolve_reference_link_definitions(parser); + if (!has_content) { + // remove blank node (former reference def) + cmark_node_free(b); + } else { + b->len = node_content->size; + b->data = cmark_strbuf_detach(node_content); + } + break; + } + + case CMARK_NODE_CODE_BLOCK: + if (!b->as.code.fenced) { // indented code + remove_trailing_blank_lines(node_content); + cmark_strbuf_putc(node_content, '\n'); + } else { + // first line of contents becomes info + for (pos = 0; pos < node_content->size; ++pos) { + if (S_is_line_end_char(node_content->ptr[pos])) + break; + } + assert(pos < node_content->size); + + if (pos == 0) { + b->as.code.info = NULL; + } else { + 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_strbuf_detach(&tmp); + } + + if (node_content->ptr[pos] == '\r') + pos += 1; + if (node_content->ptr[pos] == '\n') + pos += 1; + cmark_strbuf_drop(node_content, pos); + } + b->len = node_content->size; + b->data = cmark_strbuf_detach(node_content); + break; + + case CMARK_NODE_HEADING: + case CMARK_NODE_HTML_BLOCK: + b->len = node_content->size; + b->data = cmark_strbuf_detach(node_content); + break; + + case CMARK_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 (S_last_line_blank(item) && 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 ((item->next || subitem->next) && + S_ends_with_blank_line(subitem)) { + 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(S_type(parent), block_type)) { + parent = finalize(parser, parent); + } + + cmark_node *child = + make_block(parser->mem, 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_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; + + 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(S_type(cur))) { + cmark_parse_inlines(mem, cur, refmap, options); + mem->free(cur->data); + cur->data = NULL; + cur->len = 0; + } + } + } + + 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_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); + + if (c == '*' || c == '-' || c == '+') { + pos++; + if (!cmark_isspace(peek_at(input, pos))) { + return 0; + } + + 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 = 0; + data->delimiter = CMARK_NO_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))); + + 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; + } + 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; + } + + *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); + + // Limit total size of extra content created from reference links to + // document size to avoid superlinear growth. Always allow 100KB. + if (parser->total_size > 100000) + parser->refmap->max_ref_size = parser->total_size; + else + parser->refmap->max_ref_size = 100000; + + process_inlines(parser->mem, parser->root, parser->refmap, parser->options); + + cmark_strbuf_free(&parser->content); + + return parser->root; +} + +cmark_node *cmark_parse_file(FILE *f, int options) { + unsigned char buffer[4096]; + cmark_parser *parser = cmark_parser_new(options); + size_t bytes; + cmark_node *document; + + while ((bytes = fread(buffer, 1, sizeof(buffer), f)) > 0) { + bool eof = bytes < sizeof(buffer); + S_parser_feed(parser, buffer, bytes, eof); + if (eof) { + break; + } + } + + document = cmark_parser_finish(parser); + cmark_parser_free(parser); + return document; +} + +cmark_node *cmark_parse_document(const char *buffer, size_t len, int options) { + cmark_parser *parser = cmark_parser_new(options); + cmark_node *document; + + S_parser_feed(parser, (const unsigned char *)buffer, len, true); + + document = cmark_parser_finish(parser); + cmark_parser_free(parser); + return document; +} + +void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len) { + S_parser_feed(parser, (const unsigned char *)buffer, len, false); +} + +static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, + size_t len, bool eof) { + const unsigned char *end = buffer + len; + static const uint8_t repl[] = {239, 191, 189}; + + if (len > UINT_MAX - parser->total_size) + parser->total_size = UINT_MAX; + else + parser->total_size += (int)len; + + // Skip UTF-8 BOM if present; see #334 + if (parser->line_number == 0 && parser->column == 0 && len >= 3 && + *buffer == 0xEF && *(buffer + 1) == 0xBB && + *(buffer + 2) == 0xBF) { + buffer += 3; + } else 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; + 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 = (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); + } else { + cmark_strbuf_put(&parser->linebuf, buffer, chunk_len); + } + } + + buffer += chunk_len; + 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++; + } + } + } +} + +static void chop_trailing_hashtags(cmark_chunk *ch) { + bufsize_t 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 space before the final #s: + if (n != orig_n && n >= 0 && S_is_space_or_tab(peek_at(ch, n))) { + ch->len = n; + cmark_chunk_rtrim(ch); + } +} + +// Check for thematic break. On failure, return 0 and update +// thematic_break_kill_pos with the index at which the +// parse fails. On success, return length of match. +// "...three or more hyphens, asterisks, +// or underscores on a line by themselves. If you wish, you may use +// spaces between the hyphens or asterisks." +static int S_scan_thematic_break(cmark_parser *parser, cmark_chunk *input, + bufsize_t offset) { + bufsize_t i; + char c; + char nextc = '\0'; + int count; + i = offset; + c = peek_at(input, i); + if (!(c == '*' || c == '_' || c == '-')) { + parser->thematic_break_kill_pos = i; + return 0; + } + count = 1; + while ((nextc = peek_at(input, ++i))) { + if (nextc == c) { + count++; + } else if (nextc != ' ' && nextc != '\t') { + break; + } + } + if (count >= 3 && (nextc == '\r' || nextc == '\n')) { + return (i - offset) + 1; + } else { + parser->thematic_break_kill_pos = i; + return 0; + } +} + +// 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); + + if (parser->first_nonspace <= parser->offset) { + 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)); +} + +// 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); + 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; + } + } +} + +static bool S_last_child_is_open(cmark_node *container) { + return container->last_child && + (container->last_child->flags & CMARK_NODE__OPEN); +} + +static bool parse_block_quote_prefix(cmark_parser *parser, cmark_chunk *input) { + bool res = false; + bufsize_t matched = 0; + + matched = + parser->indent <= 3 && peek_at(input, parser->first_nonspace) == '>'; + if (matched) { + + S_advance_offset(parser, input, parser->indent + 1, true); + + if (S_is_space_or_tab(peek_at(input, parser->offset))) { + S_advance_offset(parser, input, 1, true); + } + + res = true; + } + return res; +} + +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; +} + +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; + + 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 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; + + while (i > 0 && S_is_space_or_tab(peek_at(input, parser->offset))) { + S_advance_offset(parser, input, 1, true); + i--; + } + res = true; + } + } + + return res; +} + +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; + } + + return res; +} + +/** + * 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 = 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_LIST: + // Avoid quadratic behavior caused by iterating deeply nested lists + // for each blank line. + if (parser->blank) { + if (container->flags & CMARK_NODE__LIST_LAST_LINE_BLANK && + parser->indent == 0) { + // Abort early if we encounter multiple blank lines. Returning + // NULL will cause S_process_line to skip the calls to + // open_new_blocks and add_text_to_container. open_new_blocks + // is a no-op for blank lines. add_text_to_container closes + // remaining open nodes, but since we have a second blank + // line, all open nodes have already been closed when the + // first blank line was processed. Certain block types accept + // empty lines as content, so add them here. + if (parser->current->type == CMARK_NODE_CODE_BLOCK || + parser->current->type == CMARK_NODE_HTML_BLOCK) { + add_line(input, parser); + } + return NULL; + } + container->flags |= CMARK_NODE__LIST_LAST_LINE_BLANK; + } else { + container->flags &= ~CMARK_NODE__LIST_LAST_LINE_BLANK; + } + 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; + } + } + + *all_matched = true; + +done: + if (!*all_matched) { + container = container->parent; // back up to last matching node + } + + if (!should_continue) { + container = NULL; + } + + return 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 = 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; + bool has_content; + int save_offset; + int save_column; + + while (cont_type != CMARK_NODE_CODE_BLOCK && + cont_type != CMARK_NODE_HTML_BLOCK) { + + S_find_first_nonspace(parser, input); + indented = parser->indent >= CODE_INDENT; + + 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 + 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, + 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, + heading_startpos + 1); + + hashpos = cmark_chunk_strchr(input, '#', parser->first_nonspace); + + while (peek_at(input, hashpos) == '#') { + level++; + hashpos++; + } + + (*container)->as.heading.level = level; + (*container)->as.heading.setext = false; + (*container)->as.heading.internal_offset = matched; + + } 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 > 255) ? 255 : matched; + (*container)->as.code.fence_offset = + (int8_t)(parser->first_nonspace - parser->offset); + (*container)->as.code.info = NULL; + S_advance_offset(parser, input, + parser->first_nonspace + matched - parser->offset, + false); + + } else if (!indented && ((matched = scan_html_block_start( + input, parser->first_nonspace)) || + (cont_type != CMARK_NODE_PARAGRAPH && + !maybe_lazy && + (matched = scan_html_block_start_7( + input, parser->first_nonspace))))) { + *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 && cont_type == CMARK_NODE_PARAGRAPH && + (lev = + scan_setext_heading_line(input, parser->first_nonspace))) { + // finalize paragraph, resolving reference links + has_content = resolve_reference_link_definitions(parser); + + if (has_content) { + + (*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) && + (parser->thematic_break_kill_pos <= parser->first_nonspace) && + S_scan_thematic_break(parser, 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); + S_advance_offset(parser, input, input->len - 1 - parser->offset, false); + } else if ((!indented || cont_type == CMARK_NODE_LIST) && + parser->indent < 4 && + (matched = parse_list_marker( + parser->mem, input, parser->first_nonspace, + (*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. + int i = 0; + + // compute padding: + S_advance_offset(parser, input, + parser->first_nonspace + matched - parser->offset, + false); + + 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 = parser->column - save_column; + 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; + if (i > 0) { + S_advance_offset(parser, input, 1, true); + } + } else { + data->padding = matched + 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 = parser->indent; + + 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)); + } + + // add the list item + *container = add_child(parser, *container, CMARK_NODE_ITEM, + parser->first_nonspace + 1); + /* TODO: static */ + memcpy(&((*container)->as.list), data, sizeof(*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, + 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 = NULL; + + } else { + break; + } + + if (accepts_lines(S_type(*container))) { + // if it's a line container, it can't contain other containers + break; + } + + 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) { + 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); + + if (parser->blank && container->last_child) + 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. + 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) { + S_set_last_line_blank(tmp->parent, 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 && + S_type(parser->current) == CMARK_NODE_PARAGRAPH) { + add_line(input, parser); + } 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 (S_type(container) == CMARK_NODE_CODE_BLOCK) { + add_line(input, parser); + } else if (S_type(container) == CMARK_NODE_HTML_BLOCK) { + add_line(input, parser); + + int matches_end_condition; + switch (container->as.html_block_type) { + case 1: + // </script>, </style>, </textarea>, </pre> + 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(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); + add_line(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); + add_line(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); + + 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'); + + parser->offset = 0; + parser->column = 0; + parser->first_nonspace = 0; + parser->first_nonspace_column = 0; + parser->thematic_break_kill_pos = 0; + parser->indent = 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; + + 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 && + input.data[parser->last_line_length - 1] == '\n') + parser->last_line_length -= 1; + if (parser->last_line_length && + input.data[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); + } + + finalize_document(parser); + + cmark_consolidate_text_nodes(parser->root); + + cmark_strbuf_free(&parser->curline); + +#if CMARK_DEBUG_NODES + if (cmark_node_check(parser->root, stderr)) { + abort(); + } +#endif + return parser->root; +} diff --git a/cmark/src/buffer.c b/cmark/src/buffer.c new file mode 100644 index 0000000000..f3159948ce --- /dev/null +++ b/cmark/src/buffer.c @@ -0,0 +1,209 @@ +#include <assert.h> +#include <limits.h> +#include <stdarg.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.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]; + +#ifndef MIN +#define MIN(x, y) ((x < y) ? x : y) +#endif + +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; + + if (initial_size > 0) + cmark_strbuf_grow(buf, initial_size); +} + +static 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) { + assert(target_size > 0); + + if (target_size < buf->asize) + return; + + 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. */ + bufsize_t new_size = target_size + target_size / 2; + new_size += 1; + new_size = (new_size + 7) & ~7; + + buf->ptr = (unsigned char *)buf->mem->realloc(buf->asize ? buf->ptr : NULL, + new_size); + buf->asize = new_size; +} + +void cmark_strbuf_free(cmark_strbuf *buf) { + if (!buf) + return; + + if (buf->ptr != cmark_strbuf__initbuf) + buf->mem->free(buf->ptr); + + cmark_strbuf_init(buf->mem, buf, 0); +} + +void cmark_strbuf_clear(cmark_strbuf *buf) { + buf->size = 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_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; + + 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, (bufsize_t)strlen(string)); +} + +unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) { + unsigned char *data = buf->ptr; + + if (buf->asize == 0) { + /* return an empty string */ + return (unsigned char *)buf->mem->calloc(1, 1); + } + + cmark_strbuf_init(buf->mem, buf, 0); + return data; +} + +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); + + 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) { + bufsize_t 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; + 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. +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++; + + buf->ptr[w++] = buf->ptr[r]; + } + + cmark_strbuf_truncate(buf, w); +} diff --git a/cmark/src/buffer.h b/cmark/src/buffer.h new file mode 100644 index 0000000000..e6a085724c --- /dev/null +++ b/cmark/src/buffer.h @@ -0,0 +1,74 @@ +#ifndef CMARK_BUFFER_H +#define CMARK_BUFFER_H + +#include <limits.h> +#include <stdarg.h> +#include <stddef.h> +#include <stdint.h> +#include <string.h> + +#include "cmark.h" + +#ifdef __cplusplus +extern "C" { +#endif + +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 CMARK_BUF_INIT(mem) \ + { mem, cmark_strbuf__initbuf, 0, 0 } + +/** + * Initialize a cmark_strbuf structure. + * + * For the cases where CMARK_BUF_INIT cannot be used to do static + * initialization. + */ +void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf, + bufsize_t initial_size); + +/** + * Grow the buffer to hold at least `target_size` bytes. + */ +void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size); + +void cmark_strbuf_free(cmark_strbuf *buf); + +unsigned char *cmark_strbuf_detach(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]) + +void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, + bufsize_t len); +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_clear(cmark_strbuf *buf); + +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); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/src/case_fold.inc b/cmark/src/case_fold.inc new file mode 100644 index 0000000000..b309d3e24f --- /dev/null +++ b/cmark/src/case_fold.inc @@ -0,0 +1,722 @@ +// Generated by tools/make_case_fold_inc.py + +#define CF_MAX (1 << 17) +#define CF_TABLE_SIZE 1559 +#define CF_CODE_POINT(x) ((x) & 0x1FFFF) +#define CF_REPL_IDX(x) ((((x) >> 17) & 0xFFF) * 2) +#define CF_REPL_SIZE(x) ((x) >> 29) + +static const uint32_t cf_table[1559] = { + 0x400000B5, 0x400200C0, 0x400400C1, 0x400600C2, 0x400800C3, 0x400A00C4, + 0x400C00C5, 0x400E00C6, 0x401000C7, 0x401200C8, 0x401400C9, 0x401600CA, + 0x401800CB, 0x401A00CC, 0x401C00CD, 0x401E00CE, 0x402000CF, 0x402200D0, + 0x402400D1, 0x402600D2, 0x402800D3, 0x402A00D4, 0x402C00D5, 0x402E00D6, + 0x403000D8, 0x403200D9, 0x403400DA, 0x403600DB, 0x403800DC, 0x403A00DD, + 0x403C00DE, 0x403E00DF, 0x40400100, 0x40420102, 0x40440104, 0x40460106, + 0x40480108, 0x404A010A, 0x404C010C, 0x404E010E, 0x40500110, 0x40520112, + 0x40540114, 0x40560116, 0x40580118, 0x405A011A, 0x405C011C, 0x405E011E, + 0x40600120, 0x40620122, 0x40640124, 0x40660126, 0x40680128, 0x406A012A, + 0x406C012C, 0x406E012E, 0x60700130, 0x40740132, 0x40760134, 0x40780136, + 0x407A0139, 0x407C013B, 0x407E013D, 0x4080013F, 0x40820141, 0x40840143, + 0x40860145, 0x40880147, 0x608A0149, 0x408E014A, 0x4090014C, 0x4092014E, + 0x40940150, 0x40960152, 0x40980154, 0x409A0156, 0x409C0158, 0x409E015A, + 0x40A0015C, 0x40A2015E, 0x40A40160, 0x40A60162, 0x40A80164, 0x40AA0166, + 0x40AC0168, 0x40AE016A, 0x40B0016C, 0x40B2016E, 0x40B40170, 0x40B60172, + 0x40B80174, 0x40BA0176, 0x40BC0178, 0x40BE0179, 0x40C0017B, 0x40C2017D, + 0x20C4017F, 0x40C60181, 0x40C80182, 0x40CA0184, 0x40CC0186, 0x40CE0187, + 0x40D00189, 0x40D2018A, 0x40D4018B, 0x40D6018E, 0x40D8018F, 0x40DA0190, + 0x40DC0191, 0x40DE0193, 0x40E00194, 0x40E20196, 0x40E40197, 0x40E60198, + 0x40E8019C, 0x40EA019D, 0x40EC019F, 0x40EE01A0, 0x40F001A2, 0x40F201A4, + 0x40F401A6, 0x40F601A7, 0x40F801A9, 0x40FA01AC, 0x40FC01AE, 0x40FE01AF, + 0x410001B1, 0x410201B2, 0x410401B3, 0x410601B5, 0x410801B7, 0x410A01B8, + 0x410C01BC, 0x410E01C4, 0x411001C5, 0x411201C7, 0x411401C8, 0x411601CA, + 0x411801CB, 0x411A01CD, 0x411C01CF, 0x411E01D1, 0x412001D3, 0x412201D5, + 0x412401D7, 0x412601D9, 0x412801DB, 0x412A01DE, 0x412C01E0, 0x412E01E2, + 0x413001E4, 0x413201E6, 0x413401E8, 0x413601EA, 0x413801EC, 0x413A01EE, + 0x613C01F0, 0x414001F1, 0x414201F2, 0x414401F4, 0x414601F6, 0x414801F7, + 0x414A01F8, 0x414C01FA, 0x414E01FC, 0x415001FE, 0x41520200, 0x41540202, + 0x41560204, 0x41580206, 0x415A0208, 0x415C020A, 0x415E020C, 0x4160020E, + 0x41620210, 0x41640212, 0x41660214, 0x41680216, 0x416A0218, 0x416C021A, + 0x416E021C, 0x4170021E, 0x41720220, 0x41740222, 0x41760224, 0x41780226, + 0x417A0228, 0x417C022A, 0x417E022C, 0x4180022E, 0x41820230, 0x41840232, + 0x6186023A, 0x418A023B, 0x418C023D, 0x618E023E, 0x41920241, 0x41940243, + 0x41960244, 0x41980245, 0x419A0246, 0x419C0248, 0x419E024A, 0x41A0024C, + 0x41A2024E, 0x41A40345, 0x41A60370, 0x41A80372, 0x41AA0376, 0x41AC037F, + 0x41AE0386, 0x41B00388, 0x41B20389, 0x41B4038A, 0x41B6038C, 0x41B8038E, + 0x41BA038F, 0xC1BC0390, 0x41C20391, 0x41C40392, 0x41C60393, 0x41C80394, + 0x41CA0395, 0x41CC0396, 0x41CE0397, 0x41D00398, 0x41D20399, 0x41D4039A, + 0x41D6039B, 0x41D8039C, 0x41DA039D, 0x41DC039E, 0x41DE039F, 0x41E003A0, + 0x41E203A1, 0x41E403A3, 0x41E603A4, 0x41E803A5, 0x41EA03A6, 0x41EC03A7, + 0x41EE03A8, 0x41F003A9, 0x41F203AA, 0x41F403AB, 0xC1F603B0, 0x41FC03C2, + 0x41FE03CF, 0x420003D0, 0x420203D1, 0x420403D5, 0x420603D6, 0x420803D8, + 0x420A03DA, 0x420C03DC, 0x420E03DE, 0x421003E0, 0x421203E2, 0x421403E4, + 0x421603E6, 0x421803E8, 0x421A03EA, 0x421C03EC, 0x421E03EE, 0x422003F0, + 0x422203F1, 0x422403F4, 0x422603F5, 0x422803F7, 0x422A03F9, 0x422C03FA, + 0x422E03FD, 0x423003FE, 0x423203FF, 0x42340400, 0x42360401, 0x42380402, + 0x423A0403, 0x423C0404, 0x423E0405, 0x42400406, 0x42420407, 0x42440408, + 0x42460409, 0x4248040A, 0x424A040B, 0x424C040C, 0x424E040D, 0x4250040E, + 0x4252040F, 0x42540410, 0x42560411, 0x42580412, 0x425A0413, 0x425C0414, + 0x425E0415, 0x42600416, 0x42620417, 0x42640418, 0x42660419, 0x4268041A, + 0x426A041B, 0x426C041C, 0x426E041D, 0x4270041E, 0x4272041F, 0x42740420, + 0x42760421, 0x42780422, 0x427A0423, 0x427C0424, 0x427E0425, 0x42800426, + 0x42820427, 0x42840428, 0x42860429, 0x4288042A, 0x428A042B, 0x428C042C, + 0x428E042D, 0x4290042E, 0x4292042F, 0x42940460, 0x42960462, 0x42980464, + 0x429A0466, 0x429C0468, 0x429E046A, 0x42A0046C, 0x42A2046E, 0x42A40470, + 0x42A60472, 0x42A80474, 0x42AA0476, 0x42AC0478, 0x42AE047A, 0x42B0047C, + 0x42B2047E, 0x42B40480, 0x42B6048A, 0x42B8048C, 0x42BA048E, 0x42BC0490, + 0x42BE0492, 0x42C00494, 0x42C20496, 0x42C40498, 0x42C6049A, 0x42C8049C, + 0x42CA049E, 0x42CC04A0, 0x42CE04A2, 0x42D004A4, 0x42D204A6, 0x42D404A8, + 0x42D604AA, 0x42D804AC, 0x42DA04AE, 0x42DC04B0, 0x42DE04B2, 0x42E004B4, + 0x42E204B6, 0x42E404B8, 0x42E604BA, 0x42E804BC, 0x42EA04BE, 0x42EC04C0, + 0x42EE04C1, 0x42F004C3, 0x42F204C5, 0x42F404C7, 0x42F604C9, 0x42F804CB, + 0x42FA04CD, 0x42FC04D0, 0x42FE04D2, 0x430004D4, 0x430204D6, 0x430404D8, + 0x430604DA, 0x430804DC, 0x430A04DE, 0x430C04E0, 0x430E04E2, 0x431004E4, + 0x431204E6, 0x431404E8, 0x431604EA, 0x431804EC, 0x431A04EE, 0x431C04F0, + 0x431E04F2, 0x432004F4, 0x432204F6, 0x432404F8, 0x432604FA, 0x432804FC, + 0x432A04FE, 0x432C0500, 0x432E0502, 0x43300504, 0x43320506, 0x43340508, + 0x4336050A, 0x4338050C, 0x433A050E, 0x433C0510, 0x433E0512, 0x43400514, + 0x43420516, 0x43440518, 0x4346051A, 0x4348051C, 0x434A051E, 0x434C0520, + 0x434E0522, 0x43500524, 0x43520526, 0x43540528, 0x4356052A, 0x4358052C, + 0x435A052E, 0x435C0531, 0x435E0532, 0x43600533, 0x43620534, 0x43640535, + 0x43660536, 0x43680537, 0x436A0538, 0x436C0539, 0x436E053A, 0x4370053B, + 0x4372053C, 0x4374053D, 0x4376053E, 0x4378053F, 0x437A0540, 0x437C0541, + 0x437E0542, 0x43800543, 0x43820544, 0x43840545, 0x43860546, 0x43880547, + 0x438A0548, 0x438C0549, 0x438E054A, 0x4390054B, 0x4392054C, 0x4394054D, + 0x4396054E, 0x4398054F, 0x439A0550, 0x439C0551, 0x439E0552, 0x43A00553, + 0x43A20554, 0x43A40555, 0x43A60556, 0x83A80587, 0x63AC10A0, 0x63B010A1, + 0x63B410A2, 0x63B810A3, 0x63BC10A4, 0x63C010A5, 0x63C410A6, 0x63C810A7, + 0x63CC10A8, 0x63D010A9, 0x63D410AA, 0x63D810AB, 0x63DC10AC, 0x63E010AD, + 0x63E410AE, 0x63E810AF, 0x63EC10B0, 0x63F010B1, 0x63F410B2, 0x63F810B3, + 0x63FC10B4, 0x640010B5, 0x640410B6, 0x640810B7, 0x640C10B8, 0x641010B9, + 0x641410BA, 0x641810BB, 0x641C10BC, 0x642010BD, 0x642410BE, 0x642810BF, + 0x642C10C0, 0x643010C1, 0x643410C2, 0x643810C3, 0x643C10C4, 0x644010C5, + 0x644410C7, 0x644810CD, 0x644C13F8, 0x645013F9, 0x645413FA, 0x645813FB, + 0x645C13FC, 0x646013FD, 0x44641C80, 0x44661C81, 0x44681C82, 0x446A1C83, + 0x446C1C84, 0x446E1C85, 0x44701C86, 0x44721C87, 0x64741C88, 0x64781C89, + 0x647C1C90, 0x64801C91, 0x64841C92, 0x64881C93, 0x648C1C94, 0x64901C95, + 0x64941C96, 0x64981C97, 0x649C1C98, 0x64A01C99, 0x64A41C9A, 0x64A81C9B, + 0x64AC1C9C, 0x64B01C9D, 0x64B41C9E, 0x64B81C9F, 0x64BC1CA0, 0x64C01CA1, + 0x64C41CA2, 0x64C81CA3, 0x64CC1CA4, 0x64D01CA5, 0x64D41CA6, 0x64D81CA7, + 0x64DC1CA8, 0x64E01CA9, 0x64E41CAA, 0x64E81CAB, 0x64EC1CAC, 0x64F01CAD, + 0x64F41CAE, 0x64F81CAF, 0x64FC1CB0, 0x65001CB1, 0x65041CB2, 0x65081CB3, + 0x650C1CB4, 0x65101CB5, 0x65141CB6, 0x65181CB7, 0x651C1CB8, 0x65201CB9, + 0x65241CBA, 0x65281CBD, 0x652C1CBE, 0x65301CBF, 0x65341E00, 0x65381E02, + 0x653C1E04, 0x65401E06, 0x65441E08, 0x65481E0A, 0x654C1E0C, 0x65501E0E, + 0x65541E10, 0x65581E12, 0x655C1E14, 0x65601E16, 0x65641E18, 0x65681E1A, + 0x656C1E1C, 0x65701E1E, 0x65741E20, 0x65781E22, 0x657C1E24, 0x65801E26, + 0x65841E28, 0x65881E2A, 0x658C1E2C, 0x65901E2E, 0x65941E30, 0x65981E32, + 0x659C1E34, 0x65A01E36, 0x65A41E38, 0x65A81E3A, 0x65AC1E3C, 0x65B01E3E, + 0x65B41E40, 0x65B81E42, 0x65BC1E44, 0x65C01E46, 0x65C41E48, 0x65C81E4A, + 0x65CC1E4C, 0x65D01E4E, 0x65D41E50, 0x65D81E52, 0x65DC1E54, 0x65E01E56, + 0x65E41E58, 0x65E81E5A, 0x65EC1E5C, 0x65F01E5E, 0x65F41E60, 0x65F81E62, + 0x65FC1E64, 0x66001E66, 0x66041E68, 0x66081E6A, 0x660C1E6C, 0x66101E6E, + 0x66141E70, 0x66181E72, 0x661C1E74, 0x66201E76, 0x66241E78, 0x66281E7A, + 0x662C1E7C, 0x66301E7E, 0x66341E80, 0x66381E82, 0x663C1E84, 0x66401E86, + 0x66441E88, 0x66481E8A, 0x664C1E8C, 0x66501E8E, 0x66541E90, 0x66581E92, + 0x665C1E94, 0x66601E96, 0x66641E97, 0x66681E98, 0x666C1E99, 0x66701E9A, + 0x66741E9B, 0x46781E9E, 0x667A1EA0, 0x667E1EA2, 0x66821EA4, 0x66861EA6, + 0x668A1EA8, 0x668E1EAA, 0x66921EAC, 0x66961EAE, 0x669A1EB0, 0x669E1EB2, + 0x66A21EB4, 0x66A61EB6, 0x66AA1EB8, 0x66AE1EBA, 0x66B21EBC, 0x66B61EBE, + 0x66BA1EC0, 0x66BE1EC2, 0x66C21EC4, 0x66C61EC6, 0x66CA1EC8, 0x66CE1ECA, + 0x66D21ECC, 0x66D61ECE, 0x66DA1ED0, 0x66DE1ED2, 0x66E21ED4, 0x66E61ED6, + 0x66EA1ED8, 0x66EE1EDA, 0x66F21EDC, 0x66F61EDE, 0x66FA1EE0, 0x66FE1EE2, + 0x67021EE4, 0x67061EE6, 0x670A1EE8, 0x670E1EEA, 0x67121EEC, 0x67161EEE, + 0x671A1EF0, 0x671E1EF2, 0x67221EF4, 0x67261EF6, 0x672A1EF8, 0x672E1EFA, + 0x67321EFC, 0x67361EFE, 0x673A1F08, 0x673E1F09, 0x67421F0A, 0x67461F0B, + 0x674A1F0C, 0x674E1F0D, 0x67521F0E, 0x67561F0F, 0x675A1F18, 0x675E1F19, + 0x67621F1A, 0x67661F1B, 0x676A1F1C, 0x676E1F1D, 0x67721F28, 0x67761F29, + 0x677A1F2A, 0x677E1F2B, 0x67821F2C, 0x67861F2D, 0x678A1F2E, 0x678E1F2F, + 0x67921F38, 0x67961F39, 0x679A1F3A, 0x679E1F3B, 0x67A21F3C, 0x67A61F3D, + 0x67AA1F3E, 0x67AE1F3F, 0x67B21F48, 0x67B61F49, 0x67BA1F4A, 0x67BE1F4B, + 0x67C21F4C, 0x67C61F4D, 0x87CA1F50, 0xC7CE1F52, 0xC7D41F54, 0xC7DA1F56, + 0x67E01F59, 0x67E41F5B, 0x67E81F5D, 0x67EC1F5F, 0x67F01F68, 0x67F41F69, + 0x67F81F6A, 0x67FC1F6B, 0x68001F6C, 0x68041F6D, 0x68081F6E, 0x680C1F6F, + 0xA8101F80, 0xA8161F81, 0xA81C1F82, 0xA8221F83, 0xA8281F84, 0xA82E1F85, + 0xA8341F86, 0xA83A1F87, 0xA8401F88, 0xA8461F89, 0xA84C1F8A, 0xA8521F8B, + 0xA8581F8C, 0xA85E1F8D, 0xA8641F8E, 0xA86A1F8F, 0xA8701F90, 0xA8761F91, + 0xA87C1F92, 0xA8821F93, 0xA8881F94, 0xA88E1F95, 0xA8941F96, 0xA89A1F97, + 0xA8A01F98, 0xA8A61F99, 0xA8AC1F9A, 0xA8B21F9B, 0xA8B81F9C, 0xA8BE1F9D, + 0xA8C41F9E, 0xA8CA1F9F, 0xA8D01FA0, 0xA8D61FA1, 0xA8DC1FA2, 0xA8E21FA3, + 0xA8E81FA4, 0xA8EE1FA5, 0xA8F41FA6, 0xA8FA1FA7, 0xA9001FA8, 0xA9061FA9, + 0xA90C1FAA, 0xA9121FAB, 0xA9181FAC, 0xA91E1FAD, 0xA9241FAE, 0xA92A1FAF, + 0xA9301FB2, 0x89361FB3, 0x893A1FB4, 0x893E1FB6, 0xC9421FB7, 0x69481FB8, + 0x694C1FB9, 0x69501FBA, 0x69541FBB, 0x89581FBC, 0x495C1FBE, 0xA95E1FC2, + 0x89641FC3, 0x89681FC4, 0x896C1FC6, 0xC9701FC7, 0x69761FC8, 0x697A1FC9, + 0x697E1FCA, 0x69821FCB, 0x89861FCC, 0xC98A1FD2, 0xC9901FD3, 0x89961FD6, + 0xC99A1FD7, 0x69A01FD8, 0x69A41FD9, 0x69A81FDA, 0x69AC1FDB, 0xC9B01FE2, + 0xC9B61FE3, 0x89BC1FE4, 0x89C01FE6, 0xC9C41FE7, 0x69CA1FE8, 0x69CE1FE9, + 0x69D21FEA, 0x69D61FEB, 0x69DA1FEC, 0xA9DE1FF2, 0x89E41FF3, 0x89E81FF4, + 0x89EC1FF6, 0xC9F01FF7, 0x69F61FF8, 0x69FA1FF9, 0x69FE1FFA, 0x6A021FFB, + 0x8A061FFC, 0x4A0A2126, 0x2A0C212A, 0x4A0E212B, 0x6A102132, 0x6A142160, + 0x6A182161, 0x6A1C2162, 0x6A202163, 0x6A242164, 0x6A282165, 0x6A2C2166, + 0x6A302167, 0x6A342168, 0x6A382169, 0x6A3C216A, 0x6A40216B, 0x6A44216C, + 0x6A48216D, 0x6A4C216E, 0x6A50216F, 0x6A542183, 0x6A5824B6, 0x6A5C24B7, + 0x6A6024B8, 0x6A6424B9, 0x6A6824BA, 0x6A6C24BB, 0x6A7024BC, 0x6A7424BD, + 0x6A7824BE, 0x6A7C24BF, 0x6A8024C0, 0x6A8424C1, 0x6A8824C2, 0x6A8C24C3, + 0x6A9024C4, 0x6A9424C5, 0x6A9824C6, 0x6A9C24C7, 0x6AA024C8, 0x6AA424C9, + 0x6AA824CA, 0x6AAC24CB, 0x6AB024CC, 0x6AB424CD, 0x6AB824CE, 0x6ABC24CF, + 0x6AC02C00, 0x6AC42C01, 0x6AC82C02, 0x6ACC2C03, 0x6AD02C04, 0x6AD42C05, + 0x6AD82C06, 0x6ADC2C07, 0x6AE02C08, 0x6AE42C09, 0x6AE82C0A, 0x6AEC2C0B, + 0x6AF02C0C, 0x6AF42C0D, 0x6AF82C0E, 0x6AFC2C0F, 0x6B002C10, 0x6B042C11, + 0x6B082C12, 0x6B0C2C13, 0x6B102C14, 0x6B142C15, 0x6B182C16, 0x6B1C2C17, + 0x6B202C18, 0x6B242C19, 0x6B282C1A, 0x6B2C2C1B, 0x6B302C1C, 0x6B342C1D, + 0x6B382C1E, 0x6B3C2C1F, 0x6B402C20, 0x6B442C21, 0x6B482C22, 0x6B4C2C23, + 0x6B502C24, 0x6B542C25, 0x6B582C26, 0x6B5C2C27, 0x6B602C28, 0x6B642C29, + 0x6B682C2A, 0x6B6C2C2B, 0x6B702C2C, 0x6B742C2D, 0x6B782C2E, 0x6B7C2C2F, + 0x6B802C60, 0x4B842C62, 0x6B862C63, 0x4B8A2C64, 0x6B8C2C67, 0x6B902C69, + 0x6B942C6B, 0x4B982C6D, 0x4B9A2C6E, 0x4B9C2C6F, 0x4B9E2C70, 0x6BA02C72, + 0x6BA42C75, 0x4BA82C7E, 0x4BAA2C7F, 0x6BAC2C80, 0x6BB02C82, 0x6BB42C84, + 0x6BB82C86, 0x6BBC2C88, 0x6BC02C8A, 0x6BC42C8C, 0x6BC82C8E, 0x6BCC2C90, + 0x6BD02C92, 0x6BD42C94, 0x6BD82C96, 0x6BDC2C98, 0x6BE02C9A, 0x6BE42C9C, + 0x6BE82C9E, 0x6BEC2CA0, 0x6BF02CA2, 0x6BF42CA4, 0x6BF82CA6, 0x6BFC2CA8, + 0x6C002CAA, 0x6C042CAC, 0x6C082CAE, 0x6C0C2CB0, 0x6C102CB2, 0x6C142CB4, + 0x6C182CB6, 0x6C1C2CB8, 0x6C202CBA, 0x6C242CBC, 0x6C282CBE, 0x6C2C2CC0, + 0x6C302CC2, 0x6C342CC4, 0x6C382CC6, 0x6C3C2CC8, 0x6C402CCA, 0x6C442CCC, + 0x6C482CCE, 0x6C4C2CD0, 0x6C502CD2, 0x6C542CD4, 0x6C582CD6, 0x6C5C2CD8, + 0x6C602CDA, 0x6C642CDC, 0x6C682CDE, 0x6C6C2CE0, 0x6C702CE2, 0x6C742CEB, + 0x6C782CED, 0x6C7C2CF2, 0x6C80A640, 0x6C84A642, 0x6C88A644, 0x6C8CA646, + 0x6C90A648, 0x6C94A64A, 0x6C98A64C, 0x6C9CA64E, 0x6CA0A650, 0x6CA4A652, + 0x6CA8A654, 0x6CACA656, 0x6CB0A658, 0x6CB4A65A, 0x6CB8A65C, 0x6CBCA65E, + 0x6CC0A660, 0x6CC4A662, 0x6CC8A664, 0x6CCCA666, 0x6CD0A668, 0x6CD4A66A, + 0x6CD8A66C, 0x6CDCA680, 0x6CE0A682, 0x6CE4A684, 0x6CE8A686, 0x6CECA688, + 0x6CF0A68A, 0x6CF4A68C, 0x6CF8A68E, 0x6CFCA690, 0x6D00A692, 0x6D04A694, + 0x6D08A696, 0x6D0CA698, 0x6D10A69A, 0x6D14A722, 0x6D18A724, 0x6D1CA726, + 0x6D20A728, 0x6D24A72A, 0x6D28A72C, 0x6D2CA72E, 0x6D30A732, 0x6D34A734, + 0x6D38A736, 0x6D3CA738, 0x6D40A73A, 0x6D44A73C, 0x6D48A73E, 0x6D4CA740, + 0x6D50A742, 0x6D54A744, 0x6D58A746, 0x6D5CA748, 0x6D60A74A, 0x6D64A74C, + 0x6D68A74E, 0x6D6CA750, 0x6D70A752, 0x6D74A754, 0x6D78A756, 0x6D7CA758, + 0x6D80A75A, 0x6D84A75C, 0x6D88A75E, 0x6D8CA760, 0x6D90A762, 0x6D94A764, + 0x6D98A766, 0x6D9CA768, 0x6DA0A76A, 0x6DA4A76C, 0x6DA8A76E, 0x6DACA779, + 0x6DB0A77B, 0x6DB4A77D, 0x6DB8A77E, 0x6DBCA780, 0x6DC0A782, 0x6DC4A784, + 0x6DC8A786, 0x6DCCA78B, 0x4DD0A78D, 0x6DD2A790, 0x6DD6A792, 0x6DDAA796, + 0x6DDEA798, 0x6DE2A79A, 0x6DE6A79C, 0x6DEAA79E, 0x6DEEA7A0, 0x6DF2A7A2, + 0x6DF6A7A4, 0x6DFAA7A6, 0x6DFEA7A8, 0x4E02A7AA, 0x4E04A7AB, 0x4E06A7AC, + 0x4E08A7AD, 0x4E0AA7AE, 0x4E0CA7B0, 0x4E0EA7B1, 0x4E10A7B2, 0x6E12A7B3, + 0x6E16A7B4, 0x6E1AA7B6, 0x6E1EA7B8, 0x6E22A7BA, 0x6E26A7BC, 0x6E2AA7BE, + 0x6E2EA7C0, 0x6E32A7C2, 0x6E36A7C4, 0x4E3AA7C5, 0x6E3CA7C6, 0x6E40A7C7, + 0x6E44A7C9, 0x4E48A7CB, 0x6E4AA7CC, 0x6E4EA7CE, 0x6E52A7D0, 0x6E56A7D2, + 0x6E5AA7D4, 0x6E5EA7D6, 0x6E62A7D8, 0x6E66A7DA, 0x4E6AA7DC, 0x6E6CA7F5, + 0x6E70AB70, 0x6E74AB71, 0x6E78AB72, 0x6E7CAB73, 0x6E80AB74, 0x6E84AB75, + 0x6E88AB76, 0x6E8CAB77, 0x6E90AB78, 0x6E94AB79, 0x6E98AB7A, 0x6E9CAB7B, + 0x6EA0AB7C, 0x6EA4AB7D, 0x6EA8AB7E, 0x6EACAB7F, 0x6EB0AB80, 0x6EB4AB81, + 0x6EB8AB82, 0x6EBCAB83, 0x6EC0AB84, 0x6EC4AB85, 0x6EC8AB86, 0x6ECCAB87, + 0x6ED0AB88, 0x6ED4AB89, 0x6ED8AB8A, 0x6EDCAB8B, 0x6EE0AB8C, 0x6EE4AB8D, + 0x6EE8AB8E, 0x6EECAB8F, 0x6EF0AB90, 0x6EF4AB91, 0x6EF8AB92, 0x6EFCAB93, + 0x6F00AB94, 0x6F04AB95, 0x6F08AB96, 0x6F0CAB97, 0x6F10AB98, 0x6F14AB99, + 0x6F18AB9A, 0x6F1CAB9B, 0x6F20AB9C, 0x6F24AB9D, 0x6F28AB9E, 0x6F2CAB9F, + 0x6F30ABA0, 0x6F34ABA1, 0x6F38ABA2, 0x6F3CABA3, 0x6F40ABA4, 0x6F44ABA5, + 0x6F48ABA6, 0x6F4CABA7, 0x6F50ABA8, 0x6F54ABA9, 0x6F58ABAA, 0x6F5CABAB, + 0x6F60ABAC, 0x6F64ABAD, 0x6F68ABAE, 0x6F6CABAF, 0x6F70ABB0, 0x6F74ABB1, + 0x6F78ABB2, 0x6F7CABB3, 0x6F80ABB4, 0x6F84ABB5, 0x6F88ABB6, 0x6F8CABB7, + 0x6F90ABB8, 0x6F94ABB9, 0x6F98ABBA, 0x6F9CABBB, 0x6FA0ABBC, 0x6FA4ABBD, + 0x6FA8ABBE, 0x6FACABBF, 0x4FB0FB00, 0x4FB2FB01, 0x4FB4FB02, 0x6FB6FB03, + 0x6FBAFB04, 0x4FBEFB05, 0x4FC0FB06, 0x8FC2FB13, 0x8FC6FB14, 0x8FCAFB15, + 0x8FCEFB16, 0x8FD2FB17, 0x6FD6FF21, 0x6FDAFF22, 0x6FDEFF23, 0x6FE2FF24, + 0x6FE6FF25, 0x6FEAFF26, 0x6FEEFF27, 0x6FF2FF28, 0x6FF6FF29, 0x6FFAFF2A, + 0x6FFEFF2B, 0x7002FF2C, 0x7006FF2D, 0x700AFF2E, 0x700EFF2F, 0x7012FF30, + 0x7016FF31, 0x701AFF32, 0x701EFF33, 0x7022FF34, 0x7026FF35, 0x702AFF36, + 0x702EFF37, 0x7032FF38, 0x7036FF39, 0x703AFF3A, 0x903F0400, 0x90430401, + 0x90470402, 0x904B0403, 0x904F0404, 0x90530405, 0x90570406, 0x905B0407, + 0x905F0408, 0x90630409, 0x9067040A, 0x906B040B, 0x906F040C, 0x9073040D, + 0x9077040E, 0x907B040F, 0x907F0410, 0x90830411, 0x90870412, 0x908B0413, + 0x908F0414, 0x90930415, 0x90970416, 0x909B0417, 0x909F0418, 0x90A30419, + 0x90A7041A, 0x90AB041B, 0x90AF041C, 0x90B3041D, 0x90B7041E, 0x90BB041F, + 0x90BF0420, 0x90C30421, 0x90C70422, 0x90CB0423, 0x90CF0424, 0x90D30425, + 0x90D70426, 0x90DB0427, 0x90DF04B0, 0x90E304B1, 0x90E704B2, 0x90EB04B3, + 0x90EF04B4, 0x90F304B5, 0x90F704B6, 0x90FB04B7, 0x90FF04B8, 0x910304B9, + 0x910704BA, 0x910B04BB, 0x910F04BC, 0x911304BD, 0x911704BE, 0x911B04BF, + 0x911F04C0, 0x912304C1, 0x912704C2, 0x912B04C3, 0x912F04C4, 0x913304C5, + 0x913704C6, 0x913B04C7, 0x913F04C8, 0x914304C9, 0x914704CA, 0x914B04CB, + 0x914F04CC, 0x915304CD, 0x915704CE, 0x915B04CF, 0x915F04D0, 0x916304D1, + 0x916704D2, 0x916B04D3, 0x916F0570, 0x91730571, 0x91770572, 0x917B0573, + 0x917F0574, 0x91830575, 0x91870576, 0x918B0577, 0x918F0578, 0x91930579, + 0x9197057A, 0x919B057C, 0x919F057D, 0x91A3057E, 0x91A7057F, 0x91AB0580, + 0x91AF0581, 0x91B30582, 0x91B70583, 0x91BB0584, 0x91BF0585, 0x91C30586, + 0x91C70587, 0x91CB0588, 0x91CF0589, 0x91D3058A, 0x91D7058C, 0x91DB058D, + 0x91DF058E, 0x91E3058F, 0x91E70590, 0x91EB0591, 0x91EF0592, 0x91F30594, + 0x91F70595, 0x91FB0C80, 0x91FF0C81, 0x92030C82, 0x92070C83, 0x920B0C84, + 0x920F0C85, 0x92130C86, 0x92170C87, 0x921B0C88, 0x921F0C89, 0x92230C8A, + 0x92270C8B, 0x922B0C8C, 0x922F0C8D, 0x92330C8E, 0x92370C8F, 0x923B0C90, + 0x923F0C91, 0x92430C92, 0x92470C93, 0x924B0C94, 0x924F0C95, 0x92530C96, + 0x92570C97, 0x925B0C98, 0x925F0C99, 0x92630C9A, 0x92670C9B, 0x926B0C9C, + 0x926F0C9D, 0x92730C9E, 0x92770C9F, 0x927B0CA0, 0x927F0CA1, 0x92830CA2, + 0x92870CA3, 0x928B0CA4, 0x928F0CA5, 0x92930CA6, 0x92970CA7, 0x929B0CA8, + 0x929F0CA9, 0x92A30CAA, 0x92A70CAB, 0x92AB0CAC, 0x92AF0CAD, 0x92B30CAE, + 0x92B70CAF, 0x92BB0CB0, 0x92BF0CB1, 0x92C30CB2, 0x92C70D50, 0x92CB0D51, + 0x92CF0D52, 0x92D30D53, 0x92D70D54, 0x92DB0D55, 0x92DF0D56, 0x92E30D57, + 0x92E70D58, 0x92EB0D59, 0x92EF0D5A, 0x92F30D5B, 0x92F70D5C, 0x92FB0D5D, + 0x92FF0D5E, 0x93030D5F, 0x93070D60, 0x930B0D61, 0x930F0D62, 0x93130D63, + 0x93170D64, 0x931B0D65, 0x931F18A0, 0x932318A1, 0x932718A2, 0x932B18A3, + 0x932F18A4, 0x933318A5, 0x933718A6, 0x933B18A7, 0x933F18A8, 0x934318A9, + 0x934718AA, 0x934B18AB, 0x934F18AC, 0x935318AD, 0x935718AE, 0x935B18AF, + 0x935F18B0, 0x936318B1, 0x936718B2, 0x936B18B3, 0x936F18B4, 0x937318B5, + 0x937718B6, 0x937B18B7, 0x937F18B8, 0x938318B9, 0x938718BA, 0x938B18BB, + 0x938F18BC, 0x939318BD, 0x939718BE, 0x939B18BF, 0x939F6E40, 0x93A36E41, + 0x93A76E42, 0x93AB6E43, 0x93AF6E44, 0x93B36E45, 0x93B76E46, 0x93BB6E47, + 0x93BF6E48, 0x93C36E49, 0x93C76E4A, 0x93CB6E4B, 0x93CF6E4C, 0x93D36E4D, + 0x93D76E4E, 0x93DB6E4F, 0x93DF6E50, 0x93E36E51, 0x93E76E52, 0x93EB6E53, + 0x93EF6E54, 0x93F36E55, 0x93F76E56, 0x93FB6E57, 0x93FF6E58, 0x94036E59, + 0x94076E5A, 0x940B6E5B, 0x940F6E5C, 0x94136E5D, 0x94176E5E, 0x941B6E5F, + 0x941F6EA0, 0x94236EA1, 0x94276EA2, 0x942B6EA3, 0x942F6EA4, 0x94336EA5, + 0x94376EA6, 0x943B6EA7, 0x943F6EA8, 0x94436EA9, 0x94476EAA, 0x944B6EAB, + 0x944F6EAC, 0x94536EAD, 0x94576EAE, 0x945B6EAF, 0x945F6EB0, 0x94636EB1, + 0x94676EB2, 0x946B6EB3, 0x946F6EB4, 0x94736EB5, 0x94776EB6, 0x947B6EB7, + 0x947F6EB8, 0x9483E900, 0x9487E901, 0x948BE902, 0x948FE903, 0x9493E904, + 0x9497E905, 0x949BE906, 0x949FE907, 0x94A3E908, 0x94A7E909, 0x94ABE90A, + 0x94AFE90B, 0x94B3E90C, 0x94B7E90D, 0x94BBE90E, 0x94BFE90F, 0x94C3E910, + 0x94C7E911, 0x94CBE912, 0x94CFE913, 0x94D3E914, 0x94D7E915, 0x94DBE916, + 0x94DFE917, 0x94E3E918, 0x94E7E919, 0x94EBE91A, 0x94EFE91B, 0x94F3E91C, + 0x94F7E91D, 0x94FBE91E, 0x94FFE91F, 0x9503E920, 0x9507E921 +}; + +static const unsigned char cf_repl[5386] = { + 0xCE, 0xBC, 0xC3, 0xA0, 0xC3, 0xA1, 0xC3, 0xA2, 0xC3, 0xA3, 0xC3, 0xA4, + 0xC3, 0xA5, 0xC3, 0xA6, 0xC3, 0xA7, 0xC3, 0xA8, 0xC3, 0xA9, 0xC3, 0xAA, + 0xC3, 0xAB, 0xC3, 0xAC, 0xC3, 0xAD, 0xC3, 0xAE, 0xC3, 0xAF, 0xC3, 0xB0, + 0xC3, 0xB1, 0xC3, 0xB2, 0xC3, 0xB3, 0xC3, 0xB4, 0xC3, 0xB5, 0xC3, 0xB6, + 0xC3, 0xB8, 0xC3, 0xB9, 0xC3, 0xBA, 0xC3, 0xBB, 0xC3, 0xBC, 0xC3, 0xBD, + 0xC3, 0xBE, 0x73, 0x73, 0xC4, 0x81, 0xC4, 0x83, 0xC4, 0x85, 0xC4, 0x87, + 0xC4, 0x89, 0xC4, 0x8B, 0xC4, 0x8D, 0xC4, 0x8F, 0xC4, 0x91, 0xC4, 0x93, + 0xC4, 0x95, 0xC4, 0x97, 0xC4, 0x99, 0xC4, 0x9B, 0xC4, 0x9D, 0xC4, 0x9F, + 0xC4, 0xA1, 0xC4, 0xA3, 0xC4, 0xA5, 0xC4, 0xA7, 0xC4, 0xA9, 0xC4, 0xAB, + 0xC4, 0xAD, 0xC4, 0xAF, 0x69, 0xCC, 0x87, 0x00, 0xC4, 0xB3, 0xC4, 0xB5, + 0xC4, 0xB7, 0xC4, 0xBA, 0xC4, 0xBC, 0xC4, 0xBE, 0xC5, 0x80, 0xC5, 0x82, + 0xC5, 0x84, 0xC5, 0x86, 0xC5, 0x88, 0xCA, 0xBC, 0x6E, 0x00, 0xC5, 0x8B, + 0xC5, 0x8D, 0xC5, 0x8F, 0xC5, 0x91, 0xC5, 0x93, 0xC5, 0x95, 0xC5, 0x97, + 0xC5, 0x99, 0xC5, 0x9B, 0xC5, 0x9D, 0xC5, 0x9F, 0xC5, 0xA1, 0xC5, 0xA3, + 0xC5, 0xA5, 0xC5, 0xA7, 0xC5, 0xA9, 0xC5, 0xAB, 0xC5, 0xAD, 0xC5, 0xAF, + 0xC5, 0xB1, 0xC5, 0xB3, 0xC5, 0xB5, 0xC5, 0xB7, 0xC3, 0xBF, 0xC5, 0xBA, + 0xC5, 0xBC, 0xC5, 0xBE, 0x73, 0x00, 0xC9, 0x93, 0xC6, 0x83, 0xC6, 0x85, + 0xC9, 0x94, 0xC6, 0x88, 0xC9, 0x96, 0xC9, 0x97, 0xC6, 0x8C, 0xC7, 0x9D, + 0xC9, 0x99, 0xC9, 0x9B, 0xC6, 0x92, 0xC9, 0xA0, 0xC9, 0xA3, 0xC9, 0xA9, + 0xC9, 0xA8, 0xC6, 0x99, 0xC9, 0xAF, 0xC9, 0xB2, 0xC9, 0xB5, 0xC6, 0xA1, + 0xC6, 0xA3, 0xC6, 0xA5, 0xCA, 0x80, 0xC6, 0xA8, 0xCA, 0x83, 0xC6, 0xAD, + 0xCA, 0x88, 0xC6, 0xB0, 0xCA, 0x8A, 0xCA, 0x8B, 0xC6, 0xB4, 0xC6, 0xB6, + 0xCA, 0x92, 0xC6, 0xB9, 0xC6, 0xBD, 0xC7, 0x86, 0xC7, 0x86, 0xC7, 0x89, + 0xC7, 0x89, 0xC7, 0x8C, 0xC7, 0x8C, 0xC7, 0x8E, 0xC7, 0x90, 0xC7, 0x92, + 0xC7, 0x94, 0xC7, 0x96, 0xC7, 0x98, 0xC7, 0x9A, 0xC7, 0x9C, 0xC7, 0x9F, + 0xC7, 0xA1, 0xC7, 0xA3, 0xC7, 0xA5, 0xC7, 0xA7, 0xC7, 0xA9, 0xC7, 0xAB, + 0xC7, 0xAD, 0xC7, 0xAF, 0x6A, 0xCC, 0x8C, 0x00, 0xC7, 0xB3, 0xC7, 0xB3, + 0xC7, 0xB5, 0xC6, 0x95, 0xC6, 0xBF, 0xC7, 0xB9, 0xC7, 0xBB, 0xC7, 0xBD, + 0xC7, 0xBF, 0xC8, 0x81, 0xC8, 0x83, 0xC8, 0x85, 0xC8, 0x87, 0xC8, 0x89, + 0xC8, 0x8B, 0xC8, 0x8D, 0xC8, 0x8F, 0xC8, 0x91, 0xC8, 0x93, 0xC8, 0x95, + 0xC8, 0x97, 0xC8, 0x99, 0xC8, 0x9B, 0xC8, 0x9D, 0xC8, 0x9F, 0xC6, 0x9E, + 0xC8, 0xA3, 0xC8, 0xA5, 0xC8, 0xA7, 0xC8, 0xA9, 0xC8, 0xAB, 0xC8, 0xAD, + 0xC8, 0xAF, 0xC8, 0xB1, 0xC8, 0xB3, 0xE2, 0xB1, 0xA5, 0x00, 0xC8, 0xBC, + 0xC6, 0x9A, 0xE2, 0xB1, 0xA6, 0x00, 0xC9, 0x82, 0xC6, 0x80, 0xCA, 0x89, + 0xCA, 0x8C, 0xC9, 0x87, 0xC9, 0x89, 0xC9, 0x8B, 0xC9, 0x8D, 0xC9, 0x8F, + 0xCE, 0xB9, 0xCD, 0xB1, 0xCD, 0xB3, 0xCD, 0xB7, 0xCF, 0xB3, 0xCE, 0xAC, + 0xCE, 0xAD, 0xCE, 0xAE, 0xCE, 0xAF, 0xCF, 0x8C, 0xCF, 0x8D, 0xCF, 0x8E, + 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x81, 0xCE, 0xB1, 0xCE, 0xB2, 0xCE, 0xB3, + 0xCE, 0xB4, 0xCE, 0xB5, 0xCE, 0xB6, 0xCE, 0xB7, 0xCE, 0xB8, 0xCE, 0xB9, + 0xCE, 0xBA, 0xCE, 0xBB, 0xCE, 0xBC, 0xCE, 0xBD, 0xCE, 0xBE, 0xCE, 0xBF, + 0xCF, 0x80, 0xCF, 0x81, 0xCF, 0x83, 0xCF, 0x84, 0xCF, 0x85, 0xCF, 0x86, + 0xCF, 0x87, 0xCF, 0x88, 0xCF, 0x89, 0xCF, 0x8A, 0xCF, 0x8B, 0xCF, 0x85, + 0xCC, 0x88, 0xCC, 0x81, 0xCF, 0x83, 0xCF, 0x97, 0xCE, 0xB2, 0xCE, 0xB8, + 0xCF, 0x86, 0xCF, 0x80, 0xCF, 0x99, 0xCF, 0x9B, 0xCF, 0x9D, 0xCF, 0x9F, + 0xCF, 0xA1, 0xCF, 0xA3, 0xCF, 0xA5, 0xCF, 0xA7, 0xCF, 0xA9, 0xCF, 0xAB, + 0xCF, 0xAD, 0xCF, 0xAF, 0xCE, 0xBA, 0xCF, 0x81, 0xCE, 0xB8, 0xCE, 0xB5, + 0xCF, 0xB8, 0xCF, 0xB2, 0xCF, 0xBB, 0xCD, 0xBB, 0xCD, 0xBC, 0xCD, 0xBD, + 0xD1, 0x90, 0xD1, 0x91, 0xD1, 0x92, 0xD1, 0x93, 0xD1, 0x94, 0xD1, 0x95, + 0xD1, 0x96, 0xD1, 0x97, 0xD1, 0x98, 0xD1, 0x99, 0xD1, 0x9A, 0xD1, 0x9B, + 0xD1, 0x9C, 0xD1, 0x9D, 0xD1, 0x9E, 0xD1, 0x9F, 0xD0, 0xB0, 0xD0, 0xB1, + 0xD0, 0xB2, 0xD0, 0xB3, 0xD0, 0xB4, 0xD0, 0xB5, 0xD0, 0xB6, 0xD0, 0xB7, + 0xD0, 0xB8, 0xD0, 0xB9, 0xD0, 0xBA, 0xD0, 0xBB, 0xD0, 0xBC, 0xD0, 0xBD, + 0xD0, 0xBE, 0xD0, 0xBF, 0xD1, 0x80, 0xD1, 0x81, 0xD1, 0x82, 0xD1, 0x83, + 0xD1, 0x84, 0xD1, 0x85, 0xD1, 0x86, 0xD1, 0x87, 0xD1, 0x88, 0xD1, 0x89, + 0xD1, 0x8A, 0xD1, 0x8B, 0xD1, 0x8C, 0xD1, 0x8D, 0xD1, 0x8E, 0xD1, 0x8F, + 0xD1, 0xA1, 0xD1, 0xA3, 0xD1, 0xA5, 0xD1, 0xA7, 0xD1, 0xA9, 0xD1, 0xAB, + 0xD1, 0xAD, 0xD1, 0xAF, 0xD1, 0xB1, 0xD1, 0xB3, 0xD1, 0xB5, 0xD1, 0xB7, + 0xD1, 0xB9, 0xD1, 0xBB, 0xD1, 0xBD, 0xD1, 0xBF, 0xD2, 0x81, 0xD2, 0x8B, + 0xD2, 0x8D, 0xD2, 0x8F, 0xD2, 0x91, 0xD2, 0x93, 0xD2, 0x95, 0xD2, 0x97, + 0xD2, 0x99, 0xD2, 0x9B, 0xD2, 0x9D, 0xD2, 0x9F, 0xD2, 0xA1, 0xD2, 0xA3, + 0xD2, 0xA5, 0xD2, 0xA7, 0xD2, 0xA9, 0xD2, 0xAB, 0xD2, 0xAD, 0xD2, 0xAF, + 0xD2, 0xB1, 0xD2, 0xB3, 0xD2, 0xB5, 0xD2, 0xB7, 0xD2, 0xB9, 0xD2, 0xBB, + 0xD2, 0xBD, 0xD2, 0xBF, 0xD3, 0x8F, 0xD3, 0x82, 0xD3, 0x84, 0xD3, 0x86, + 0xD3, 0x88, 0xD3, 0x8A, 0xD3, 0x8C, 0xD3, 0x8E, 0xD3, 0x91, 0xD3, 0x93, + 0xD3, 0x95, 0xD3, 0x97, 0xD3, 0x99, 0xD3, 0x9B, 0xD3, 0x9D, 0xD3, 0x9F, + 0xD3, 0xA1, 0xD3, 0xA3, 0xD3, 0xA5, 0xD3, 0xA7, 0xD3, 0xA9, 0xD3, 0xAB, + 0xD3, 0xAD, 0xD3, 0xAF, 0xD3, 0xB1, 0xD3, 0xB3, 0xD3, 0xB5, 0xD3, 0xB7, + 0xD3, 0xB9, 0xD3, 0xBB, 0xD3, 0xBD, 0xD3, 0xBF, 0xD4, 0x81, 0xD4, 0x83, + 0xD4, 0x85, 0xD4, 0x87, 0xD4, 0x89, 0xD4, 0x8B, 0xD4, 0x8D, 0xD4, 0x8F, + 0xD4, 0x91, 0xD4, 0x93, 0xD4, 0x95, 0xD4, 0x97, 0xD4, 0x99, 0xD4, 0x9B, + 0xD4, 0x9D, 0xD4, 0x9F, 0xD4, 0xA1, 0xD4, 0xA3, 0xD4, 0xA5, 0xD4, 0xA7, + 0xD4, 0xA9, 0xD4, 0xAB, 0xD4, 0xAD, 0xD4, 0xAF, 0xD5, 0xA1, 0xD5, 0xA2, + 0xD5, 0xA3, 0xD5, 0xA4, 0xD5, 0xA5, 0xD5, 0xA6, 0xD5, 0xA7, 0xD5, 0xA8, + 0xD5, 0xA9, 0xD5, 0xAA, 0xD5, 0xAB, 0xD5, 0xAC, 0xD5, 0xAD, 0xD5, 0xAE, + 0xD5, 0xAF, 0xD5, 0xB0, 0xD5, 0xB1, 0xD5, 0xB2, 0xD5, 0xB3, 0xD5, 0xB4, + 0xD5, 0xB5, 0xD5, 0xB6, 0xD5, 0xB7, 0xD5, 0xB8, 0xD5, 0xB9, 0xD5, 0xBA, + 0xD5, 0xBB, 0xD5, 0xBC, 0xD5, 0xBD, 0xD5, 0xBE, 0xD5, 0xBF, 0xD6, 0x80, + 0xD6, 0x81, 0xD6, 0x82, 0xD6, 0x83, 0xD6, 0x84, 0xD6, 0x85, 0xD6, 0x86, + 0xD5, 0xA5, 0xD6, 0x82, 0xE2, 0xB4, 0x80, 0x00, 0xE2, 0xB4, 0x81, 0x00, + 0xE2, 0xB4, 0x82, 0x00, 0xE2, 0xB4, 0x83, 0x00, 0xE2, 0xB4, 0x84, 0x00, + 0xE2, 0xB4, 0x85, 0x00, 0xE2, 0xB4, 0x86, 0x00, 0xE2, 0xB4, 0x87, 0x00, + 0xE2, 0xB4, 0x88, 0x00, 0xE2, 0xB4, 0x89, 0x00, 0xE2, 0xB4, 0x8A, 0x00, + 0xE2, 0xB4, 0x8B, 0x00, 0xE2, 0xB4, 0x8C, 0x00, 0xE2, 0xB4, 0x8D, 0x00, + 0xE2, 0xB4, 0x8E, 0x00, 0xE2, 0xB4, 0x8F, 0x00, 0xE2, 0xB4, 0x90, 0x00, + 0xE2, 0xB4, 0x91, 0x00, 0xE2, 0xB4, 0x92, 0x00, 0xE2, 0xB4, 0x93, 0x00, + 0xE2, 0xB4, 0x94, 0x00, 0xE2, 0xB4, 0x95, 0x00, 0xE2, 0xB4, 0x96, 0x00, + 0xE2, 0xB4, 0x97, 0x00, 0xE2, 0xB4, 0x98, 0x00, 0xE2, 0xB4, 0x99, 0x00, + 0xE2, 0xB4, 0x9A, 0x00, 0xE2, 0xB4, 0x9B, 0x00, 0xE2, 0xB4, 0x9C, 0x00, + 0xE2, 0xB4, 0x9D, 0x00, 0xE2, 0xB4, 0x9E, 0x00, 0xE2, 0xB4, 0x9F, 0x00, + 0xE2, 0xB4, 0xA0, 0x00, 0xE2, 0xB4, 0xA1, 0x00, 0xE2, 0xB4, 0xA2, 0x00, + 0xE2, 0xB4, 0xA3, 0x00, 0xE2, 0xB4, 0xA4, 0x00, 0xE2, 0xB4, 0xA5, 0x00, + 0xE2, 0xB4, 0xA7, 0x00, 0xE2, 0xB4, 0xAD, 0x00, 0xE1, 0x8F, 0xB0, 0x00, + 0xE1, 0x8F, 0xB1, 0x00, 0xE1, 0x8F, 0xB2, 0x00, 0xE1, 0x8F, 0xB3, 0x00, + 0xE1, 0x8F, 0xB4, 0x00, 0xE1, 0x8F, 0xB5, 0x00, 0xD0, 0xB2, 0xD0, 0xB4, + 0xD0, 0xBE, 0xD1, 0x81, 0xD1, 0x82, 0xD1, 0x82, 0xD1, 0x8A, 0xD1, 0xA3, + 0xEA, 0x99, 0x8B, 0x00, 0xE1, 0xB2, 0x8A, 0x00, 0xE1, 0x83, 0x90, 0x00, + 0xE1, 0x83, 0x91, 0x00, 0xE1, 0x83, 0x92, 0x00, 0xE1, 0x83, 0x93, 0x00, + 0xE1, 0x83, 0x94, 0x00, 0xE1, 0x83, 0x95, 0x00, 0xE1, 0x83, 0x96, 0x00, + 0xE1, 0x83, 0x97, 0x00, 0xE1, 0x83, 0x98, 0x00, 0xE1, 0x83, 0x99, 0x00, + 0xE1, 0x83, 0x9A, 0x00, 0xE1, 0x83, 0x9B, 0x00, 0xE1, 0x83, 0x9C, 0x00, + 0xE1, 0x83, 0x9D, 0x00, 0xE1, 0x83, 0x9E, 0x00, 0xE1, 0x83, 0x9F, 0x00, + 0xE1, 0x83, 0xA0, 0x00, 0xE1, 0x83, 0xA1, 0x00, 0xE1, 0x83, 0xA2, 0x00, + 0xE1, 0x83, 0xA3, 0x00, 0xE1, 0x83, 0xA4, 0x00, 0xE1, 0x83, 0xA5, 0x00, + 0xE1, 0x83, 0xA6, 0x00, 0xE1, 0x83, 0xA7, 0x00, 0xE1, 0x83, 0xA8, 0x00, + 0xE1, 0x83, 0xA9, 0x00, 0xE1, 0x83, 0xAA, 0x00, 0xE1, 0x83, 0xAB, 0x00, + 0xE1, 0x83, 0xAC, 0x00, 0xE1, 0x83, 0xAD, 0x00, 0xE1, 0x83, 0xAE, 0x00, + 0xE1, 0x83, 0xAF, 0x00, 0xE1, 0x83, 0xB0, 0x00, 0xE1, 0x83, 0xB1, 0x00, + 0xE1, 0x83, 0xB2, 0x00, 0xE1, 0x83, 0xB3, 0x00, 0xE1, 0x83, 0xB4, 0x00, + 0xE1, 0x83, 0xB5, 0x00, 0xE1, 0x83, 0xB6, 0x00, 0xE1, 0x83, 0xB7, 0x00, + 0xE1, 0x83, 0xB8, 0x00, 0xE1, 0x83, 0xB9, 0x00, 0xE1, 0x83, 0xBA, 0x00, + 0xE1, 0x83, 0xBD, 0x00, 0xE1, 0x83, 0xBE, 0x00, 0xE1, 0x83, 0xBF, 0x00, + 0xE1, 0xB8, 0x81, 0x00, 0xE1, 0xB8, 0x83, 0x00, 0xE1, 0xB8, 0x85, 0x00, + 0xE1, 0xB8, 0x87, 0x00, 0xE1, 0xB8, 0x89, 0x00, 0xE1, 0xB8, 0x8B, 0x00, + 0xE1, 0xB8, 0x8D, 0x00, 0xE1, 0xB8, 0x8F, 0x00, 0xE1, 0xB8, 0x91, 0x00, + 0xE1, 0xB8, 0x93, 0x00, 0xE1, 0xB8, 0x95, 0x00, 0xE1, 0xB8, 0x97, 0x00, + 0xE1, 0xB8, 0x99, 0x00, 0xE1, 0xB8, 0x9B, 0x00, 0xE1, 0xB8, 0x9D, 0x00, + 0xE1, 0xB8, 0x9F, 0x00, 0xE1, 0xB8, 0xA1, 0x00, 0xE1, 0xB8, 0xA3, 0x00, + 0xE1, 0xB8, 0xA5, 0x00, 0xE1, 0xB8, 0xA7, 0x00, 0xE1, 0xB8, 0xA9, 0x00, + 0xE1, 0xB8, 0xAB, 0x00, 0xE1, 0xB8, 0xAD, 0x00, 0xE1, 0xB8, 0xAF, 0x00, + 0xE1, 0xB8, 0xB1, 0x00, 0xE1, 0xB8, 0xB3, 0x00, 0xE1, 0xB8, 0xB5, 0x00, + 0xE1, 0xB8, 0xB7, 0x00, 0xE1, 0xB8, 0xB9, 0x00, 0xE1, 0xB8, 0xBB, 0x00, + 0xE1, 0xB8, 0xBD, 0x00, 0xE1, 0xB8, 0xBF, 0x00, 0xE1, 0xB9, 0x81, 0x00, + 0xE1, 0xB9, 0x83, 0x00, 0xE1, 0xB9, 0x85, 0x00, 0xE1, 0xB9, 0x87, 0x00, + 0xE1, 0xB9, 0x89, 0x00, 0xE1, 0xB9, 0x8B, 0x00, 0xE1, 0xB9, 0x8D, 0x00, + 0xE1, 0xB9, 0x8F, 0x00, 0xE1, 0xB9, 0x91, 0x00, 0xE1, 0xB9, 0x93, 0x00, + 0xE1, 0xB9, 0x95, 0x00, 0xE1, 0xB9, 0x97, 0x00, 0xE1, 0xB9, 0x99, 0x00, + 0xE1, 0xB9, 0x9B, 0x00, 0xE1, 0xB9, 0x9D, 0x00, 0xE1, 0xB9, 0x9F, 0x00, + 0xE1, 0xB9, 0xA1, 0x00, 0xE1, 0xB9, 0xA3, 0x00, 0xE1, 0xB9, 0xA5, 0x00, + 0xE1, 0xB9, 0xA7, 0x00, 0xE1, 0xB9, 0xA9, 0x00, 0xE1, 0xB9, 0xAB, 0x00, + 0xE1, 0xB9, 0xAD, 0x00, 0xE1, 0xB9, 0xAF, 0x00, 0xE1, 0xB9, 0xB1, 0x00, + 0xE1, 0xB9, 0xB3, 0x00, 0xE1, 0xB9, 0xB5, 0x00, 0xE1, 0xB9, 0xB7, 0x00, + 0xE1, 0xB9, 0xB9, 0x00, 0xE1, 0xB9, 0xBB, 0x00, 0xE1, 0xB9, 0xBD, 0x00, + 0xE1, 0xB9, 0xBF, 0x00, 0xE1, 0xBA, 0x81, 0x00, 0xE1, 0xBA, 0x83, 0x00, + 0xE1, 0xBA, 0x85, 0x00, 0xE1, 0xBA, 0x87, 0x00, 0xE1, 0xBA, 0x89, 0x00, + 0xE1, 0xBA, 0x8B, 0x00, 0xE1, 0xBA, 0x8D, 0x00, 0xE1, 0xBA, 0x8F, 0x00, + 0xE1, 0xBA, 0x91, 0x00, 0xE1, 0xBA, 0x93, 0x00, 0xE1, 0xBA, 0x95, 0x00, + 0x68, 0xCC, 0xB1, 0x00, 0x74, 0xCC, 0x88, 0x00, 0x77, 0xCC, 0x8A, 0x00, + 0x79, 0xCC, 0x8A, 0x00, 0x61, 0xCA, 0xBE, 0x00, 0xE1, 0xB9, 0xA1, 0x00, + 0x73, 0x73, 0xE1, 0xBA, 0xA1, 0x00, 0xE1, 0xBA, 0xA3, 0x00, 0xE1, 0xBA, + 0xA5, 0x00, 0xE1, 0xBA, 0xA7, 0x00, 0xE1, 0xBA, 0xA9, 0x00, 0xE1, 0xBA, + 0xAB, 0x00, 0xE1, 0xBA, 0xAD, 0x00, 0xE1, 0xBA, 0xAF, 0x00, 0xE1, 0xBA, + 0xB1, 0x00, 0xE1, 0xBA, 0xB3, 0x00, 0xE1, 0xBA, 0xB5, 0x00, 0xE1, 0xBA, + 0xB7, 0x00, 0xE1, 0xBA, 0xB9, 0x00, 0xE1, 0xBA, 0xBB, 0x00, 0xE1, 0xBA, + 0xBD, 0x00, 0xE1, 0xBA, 0xBF, 0x00, 0xE1, 0xBB, 0x81, 0x00, 0xE1, 0xBB, + 0x83, 0x00, 0xE1, 0xBB, 0x85, 0x00, 0xE1, 0xBB, 0x87, 0x00, 0xE1, 0xBB, + 0x89, 0x00, 0xE1, 0xBB, 0x8B, 0x00, 0xE1, 0xBB, 0x8D, 0x00, 0xE1, 0xBB, + 0x8F, 0x00, 0xE1, 0xBB, 0x91, 0x00, 0xE1, 0xBB, 0x93, 0x00, 0xE1, 0xBB, + 0x95, 0x00, 0xE1, 0xBB, 0x97, 0x00, 0xE1, 0xBB, 0x99, 0x00, 0xE1, 0xBB, + 0x9B, 0x00, 0xE1, 0xBB, 0x9D, 0x00, 0xE1, 0xBB, 0x9F, 0x00, 0xE1, 0xBB, + 0xA1, 0x00, 0xE1, 0xBB, 0xA3, 0x00, 0xE1, 0xBB, 0xA5, 0x00, 0xE1, 0xBB, + 0xA7, 0x00, 0xE1, 0xBB, 0xA9, 0x00, 0xE1, 0xBB, 0xAB, 0x00, 0xE1, 0xBB, + 0xAD, 0x00, 0xE1, 0xBB, 0xAF, 0x00, 0xE1, 0xBB, 0xB1, 0x00, 0xE1, 0xBB, + 0xB3, 0x00, 0xE1, 0xBB, 0xB5, 0x00, 0xE1, 0xBB, 0xB7, 0x00, 0xE1, 0xBB, + 0xB9, 0x00, 0xE1, 0xBB, 0xBB, 0x00, 0xE1, 0xBB, 0xBD, 0x00, 0xE1, 0xBB, + 0xBF, 0x00, 0xE1, 0xBC, 0x80, 0x00, 0xE1, 0xBC, 0x81, 0x00, 0xE1, 0xBC, + 0x82, 0x00, 0xE1, 0xBC, 0x83, 0x00, 0xE1, 0xBC, 0x84, 0x00, 0xE1, 0xBC, + 0x85, 0x00, 0xE1, 0xBC, 0x86, 0x00, 0xE1, 0xBC, 0x87, 0x00, 0xE1, 0xBC, + 0x90, 0x00, 0xE1, 0xBC, 0x91, 0x00, 0xE1, 0xBC, 0x92, 0x00, 0xE1, 0xBC, + 0x93, 0x00, 0xE1, 0xBC, 0x94, 0x00, 0xE1, 0xBC, 0x95, 0x00, 0xE1, 0xBC, + 0xA0, 0x00, 0xE1, 0xBC, 0xA1, 0x00, 0xE1, 0xBC, 0xA2, 0x00, 0xE1, 0xBC, + 0xA3, 0x00, 0xE1, 0xBC, 0xA4, 0x00, 0xE1, 0xBC, 0xA5, 0x00, 0xE1, 0xBC, + 0xA6, 0x00, 0xE1, 0xBC, 0xA7, 0x00, 0xE1, 0xBC, 0xB0, 0x00, 0xE1, 0xBC, + 0xB1, 0x00, 0xE1, 0xBC, 0xB2, 0x00, 0xE1, 0xBC, 0xB3, 0x00, 0xE1, 0xBC, + 0xB4, 0x00, 0xE1, 0xBC, 0xB5, 0x00, 0xE1, 0xBC, 0xB6, 0x00, 0xE1, 0xBC, + 0xB7, 0x00, 0xE1, 0xBD, 0x80, 0x00, 0xE1, 0xBD, 0x81, 0x00, 0xE1, 0xBD, + 0x82, 0x00, 0xE1, 0xBD, 0x83, 0x00, 0xE1, 0xBD, 0x84, 0x00, 0xE1, 0xBD, + 0x85, 0x00, 0xCF, 0x85, 0xCC, 0x93, 0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x80, + 0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x81, 0xCF, 0x85, 0xCC, 0x93, 0xCD, 0x82, + 0xE1, 0xBD, 0x91, 0x00, 0xE1, 0xBD, 0x93, 0x00, 0xE1, 0xBD, 0x95, 0x00, + 0xE1, 0xBD, 0x97, 0x00, 0xE1, 0xBD, 0xA0, 0x00, 0xE1, 0xBD, 0xA1, 0x00, + 0xE1, 0xBD, 0xA2, 0x00, 0xE1, 0xBD, 0xA3, 0x00, 0xE1, 0xBD, 0xA4, 0x00, + 0xE1, 0xBD, 0xA5, 0x00, 0xE1, 0xBD, 0xA6, 0x00, 0xE1, 0xBD, 0xA7, 0x00, + 0xE1, 0xBC, 0x80, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x81, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0x82, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x83, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0x84, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x85, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0x86, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x87, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0x80, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x81, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0x82, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x83, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0x84, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x85, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0x86, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x87, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0xA0, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA1, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0xA2, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA3, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0xA4, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA5, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0xA6, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA7, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0xA0, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA1, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0xA2, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA3, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0xA4, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA5, 0xCE, 0xB9, 0x00, + 0xE1, 0xBC, 0xA6, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA7, 0xCE, 0xB9, 0x00, + 0xE1, 0xBD, 0xA0, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA1, 0xCE, 0xB9, 0x00, + 0xE1, 0xBD, 0xA2, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA3, 0xCE, 0xB9, 0x00, + 0xE1, 0xBD, 0xA4, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA5, 0xCE, 0xB9, 0x00, + 0xE1, 0xBD, 0xA6, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA7, 0xCE, 0xB9, 0x00, + 0xE1, 0xBD, 0xA0, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA1, 0xCE, 0xB9, 0x00, + 0xE1, 0xBD, 0xA2, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA3, 0xCE, 0xB9, 0x00, + 0xE1, 0xBD, 0xA4, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA5, 0xCE, 0xB9, 0x00, + 0xE1, 0xBD, 0xA6, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA7, 0xCE, 0xB9, 0x00, + 0xE1, 0xBD, 0xB0, 0xCE, 0xB9, 0x00, 0xCE, 0xB1, 0xCE, 0xB9, 0xCE, 0xAC, + 0xCE, 0xB9, 0xCE, 0xB1, 0xCD, 0x82, 0xCE, 0xB1, 0xCD, 0x82, 0xCE, 0xB9, + 0xE1, 0xBE, 0xB0, 0x00, 0xE1, 0xBE, 0xB1, 0x00, 0xE1, 0xBD, 0xB0, 0x00, + 0xE1, 0xBD, 0xB1, 0x00, 0xCE, 0xB1, 0xCE, 0xB9, 0xCE, 0xB9, 0xE1, 0xBD, + 0xB4, 0xCE, 0xB9, 0x00, 0xCE, 0xB7, 0xCE, 0xB9, 0xCE, 0xAE, 0xCE, 0xB9, + 0xCE, 0xB7, 0xCD, 0x82, 0xCE, 0xB7, 0xCD, 0x82, 0xCE, 0xB9, 0xE1, 0xBD, + 0xB2, 0x00, 0xE1, 0xBD, 0xB3, 0x00, 0xE1, 0xBD, 0xB4, 0x00, 0xE1, 0xBD, + 0xB5, 0x00, 0xCE, 0xB7, 0xCE, 0xB9, 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x80, + 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x81, 0xCE, 0xB9, 0xCD, 0x82, 0xCE, 0xB9, + 0xCC, 0x88, 0xCD, 0x82, 0xE1, 0xBF, 0x90, 0x00, 0xE1, 0xBF, 0x91, 0x00, + 0xE1, 0xBD, 0xB6, 0x00, 0xE1, 0xBD, 0xB7, 0x00, 0xCF, 0x85, 0xCC, 0x88, + 0xCC, 0x80, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x81, 0xCF, 0x81, 0xCC, 0x93, + 0xCF, 0x85, 0xCD, 0x82, 0xCF, 0x85, 0xCC, 0x88, 0xCD, 0x82, 0xE1, 0xBF, + 0xA0, 0x00, 0xE1, 0xBF, 0xA1, 0x00, 0xE1, 0xBD, 0xBA, 0x00, 0xE1, 0xBD, + 0xBB, 0x00, 0xE1, 0xBF, 0xA5, 0x00, 0xE1, 0xBD, 0xBC, 0xCE, 0xB9, 0x00, + 0xCF, 0x89, 0xCE, 0xB9, 0xCF, 0x8E, 0xCE, 0xB9, 0xCF, 0x89, 0xCD, 0x82, + 0xCF, 0x89, 0xCD, 0x82, 0xCE, 0xB9, 0xE1, 0xBD, 0xB8, 0x00, 0xE1, 0xBD, + 0xB9, 0x00, 0xE1, 0xBD, 0xBC, 0x00, 0xE1, 0xBD, 0xBD, 0x00, 0xCF, 0x89, + 0xCE, 0xB9, 0xCF, 0x89, 0x6B, 0x00, 0xC3, 0xA5, 0xE2, 0x85, 0x8E, 0x00, + 0xE2, 0x85, 0xB0, 0x00, 0xE2, 0x85, 0xB1, 0x00, 0xE2, 0x85, 0xB2, 0x00, + 0xE2, 0x85, 0xB3, 0x00, 0xE2, 0x85, 0xB4, 0x00, 0xE2, 0x85, 0xB5, 0x00, + 0xE2, 0x85, 0xB6, 0x00, 0xE2, 0x85, 0xB7, 0x00, 0xE2, 0x85, 0xB8, 0x00, + 0xE2, 0x85, 0xB9, 0x00, 0xE2, 0x85, 0xBA, 0x00, 0xE2, 0x85, 0xBB, 0x00, + 0xE2, 0x85, 0xBC, 0x00, 0xE2, 0x85, 0xBD, 0x00, 0xE2, 0x85, 0xBE, 0x00, + 0xE2, 0x85, 0xBF, 0x00, 0xE2, 0x86, 0x84, 0x00, 0xE2, 0x93, 0x90, 0x00, + 0xE2, 0x93, 0x91, 0x00, 0xE2, 0x93, 0x92, 0x00, 0xE2, 0x93, 0x93, 0x00, + 0xE2, 0x93, 0x94, 0x00, 0xE2, 0x93, 0x95, 0x00, 0xE2, 0x93, 0x96, 0x00, + 0xE2, 0x93, 0x97, 0x00, 0xE2, 0x93, 0x98, 0x00, 0xE2, 0x93, 0x99, 0x00, + 0xE2, 0x93, 0x9A, 0x00, 0xE2, 0x93, 0x9B, 0x00, 0xE2, 0x93, 0x9C, 0x00, + 0xE2, 0x93, 0x9D, 0x00, 0xE2, 0x93, 0x9E, 0x00, 0xE2, 0x93, 0x9F, 0x00, + 0xE2, 0x93, 0xA0, 0x00, 0xE2, 0x93, 0xA1, 0x00, 0xE2, 0x93, 0xA2, 0x00, + 0xE2, 0x93, 0xA3, 0x00, 0xE2, 0x93, 0xA4, 0x00, 0xE2, 0x93, 0xA5, 0x00, + 0xE2, 0x93, 0xA6, 0x00, 0xE2, 0x93, 0xA7, 0x00, 0xE2, 0x93, 0xA8, 0x00, + 0xE2, 0x93, 0xA9, 0x00, 0xE2, 0xB0, 0xB0, 0x00, 0xE2, 0xB0, 0xB1, 0x00, + 0xE2, 0xB0, 0xB2, 0x00, 0xE2, 0xB0, 0xB3, 0x00, 0xE2, 0xB0, 0xB4, 0x00, + 0xE2, 0xB0, 0xB5, 0x00, 0xE2, 0xB0, 0xB6, 0x00, 0xE2, 0xB0, 0xB7, 0x00, + 0xE2, 0xB0, 0xB8, 0x00, 0xE2, 0xB0, 0xB9, 0x00, 0xE2, 0xB0, 0xBA, 0x00, + 0xE2, 0xB0, 0xBB, 0x00, 0xE2, 0xB0, 0xBC, 0x00, 0xE2, 0xB0, 0xBD, 0x00, + 0xE2, 0xB0, 0xBE, 0x00, 0xE2, 0xB0, 0xBF, 0x00, 0xE2, 0xB1, 0x80, 0x00, + 0xE2, 0xB1, 0x81, 0x00, 0xE2, 0xB1, 0x82, 0x00, 0xE2, 0xB1, 0x83, 0x00, + 0xE2, 0xB1, 0x84, 0x00, 0xE2, 0xB1, 0x85, 0x00, 0xE2, 0xB1, 0x86, 0x00, + 0xE2, 0xB1, 0x87, 0x00, 0xE2, 0xB1, 0x88, 0x00, 0xE2, 0xB1, 0x89, 0x00, + 0xE2, 0xB1, 0x8A, 0x00, 0xE2, 0xB1, 0x8B, 0x00, 0xE2, 0xB1, 0x8C, 0x00, + 0xE2, 0xB1, 0x8D, 0x00, 0xE2, 0xB1, 0x8E, 0x00, 0xE2, 0xB1, 0x8F, 0x00, + 0xE2, 0xB1, 0x90, 0x00, 0xE2, 0xB1, 0x91, 0x00, 0xE2, 0xB1, 0x92, 0x00, + 0xE2, 0xB1, 0x93, 0x00, 0xE2, 0xB1, 0x94, 0x00, 0xE2, 0xB1, 0x95, 0x00, + 0xE2, 0xB1, 0x96, 0x00, 0xE2, 0xB1, 0x97, 0x00, 0xE2, 0xB1, 0x98, 0x00, + 0xE2, 0xB1, 0x99, 0x00, 0xE2, 0xB1, 0x9A, 0x00, 0xE2, 0xB1, 0x9B, 0x00, + 0xE2, 0xB1, 0x9C, 0x00, 0xE2, 0xB1, 0x9D, 0x00, 0xE2, 0xB1, 0x9E, 0x00, + 0xE2, 0xB1, 0x9F, 0x00, 0xE2, 0xB1, 0xA1, 0x00, 0xC9, 0xAB, 0xE1, 0xB5, + 0xBD, 0x00, 0xC9, 0xBD, 0xE2, 0xB1, 0xA8, 0x00, 0xE2, 0xB1, 0xAA, 0x00, + 0xE2, 0xB1, 0xAC, 0x00, 0xC9, 0x91, 0xC9, 0xB1, 0xC9, 0x90, 0xC9, 0x92, + 0xE2, 0xB1, 0xB3, 0x00, 0xE2, 0xB1, 0xB6, 0x00, 0xC8, 0xBF, 0xC9, 0x80, + 0xE2, 0xB2, 0x81, 0x00, 0xE2, 0xB2, 0x83, 0x00, 0xE2, 0xB2, 0x85, 0x00, + 0xE2, 0xB2, 0x87, 0x00, 0xE2, 0xB2, 0x89, 0x00, 0xE2, 0xB2, 0x8B, 0x00, + 0xE2, 0xB2, 0x8D, 0x00, 0xE2, 0xB2, 0x8F, 0x00, 0xE2, 0xB2, 0x91, 0x00, + 0xE2, 0xB2, 0x93, 0x00, 0xE2, 0xB2, 0x95, 0x00, 0xE2, 0xB2, 0x97, 0x00, + 0xE2, 0xB2, 0x99, 0x00, 0xE2, 0xB2, 0x9B, 0x00, 0xE2, 0xB2, 0x9D, 0x00, + 0xE2, 0xB2, 0x9F, 0x00, 0xE2, 0xB2, 0xA1, 0x00, 0xE2, 0xB2, 0xA3, 0x00, + 0xE2, 0xB2, 0xA5, 0x00, 0xE2, 0xB2, 0xA7, 0x00, 0xE2, 0xB2, 0xA9, 0x00, + 0xE2, 0xB2, 0xAB, 0x00, 0xE2, 0xB2, 0xAD, 0x00, 0xE2, 0xB2, 0xAF, 0x00, + 0xE2, 0xB2, 0xB1, 0x00, 0xE2, 0xB2, 0xB3, 0x00, 0xE2, 0xB2, 0xB5, 0x00, + 0xE2, 0xB2, 0xB7, 0x00, 0xE2, 0xB2, 0xB9, 0x00, 0xE2, 0xB2, 0xBB, 0x00, + 0xE2, 0xB2, 0xBD, 0x00, 0xE2, 0xB2, 0xBF, 0x00, 0xE2, 0xB3, 0x81, 0x00, + 0xE2, 0xB3, 0x83, 0x00, 0xE2, 0xB3, 0x85, 0x00, 0xE2, 0xB3, 0x87, 0x00, + 0xE2, 0xB3, 0x89, 0x00, 0xE2, 0xB3, 0x8B, 0x00, 0xE2, 0xB3, 0x8D, 0x00, + 0xE2, 0xB3, 0x8F, 0x00, 0xE2, 0xB3, 0x91, 0x00, 0xE2, 0xB3, 0x93, 0x00, + 0xE2, 0xB3, 0x95, 0x00, 0xE2, 0xB3, 0x97, 0x00, 0xE2, 0xB3, 0x99, 0x00, + 0xE2, 0xB3, 0x9B, 0x00, 0xE2, 0xB3, 0x9D, 0x00, 0xE2, 0xB3, 0x9F, 0x00, + 0xE2, 0xB3, 0xA1, 0x00, 0xE2, 0xB3, 0xA3, 0x00, 0xE2, 0xB3, 0xAC, 0x00, + 0xE2, 0xB3, 0xAE, 0x00, 0xE2, 0xB3, 0xB3, 0x00, 0xEA, 0x99, 0x81, 0x00, + 0xEA, 0x99, 0x83, 0x00, 0xEA, 0x99, 0x85, 0x00, 0xEA, 0x99, 0x87, 0x00, + 0xEA, 0x99, 0x89, 0x00, 0xEA, 0x99, 0x8B, 0x00, 0xEA, 0x99, 0x8D, 0x00, + 0xEA, 0x99, 0x8F, 0x00, 0xEA, 0x99, 0x91, 0x00, 0xEA, 0x99, 0x93, 0x00, + 0xEA, 0x99, 0x95, 0x00, 0xEA, 0x99, 0x97, 0x00, 0xEA, 0x99, 0x99, 0x00, + 0xEA, 0x99, 0x9B, 0x00, 0xEA, 0x99, 0x9D, 0x00, 0xEA, 0x99, 0x9F, 0x00, + 0xEA, 0x99, 0xA1, 0x00, 0xEA, 0x99, 0xA3, 0x00, 0xEA, 0x99, 0xA5, 0x00, + 0xEA, 0x99, 0xA7, 0x00, 0xEA, 0x99, 0xA9, 0x00, 0xEA, 0x99, 0xAB, 0x00, + 0xEA, 0x99, 0xAD, 0x00, 0xEA, 0x9A, 0x81, 0x00, 0xEA, 0x9A, 0x83, 0x00, + 0xEA, 0x9A, 0x85, 0x00, 0xEA, 0x9A, 0x87, 0x00, 0xEA, 0x9A, 0x89, 0x00, + 0xEA, 0x9A, 0x8B, 0x00, 0xEA, 0x9A, 0x8D, 0x00, 0xEA, 0x9A, 0x8F, 0x00, + 0xEA, 0x9A, 0x91, 0x00, 0xEA, 0x9A, 0x93, 0x00, 0xEA, 0x9A, 0x95, 0x00, + 0xEA, 0x9A, 0x97, 0x00, 0xEA, 0x9A, 0x99, 0x00, 0xEA, 0x9A, 0x9B, 0x00, + 0xEA, 0x9C, 0xA3, 0x00, 0xEA, 0x9C, 0xA5, 0x00, 0xEA, 0x9C, 0xA7, 0x00, + 0xEA, 0x9C, 0xA9, 0x00, 0xEA, 0x9C, 0xAB, 0x00, 0xEA, 0x9C, 0xAD, 0x00, + 0xEA, 0x9C, 0xAF, 0x00, 0xEA, 0x9C, 0xB3, 0x00, 0xEA, 0x9C, 0xB5, 0x00, + 0xEA, 0x9C, 0xB7, 0x00, 0xEA, 0x9C, 0xB9, 0x00, 0xEA, 0x9C, 0xBB, 0x00, + 0xEA, 0x9C, 0xBD, 0x00, 0xEA, 0x9C, 0xBF, 0x00, 0xEA, 0x9D, 0x81, 0x00, + 0xEA, 0x9D, 0x83, 0x00, 0xEA, 0x9D, 0x85, 0x00, 0xEA, 0x9D, 0x87, 0x00, + 0xEA, 0x9D, 0x89, 0x00, 0xEA, 0x9D, 0x8B, 0x00, 0xEA, 0x9D, 0x8D, 0x00, + 0xEA, 0x9D, 0x8F, 0x00, 0xEA, 0x9D, 0x91, 0x00, 0xEA, 0x9D, 0x93, 0x00, + 0xEA, 0x9D, 0x95, 0x00, 0xEA, 0x9D, 0x97, 0x00, 0xEA, 0x9D, 0x99, 0x00, + 0xEA, 0x9D, 0x9B, 0x00, 0xEA, 0x9D, 0x9D, 0x00, 0xEA, 0x9D, 0x9F, 0x00, + 0xEA, 0x9D, 0xA1, 0x00, 0xEA, 0x9D, 0xA3, 0x00, 0xEA, 0x9D, 0xA5, 0x00, + 0xEA, 0x9D, 0xA7, 0x00, 0xEA, 0x9D, 0xA9, 0x00, 0xEA, 0x9D, 0xAB, 0x00, + 0xEA, 0x9D, 0xAD, 0x00, 0xEA, 0x9D, 0xAF, 0x00, 0xEA, 0x9D, 0xBA, 0x00, + 0xEA, 0x9D, 0xBC, 0x00, 0xE1, 0xB5, 0xB9, 0x00, 0xEA, 0x9D, 0xBF, 0x00, + 0xEA, 0x9E, 0x81, 0x00, 0xEA, 0x9E, 0x83, 0x00, 0xEA, 0x9E, 0x85, 0x00, + 0xEA, 0x9E, 0x87, 0x00, 0xEA, 0x9E, 0x8C, 0x00, 0xC9, 0xA5, 0xEA, 0x9E, + 0x91, 0x00, 0xEA, 0x9E, 0x93, 0x00, 0xEA, 0x9E, 0x97, 0x00, 0xEA, 0x9E, + 0x99, 0x00, 0xEA, 0x9E, 0x9B, 0x00, 0xEA, 0x9E, 0x9D, 0x00, 0xEA, 0x9E, + 0x9F, 0x00, 0xEA, 0x9E, 0xA1, 0x00, 0xEA, 0x9E, 0xA3, 0x00, 0xEA, 0x9E, + 0xA5, 0x00, 0xEA, 0x9E, 0xA7, 0x00, 0xEA, 0x9E, 0xA9, 0x00, 0xC9, 0xA6, + 0xC9, 0x9C, 0xC9, 0xA1, 0xC9, 0xAC, 0xC9, 0xAA, 0xCA, 0x9E, 0xCA, 0x87, + 0xCA, 0x9D, 0xEA, 0xAD, 0x93, 0x00, 0xEA, 0x9E, 0xB5, 0x00, 0xEA, 0x9E, + 0xB7, 0x00, 0xEA, 0x9E, 0xB9, 0x00, 0xEA, 0x9E, 0xBB, 0x00, 0xEA, 0x9E, + 0xBD, 0x00, 0xEA, 0x9E, 0xBF, 0x00, 0xEA, 0x9F, 0x81, 0x00, 0xEA, 0x9F, + 0x83, 0x00, 0xEA, 0x9E, 0x94, 0x00, 0xCA, 0x82, 0xE1, 0xB6, 0x8E, 0x00, + 0xEA, 0x9F, 0x88, 0x00, 0xEA, 0x9F, 0x8A, 0x00, 0xC9, 0xA4, 0xEA, 0x9F, + 0x8D, 0x00, 0xEA, 0x9F, 0x8F, 0x00, 0xEA, 0x9F, 0x91, 0x00, 0xEA, 0x9F, + 0x93, 0x00, 0xEA, 0x9F, 0x95, 0x00, 0xEA, 0x9F, 0x97, 0x00, 0xEA, 0x9F, + 0x99, 0x00, 0xEA, 0x9F, 0x9B, 0x00, 0xC6, 0x9B, 0xEA, 0x9F, 0xB6, 0x00, + 0xE1, 0x8E, 0xA0, 0x00, 0xE1, 0x8E, 0xA1, 0x00, 0xE1, 0x8E, 0xA2, 0x00, + 0xE1, 0x8E, 0xA3, 0x00, 0xE1, 0x8E, 0xA4, 0x00, 0xE1, 0x8E, 0xA5, 0x00, + 0xE1, 0x8E, 0xA6, 0x00, 0xE1, 0x8E, 0xA7, 0x00, 0xE1, 0x8E, 0xA8, 0x00, + 0xE1, 0x8E, 0xA9, 0x00, 0xE1, 0x8E, 0xAA, 0x00, 0xE1, 0x8E, 0xAB, 0x00, + 0xE1, 0x8E, 0xAC, 0x00, 0xE1, 0x8E, 0xAD, 0x00, 0xE1, 0x8E, 0xAE, 0x00, + 0xE1, 0x8E, 0xAF, 0x00, 0xE1, 0x8E, 0xB0, 0x00, 0xE1, 0x8E, 0xB1, 0x00, + 0xE1, 0x8E, 0xB2, 0x00, 0xE1, 0x8E, 0xB3, 0x00, 0xE1, 0x8E, 0xB4, 0x00, + 0xE1, 0x8E, 0xB5, 0x00, 0xE1, 0x8E, 0xB6, 0x00, 0xE1, 0x8E, 0xB7, 0x00, + 0xE1, 0x8E, 0xB8, 0x00, 0xE1, 0x8E, 0xB9, 0x00, 0xE1, 0x8E, 0xBA, 0x00, + 0xE1, 0x8E, 0xBB, 0x00, 0xE1, 0x8E, 0xBC, 0x00, 0xE1, 0x8E, 0xBD, 0x00, + 0xE1, 0x8E, 0xBE, 0x00, 0xE1, 0x8E, 0xBF, 0x00, 0xE1, 0x8F, 0x80, 0x00, + 0xE1, 0x8F, 0x81, 0x00, 0xE1, 0x8F, 0x82, 0x00, 0xE1, 0x8F, 0x83, 0x00, + 0xE1, 0x8F, 0x84, 0x00, 0xE1, 0x8F, 0x85, 0x00, 0xE1, 0x8F, 0x86, 0x00, + 0xE1, 0x8F, 0x87, 0x00, 0xE1, 0x8F, 0x88, 0x00, 0xE1, 0x8F, 0x89, 0x00, + 0xE1, 0x8F, 0x8A, 0x00, 0xE1, 0x8F, 0x8B, 0x00, 0xE1, 0x8F, 0x8C, 0x00, + 0xE1, 0x8F, 0x8D, 0x00, 0xE1, 0x8F, 0x8E, 0x00, 0xE1, 0x8F, 0x8F, 0x00, + 0xE1, 0x8F, 0x90, 0x00, 0xE1, 0x8F, 0x91, 0x00, 0xE1, 0x8F, 0x92, 0x00, + 0xE1, 0x8F, 0x93, 0x00, 0xE1, 0x8F, 0x94, 0x00, 0xE1, 0x8F, 0x95, 0x00, + 0xE1, 0x8F, 0x96, 0x00, 0xE1, 0x8F, 0x97, 0x00, 0xE1, 0x8F, 0x98, 0x00, + 0xE1, 0x8F, 0x99, 0x00, 0xE1, 0x8F, 0x9A, 0x00, 0xE1, 0x8F, 0x9B, 0x00, + 0xE1, 0x8F, 0x9C, 0x00, 0xE1, 0x8F, 0x9D, 0x00, 0xE1, 0x8F, 0x9E, 0x00, + 0xE1, 0x8F, 0x9F, 0x00, 0xE1, 0x8F, 0xA0, 0x00, 0xE1, 0x8F, 0xA1, 0x00, + 0xE1, 0x8F, 0xA2, 0x00, 0xE1, 0x8F, 0xA3, 0x00, 0xE1, 0x8F, 0xA4, 0x00, + 0xE1, 0x8F, 0xA5, 0x00, 0xE1, 0x8F, 0xA6, 0x00, 0xE1, 0x8F, 0xA7, 0x00, + 0xE1, 0x8F, 0xA8, 0x00, 0xE1, 0x8F, 0xA9, 0x00, 0xE1, 0x8F, 0xAA, 0x00, + 0xE1, 0x8F, 0xAB, 0x00, 0xE1, 0x8F, 0xAC, 0x00, 0xE1, 0x8F, 0xAD, 0x00, + 0xE1, 0x8F, 0xAE, 0x00, 0xE1, 0x8F, 0xAF, 0x00, 0x66, 0x66, 0x66, 0x69, + 0x66, 0x6C, 0x66, 0x66, 0x69, 0x00, 0x66, 0x66, 0x6C, 0x00, 0x73, 0x74, + 0x73, 0x74, 0xD5, 0xB4, 0xD5, 0xB6, 0xD5, 0xB4, 0xD5, 0xA5, 0xD5, 0xB4, + 0xD5, 0xAB, 0xD5, 0xBE, 0xD5, 0xB6, 0xD5, 0xB4, 0xD5, 0xAD, 0xEF, 0xBD, + 0x81, 0x00, 0xEF, 0xBD, 0x82, 0x00, 0xEF, 0xBD, 0x83, 0x00, 0xEF, 0xBD, + 0x84, 0x00, 0xEF, 0xBD, 0x85, 0x00, 0xEF, 0xBD, 0x86, 0x00, 0xEF, 0xBD, + 0x87, 0x00, 0xEF, 0xBD, 0x88, 0x00, 0xEF, 0xBD, 0x89, 0x00, 0xEF, 0xBD, + 0x8A, 0x00, 0xEF, 0xBD, 0x8B, 0x00, 0xEF, 0xBD, 0x8C, 0x00, 0xEF, 0xBD, + 0x8D, 0x00, 0xEF, 0xBD, 0x8E, 0x00, 0xEF, 0xBD, 0x8F, 0x00, 0xEF, 0xBD, + 0x90, 0x00, 0xEF, 0xBD, 0x91, 0x00, 0xEF, 0xBD, 0x92, 0x00, 0xEF, 0xBD, + 0x93, 0x00, 0xEF, 0xBD, 0x94, 0x00, 0xEF, 0xBD, 0x95, 0x00, 0xEF, 0xBD, + 0x96, 0x00, 0xEF, 0xBD, 0x97, 0x00, 0xEF, 0xBD, 0x98, 0x00, 0xEF, 0xBD, + 0x99, 0x00, 0xEF, 0xBD, 0x9A, 0x00, 0xF0, 0x90, 0x90, 0xA8, 0xF0, 0x90, + 0x90, 0xA9, 0xF0, 0x90, 0x90, 0xAA, 0xF0, 0x90, 0x90, 0xAB, 0xF0, 0x90, + 0x90, 0xAC, 0xF0, 0x90, 0x90, 0xAD, 0xF0, 0x90, 0x90, 0xAE, 0xF0, 0x90, + 0x90, 0xAF, 0xF0, 0x90, 0x90, 0xB0, 0xF0, 0x90, 0x90, 0xB1, 0xF0, 0x90, + 0x90, 0xB2, 0xF0, 0x90, 0x90, 0xB3, 0xF0, 0x90, 0x90, 0xB4, 0xF0, 0x90, + 0x90, 0xB5, 0xF0, 0x90, 0x90, 0xB6, 0xF0, 0x90, 0x90, 0xB7, 0xF0, 0x90, + 0x90, 0xB8, 0xF0, 0x90, 0x90, 0xB9, 0xF0, 0x90, 0x90, 0xBA, 0xF0, 0x90, + 0x90, 0xBB, 0xF0, 0x90, 0x90, 0xBC, 0xF0, 0x90, 0x90, 0xBD, 0xF0, 0x90, + 0x90, 0xBE, 0xF0, 0x90, 0x90, 0xBF, 0xF0, 0x90, 0x91, 0x80, 0xF0, 0x90, + 0x91, 0x81, 0xF0, 0x90, 0x91, 0x82, 0xF0, 0x90, 0x91, 0x83, 0xF0, 0x90, + 0x91, 0x84, 0xF0, 0x90, 0x91, 0x85, 0xF0, 0x90, 0x91, 0x86, 0xF0, 0x90, + 0x91, 0x87, 0xF0, 0x90, 0x91, 0x88, 0xF0, 0x90, 0x91, 0x89, 0xF0, 0x90, + 0x91, 0x8A, 0xF0, 0x90, 0x91, 0x8B, 0xF0, 0x90, 0x91, 0x8C, 0xF0, 0x90, + 0x91, 0x8D, 0xF0, 0x90, 0x91, 0x8E, 0xF0, 0x90, 0x91, 0x8F, 0xF0, 0x90, + 0x93, 0x98, 0xF0, 0x90, 0x93, 0x99, 0xF0, 0x90, 0x93, 0x9A, 0xF0, 0x90, + 0x93, 0x9B, 0xF0, 0x90, 0x93, 0x9C, 0xF0, 0x90, 0x93, 0x9D, 0xF0, 0x90, + 0x93, 0x9E, 0xF0, 0x90, 0x93, 0x9F, 0xF0, 0x90, 0x93, 0xA0, 0xF0, 0x90, + 0x93, 0xA1, 0xF0, 0x90, 0x93, 0xA2, 0xF0, 0x90, 0x93, 0xA3, 0xF0, 0x90, + 0x93, 0xA4, 0xF0, 0x90, 0x93, 0xA5, 0xF0, 0x90, 0x93, 0xA6, 0xF0, 0x90, + 0x93, 0xA7, 0xF0, 0x90, 0x93, 0xA8, 0xF0, 0x90, 0x93, 0xA9, 0xF0, 0x90, + 0x93, 0xAA, 0xF0, 0x90, 0x93, 0xAB, 0xF0, 0x90, 0x93, 0xAC, 0xF0, 0x90, + 0x93, 0xAD, 0xF0, 0x90, 0x93, 0xAE, 0xF0, 0x90, 0x93, 0xAF, 0xF0, 0x90, + 0x93, 0xB0, 0xF0, 0x90, 0x93, 0xB1, 0xF0, 0x90, 0x93, 0xB2, 0xF0, 0x90, + 0x93, 0xB3, 0xF0, 0x90, 0x93, 0xB4, 0xF0, 0x90, 0x93, 0xB5, 0xF0, 0x90, + 0x93, 0xB6, 0xF0, 0x90, 0x93, 0xB7, 0xF0, 0x90, 0x93, 0xB8, 0xF0, 0x90, + 0x93, 0xB9, 0xF0, 0x90, 0x93, 0xBA, 0xF0, 0x90, 0x93, 0xBB, 0xF0, 0x90, + 0x96, 0x97, 0xF0, 0x90, 0x96, 0x98, 0xF0, 0x90, 0x96, 0x99, 0xF0, 0x90, + 0x96, 0x9A, 0xF0, 0x90, 0x96, 0x9B, 0xF0, 0x90, 0x96, 0x9C, 0xF0, 0x90, + 0x96, 0x9D, 0xF0, 0x90, 0x96, 0x9E, 0xF0, 0x90, 0x96, 0x9F, 0xF0, 0x90, + 0x96, 0xA0, 0xF0, 0x90, 0x96, 0xA1, 0xF0, 0x90, 0x96, 0xA3, 0xF0, 0x90, + 0x96, 0xA4, 0xF0, 0x90, 0x96, 0xA5, 0xF0, 0x90, 0x96, 0xA6, 0xF0, 0x90, + 0x96, 0xA7, 0xF0, 0x90, 0x96, 0xA8, 0xF0, 0x90, 0x96, 0xA9, 0xF0, 0x90, + 0x96, 0xAA, 0xF0, 0x90, 0x96, 0xAB, 0xF0, 0x90, 0x96, 0xAC, 0xF0, 0x90, + 0x96, 0xAD, 0xF0, 0x90, 0x96, 0xAE, 0xF0, 0x90, 0x96, 0xAF, 0xF0, 0x90, + 0x96, 0xB0, 0xF0, 0x90, 0x96, 0xB1, 0xF0, 0x90, 0x96, 0xB3, 0xF0, 0x90, + 0x96, 0xB4, 0xF0, 0x90, 0x96, 0xB5, 0xF0, 0x90, 0x96, 0xB6, 0xF0, 0x90, + 0x96, 0xB7, 0xF0, 0x90, 0x96, 0xB8, 0xF0, 0x90, 0x96, 0xB9, 0xF0, 0x90, + 0x96, 0xBB, 0xF0, 0x90, 0x96, 0xBC, 0xF0, 0x90, 0xB3, 0x80, 0xF0, 0x90, + 0xB3, 0x81, 0xF0, 0x90, 0xB3, 0x82, 0xF0, 0x90, 0xB3, 0x83, 0xF0, 0x90, + 0xB3, 0x84, 0xF0, 0x90, 0xB3, 0x85, 0xF0, 0x90, 0xB3, 0x86, 0xF0, 0x90, + 0xB3, 0x87, 0xF0, 0x90, 0xB3, 0x88, 0xF0, 0x90, 0xB3, 0x89, 0xF0, 0x90, + 0xB3, 0x8A, 0xF0, 0x90, 0xB3, 0x8B, 0xF0, 0x90, 0xB3, 0x8C, 0xF0, 0x90, + 0xB3, 0x8D, 0xF0, 0x90, 0xB3, 0x8E, 0xF0, 0x90, 0xB3, 0x8F, 0xF0, 0x90, + 0xB3, 0x90, 0xF0, 0x90, 0xB3, 0x91, 0xF0, 0x90, 0xB3, 0x92, 0xF0, 0x90, + 0xB3, 0x93, 0xF0, 0x90, 0xB3, 0x94, 0xF0, 0x90, 0xB3, 0x95, 0xF0, 0x90, + 0xB3, 0x96, 0xF0, 0x90, 0xB3, 0x97, 0xF0, 0x90, 0xB3, 0x98, 0xF0, 0x90, + 0xB3, 0x99, 0xF0, 0x90, 0xB3, 0x9A, 0xF0, 0x90, 0xB3, 0x9B, 0xF0, 0x90, + 0xB3, 0x9C, 0xF0, 0x90, 0xB3, 0x9D, 0xF0, 0x90, 0xB3, 0x9E, 0xF0, 0x90, + 0xB3, 0x9F, 0xF0, 0x90, 0xB3, 0xA0, 0xF0, 0x90, 0xB3, 0xA1, 0xF0, 0x90, + 0xB3, 0xA2, 0xF0, 0x90, 0xB3, 0xA3, 0xF0, 0x90, 0xB3, 0xA4, 0xF0, 0x90, + 0xB3, 0xA5, 0xF0, 0x90, 0xB3, 0xA6, 0xF0, 0x90, 0xB3, 0xA7, 0xF0, 0x90, + 0xB3, 0xA8, 0xF0, 0x90, 0xB3, 0xA9, 0xF0, 0x90, 0xB3, 0xAA, 0xF0, 0x90, + 0xB3, 0xAB, 0xF0, 0x90, 0xB3, 0xAC, 0xF0, 0x90, 0xB3, 0xAD, 0xF0, 0x90, + 0xB3, 0xAE, 0xF0, 0x90, 0xB3, 0xAF, 0xF0, 0x90, 0xB3, 0xB0, 0xF0, 0x90, + 0xB3, 0xB1, 0xF0, 0x90, 0xB3, 0xB2, 0xF0, 0x90, 0xB5, 0xB0, 0xF0, 0x90, + 0xB5, 0xB1, 0xF0, 0x90, 0xB5, 0xB2, 0xF0, 0x90, 0xB5, 0xB3, 0xF0, 0x90, + 0xB5, 0xB4, 0xF0, 0x90, 0xB5, 0xB5, 0xF0, 0x90, 0xB5, 0xB6, 0xF0, 0x90, + 0xB5, 0xB7, 0xF0, 0x90, 0xB5, 0xB8, 0xF0, 0x90, 0xB5, 0xB9, 0xF0, 0x90, + 0xB5, 0xBA, 0xF0, 0x90, 0xB5, 0xBB, 0xF0, 0x90, 0xB5, 0xBC, 0xF0, 0x90, + 0xB5, 0xBD, 0xF0, 0x90, 0xB5, 0xBE, 0xF0, 0x90, 0xB5, 0xBF, 0xF0, 0x90, + 0xB6, 0x80, 0xF0, 0x90, 0xB6, 0x81, 0xF0, 0x90, 0xB6, 0x82, 0xF0, 0x90, + 0xB6, 0x83, 0xF0, 0x90, 0xB6, 0x84, 0xF0, 0x90, 0xB6, 0x85, 0xF0, 0x91, + 0xA3, 0x80, 0xF0, 0x91, 0xA3, 0x81, 0xF0, 0x91, 0xA3, 0x82, 0xF0, 0x91, + 0xA3, 0x83, 0xF0, 0x91, 0xA3, 0x84, 0xF0, 0x91, 0xA3, 0x85, 0xF0, 0x91, + 0xA3, 0x86, 0xF0, 0x91, 0xA3, 0x87, 0xF0, 0x91, 0xA3, 0x88, 0xF0, 0x91, + 0xA3, 0x89, 0xF0, 0x91, 0xA3, 0x8A, 0xF0, 0x91, 0xA3, 0x8B, 0xF0, 0x91, + 0xA3, 0x8C, 0xF0, 0x91, 0xA3, 0x8D, 0xF0, 0x91, 0xA3, 0x8E, 0xF0, 0x91, + 0xA3, 0x8F, 0xF0, 0x91, 0xA3, 0x90, 0xF0, 0x91, 0xA3, 0x91, 0xF0, 0x91, + 0xA3, 0x92, 0xF0, 0x91, 0xA3, 0x93, 0xF0, 0x91, 0xA3, 0x94, 0xF0, 0x91, + 0xA3, 0x95, 0xF0, 0x91, 0xA3, 0x96, 0xF0, 0x91, 0xA3, 0x97, 0xF0, 0x91, + 0xA3, 0x98, 0xF0, 0x91, 0xA3, 0x99, 0xF0, 0x91, 0xA3, 0x9A, 0xF0, 0x91, + 0xA3, 0x9B, 0xF0, 0x91, 0xA3, 0x9C, 0xF0, 0x91, 0xA3, 0x9D, 0xF0, 0x91, + 0xA3, 0x9E, 0xF0, 0x91, 0xA3, 0x9F, 0xF0, 0x96, 0xB9, 0xA0, 0xF0, 0x96, + 0xB9, 0xA1, 0xF0, 0x96, 0xB9, 0xA2, 0xF0, 0x96, 0xB9, 0xA3, 0xF0, 0x96, + 0xB9, 0xA4, 0xF0, 0x96, 0xB9, 0xA5, 0xF0, 0x96, 0xB9, 0xA6, 0xF0, 0x96, + 0xB9, 0xA7, 0xF0, 0x96, 0xB9, 0xA8, 0xF0, 0x96, 0xB9, 0xA9, 0xF0, 0x96, + 0xB9, 0xAA, 0xF0, 0x96, 0xB9, 0xAB, 0xF0, 0x96, 0xB9, 0xAC, 0xF0, 0x96, + 0xB9, 0xAD, 0xF0, 0x96, 0xB9, 0xAE, 0xF0, 0x96, 0xB9, 0xAF, 0xF0, 0x96, + 0xB9, 0xB0, 0xF0, 0x96, 0xB9, 0xB1, 0xF0, 0x96, 0xB9, 0xB2, 0xF0, 0x96, + 0xB9, 0xB3, 0xF0, 0x96, 0xB9, 0xB4, 0xF0, 0x96, 0xB9, 0xB5, 0xF0, 0x96, + 0xB9, 0xB6, 0xF0, 0x96, 0xB9, 0xB7, 0xF0, 0x96, 0xB9, 0xB8, 0xF0, 0x96, + 0xB9, 0xB9, 0xF0, 0x96, 0xB9, 0xBA, 0xF0, 0x96, 0xB9, 0xBB, 0xF0, 0x96, + 0xB9, 0xBC, 0xF0, 0x96, 0xB9, 0xBD, 0xF0, 0x96, 0xB9, 0xBE, 0xF0, 0x96, + 0xB9, 0xBF, 0xF0, 0x96, 0xBA, 0xBB, 0xF0, 0x96, 0xBA, 0xBC, 0xF0, 0x96, + 0xBA, 0xBD, 0xF0, 0x96, 0xBA, 0xBE, 0xF0, 0x96, 0xBA, 0xBF, 0xF0, 0x96, + 0xBB, 0x80, 0xF0, 0x96, 0xBB, 0x81, 0xF0, 0x96, 0xBB, 0x82, 0xF0, 0x96, + 0xBB, 0x83, 0xF0, 0x96, 0xBB, 0x84, 0xF0, 0x96, 0xBB, 0x85, 0xF0, 0x96, + 0xBB, 0x86, 0xF0, 0x96, 0xBB, 0x87, 0xF0, 0x96, 0xBB, 0x88, 0xF0, 0x96, + 0xBB, 0x89, 0xF0, 0x96, 0xBB, 0x8A, 0xF0, 0x96, 0xBB, 0x8B, 0xF0, 0x96, + 0xBB, 0x8C, 0xF0, 0x96, 0xBB, 0x8D, 0xF0, 0x96, 0xBB, 0x8E, 0xF0, 0x96, + 0xBB, 0x8F, 0xF0, 0x96, 0xBB, 0x90, 0xF0, 0x96, 0xBB, 0x91, 0xF0, 0x96, + 0xBB, 0x92, 0xF0, 0x96, 0xBB, 0x93, 0xF0, 0x9E, 0xA4, 0xA2, 0xF0, 0x9E, + 0xA4, 0xA3, 0xF0, 0x9E, 0xA4, 0xA4, 0xF0, 0x9E, 0xA4, 0xA5, 0xF0, 0x9E, + 0xA4, 0xA6, 0xF0, 0x9E, 0xA4, 0xA7, 0xF0, 0x9E, 0xA4, 0xA8, 0xF0, 0x9E, + 0xA4, 0xA9, 0xF0, 0x9E, 0xA4, 0xAA, 0xF0, 0x9E, 0xA4, 0xAB, 0xF0, 0x9E, + 0xA4, 0xAC, 0xF0, 0x9E, 0xA4, 0xAD, 0xF0, 0x9E, 0xA4, 0xAE, 0xF0, 0x9E, + 0xA4, 0xAF, 0xF0, 0x9E, 0xA4, 0xB0, 0xF0, 0x9E, 0xA4, 0xB1, 0xF0, 0x9E, + 0xA4, 0xB2, 0xF0, 0x9E, 0xA4, 0xB3, 0xF0, 0x9E, 0xA4, 0xB4, 0xF0, 0x9E, + 0xA4, 0xB5, 0xF0, 0x9E, 0xA4, 0xB6, 0xF0, 0x9E, 0xA4, 0xB7, 0xF0, 0x9E, + 0xA4, 0xB8, 0xF0, 0x9E, 0xA4, 0xB9, 0xF0, 0x9E, 0xA4, 0xBA, 0xF0, 0x9E, + 0xA4, 0xBB, 0xF0, 0x9E, 0xA4, 0xBC, 0xF0, 0x9E, 0xA4, 0xBD, 0xF0, 0x9E, + 0xA4, 0xBE, 0xF0, 0x9E, 0xA4, 0xBF, 0xF0, 0x9E, 0xA5, 0x80, 0xF0, 0x9E, + 0xA5, 0x81, 0xF0, 0x9E, 0xA5, 0x82, 0xF0, 0x9E, 0xA5, 0x83 +}; diff --git a/cmark/src/chunk.h b/cmark/src/chunk.h new file mode 100644 index 0000000000..54c28f8b82 --- /dev/null +++ b/cmark/src/chunk.h @@ -0,0 +1,69 @@ +#ifndef CMARK_CHUNK_H +#define CMARK_CHUNK_H + +#include <string.h> +#include <stdlib.h> +#include <assert.h> +#include "cmark.h" +#include "buffer.h" +#include "cmark_ctype.h" + +#define CMARK_CHUNK_EMPTY \ + { NULL, 0 } + +typedef struct { + const unsigned char *data; + bufsize_t len; +} cmark_chunk; + +// NOLINTNEXTLINE(clang-diagnostic-unused-function) +static inline void cmark_chunk_free(cmark_chunk *c) { + c->data = NULL; + c->len = 0; +} + +static inline void cmark_chunk_ltrim(cmark_chunk *c) { + 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--; + } +} + +// NOLINTNEXTLINE(clang-diagnostic-unused-function) +static inline void cmark_chunk_trim(cmark_chunk *c) { + cmark_chunk_ltrim(c); + cmark_chunk_rtrim(c); +} + +// NOLINTNEXTLINE(clang-diagnostic-unused-function) +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; +} + +// NOLINTNEXTLINE(clang-diagnostic-unused-function) +static inline cmark_chunk cmark_chunk_literal(const char *data) { + bufsize_t len = data ? (bufsize_t)strlen(data) : 0; + cmark_chunk c = {(unsigned char *)data, len}; + return c; +} + +// NOLINTNEXTLINE(clang-diagnostic-unused-function) +static inline cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, bufsize_t pos, + bufsize_t len) { + cmark_chunk c = {ch->data + pos, len}; + return c; +} + +#endif diff --git a/cmark/src/cmark.c b/cmark/src/cmark.c new file mode 100644 index 0000000000..60aedbc6f1 --- /dev/null +++ b/cmark/src/cmark.c @@ -0,0 +1,48 @@ +#include <stdlib.h> +#include <assert.h> +#include <stdio.h> +#include "node.h" +#include "houdini.h" +#include "cmark.h" +#include "buffer.h" + +int cmark_version(void) { return CMARK_VERSION; } + +const char *cmark_version_string(void) { return CMARK_VERSION_STRING; } + +static void *xcalloc(size_t nmem, size_t size) { + void *ptr = calloc(nmem, size); + 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) { + fprintf(stderr, "[cmark] realloc returned null pointer, aborting\n"); + abort(); + } + return new_ptr; +} + +cmark_mem DEFAULT_MEM_ALLOCATOR = {xcalloc, xrealloc, free}; + +cmark_mem *cmark_get_default_mem_allocator(void) { + return &DEFAULT_MEM_ALLOCATOR; +} + + +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); + + result = cmark_render_html(doc, options); + cmark_node_free(doc); + + return result; +} diff --git a/cmark/src/cmark.h b/cmark/src/cmark.h new file mode 100644 index 0000000000..6626b06273 --- /dev/null +++ b/cmark/src/cmark.h @@ -0,0 +1,704 @@ +#ifndef CMARK_H +#define CMARK_H + +#include <stdio.h> +#include <stdbool.h> +#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. 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); + +/** ## 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_BLOCK, + CMARK_NODE_CUSTOM_BLOCK, + CMARK_NODE_PARAGRAPH, + CMARK_NODE_HEADING, + CMARK_NODE_THEMATIC_BREAK, + + CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT, + CMARK_NODE_LAST_BLOCK = CMARK_NODE_THEMATIC_BREAK, + + /* Inline */ + CMARK_NODE_TEXT, + CMARK_NODE_SOFTBREAK, + CMARK_NODE_LINEBREAK, + CMARK_NODE_CODE, + CMARK_NODE_HTML_INLINE, + CMARK_NODE_CUSTOM_INLINE, + 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; + +/* 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, + 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; + +/** + * ## 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; + +/** Returns a pointer to the default memory allocator. + */ +CMARK_EXPORT cmark_mem *cmark_get_default_mem_allocator(void); + +/** + * ## Classifying nodes + */ + +/** Returns true if the node is a block node. + */ +CMARK_EXPORT bool cmark_node_is_block(cmark_node *node); + +/** Returns true if the node is an inline node. + */ +CMARK_EXPORT bool cmark_node_is_inline(cmark_node *node); + +/** Returns true if the node is a leaf node (a node that cannot + contain children). + */ +CMARK_EXPORT bool cmark_node_is_leaf(cmark_node *node); + +/** + * ## 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); + +/** 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); + +/** + * ## 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 headings 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_BLOCK + * * CMARK_NODE_THEMATIC_BREAK + * * CMARK_NODE_CODE_BLOCK + * * CMARK_NODE_TEXT + * * CMARK_NODE_SOFTBREAK + * * CMARK_NODE_LINEBREAK + * * CMARK_NODE_CODE + * * CMARK_NODE_HTML_INLINE + * + * Nodes must only be modified after an `EXIT` event, or an `ENTER` event for + * 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. + * 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); + +/** 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 `"<unknown>"`. + */ +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. Returns NULL if called on a + node that does not have string content. + */ +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 heading level of 'node', or 0 if 'node' is not a heading. + */ +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 heading level of 'node', returning 1 on success and 0 on error. + */ +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. + */ +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. + */ +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); + +/** Returns the URL of a link or image 'node', or an empty string + 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); + +/** 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); + +/** Returns the title of a link or image 'node', or an empty + 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); + +/** 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 literal "on enter" text for a custom 'node', or + 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); + +/** 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. Returns NULL if + called on a non-custom node. + */ +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); + +/** 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); + +/** 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. + */ +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*", 13, + * CMARK_OPT_DEFAULT); + * + * Streaming interface: + * + * cmark_parser *parser = cmark_parser_new(CMARK_OPT_DEFAULT); + * 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)) { + * break; + * } + * } + * document = cmark_parser_finish(parser); + * cmark_parser_free(parser); + */ + +/** Creates a new parser object. + */ +CMARK_EXPORT +cmark_parser *cmark_parser_new(int options); + +/** Creates a new parser object with the given memory allocator + * + * A generalization of `cmark_parser_new`: + * ```c + * cmark_parser_new(options) + * ``` + * is the same as: + * ```c + * cmark_parser_new_with_mem(options, cmark_get_default_mem_allocator()) + * ``` + */ +CMARK_EXPORT +cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem); + +/** Creates a new parser object with the given node to use as the root + * node of the parsed AST. + * + * When parsing, children are always appended, not prepended; that means + * if `root` already has children, the newly-parsed children will appear + * after the given children. + * + * A generalization of `cmark_parser_new_with_mem`: + * ```c + * cmark_parser_new_with_mem(options, mem) + * ``` + * is approximately the same as: + * ```c + * cmark_parser_new_with_mem_into_root(options, mem, cmark_node_new(CMARK_NODE_DOCUMENT)) + * ``` + * + * This is useful for creating a single document out of multiple parsed + * document fragments. + */ +CMARK_EXPORT +cmark_parser *cmark_parser_new_with_mem_into_root( + int options, cmark_mem *mem, cmark_node *root); + +/** 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. 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. 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); + +/** + * ## Rendering + */ + +/** 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. 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); + +/** + * ## 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 << 1) + +/** Render `softbreak` elements as hard line breaks. + */ +#define CMARK_OPT_HARDBREAKS (1 << 2) + +/** `CMARK_OPT_SAFE` is defined here for API compatibility, + but it no longer has any effect. "Safe" mode is now the default: + set `CMARK_OPT_UNSAFE` to disable it. + */ +#define CMARK_OPT_SAFE (1 << 3) + +/** Render raw HTML and unsafe links (`javascript:`, `vbscript:`, + * `file:`, and `data:`, except for `image/png`, `image/gif`, + * `image/jpeg`, or `image/webp` mime types). By default, + * raw HTML is replaced by a placeholder HTML comment. Unsafe + * links are replaced by empty strings. + */ +#define CMARK_OPT_UNSAFE (1 << 17) + +/** Render `softbreak` elements as spaces. + */ +#define CMARK_OPT_NOBREAKS (1 << 4) + +/** + * ### Options affecting parsing + */ + +/** Legacy option (no effect). + */ +#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 (1 << 9) + +/** Convert straight quotes to curly, `---` to em dashes, `--` to en dashes. + */ +#define CMARK_OPT_SMART (1 << 10) + +/** + * ## 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 +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(void); + +/** # 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_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_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 +#define NODE_IMAGE CMARK_NODE_IMAGE +#define BULLET_LIST CMARK_BULLET_LIST +#define ORDERED_LIST CMARK_ORDERED_LIST +#define PERIOD_DELIM CMARK_PERIOD_DELIM +#define PAREN_DELIM CMARK_PAREN_DELIM +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/src/cmarkConfig.cmake.in b/cmark/src/cmarkConfig.cmake.in new file mode 100644 index 0000000000..3d865ff3f5 --- /dev/null +++ b/cmark/src/cmarkConfig.cmake.in @@ -0,0 +1,4 @@ +@PACKAGE_INIT@ + +include("${CMAKE_CURRENT_LIST_DIR}/cmark-targets.cmake") +check_required_components("cmark") diff --git a/cmark/src/cmark_ctype.c b/cmark/src/cmark_ctype.c new file mode 100644 index 0000000000..6280f0a424 --- /dev/null +++ b/cmark/src/cmark_ctype.c @@ -0,0 +1,38 @@ +#include <stdint.h> + +#include "cmark_ctype.h" + +/** 1 = space, 2 = punct, 3 = digit, 4 = alpha, 0 = other + */ +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, 1, 1, 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[(uint8_t)c] == 1; } + +/** + * Returns 1 if c is an ascii punctuation character. + */ +int cmark_ispunct(char c) { return cmark_ctype_class[(uint8_t)c] == 2; } + +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/src/cmark_ctype.h b/cmark/src/cmark_ctype.h new file mode 100644 index 0000000000..3ed63defda --- /dev/null +++ b/cmark/src/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_isdigit(char c); + +int cmark_isalpha(char c); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/src/cmark_version.h.in b/cmark/src/cmark_version.h.in new file mode 100644 index 0000000000..41de3ac675 --- /dev/null +++ b/cmark/src/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/cmark/src/commonmark.c b/cmark/src/commonmark.c new file mode 100644 index 0000000000..ad805a630e --- /dev/null +++ b/cmark/src/commonmark.c @@ -0,0 +1,473 @@ +#include <assert.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "utf8.h" +#include "scanners.h" +#include "render.h" + +#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) +#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, + int32_t c, unsigned char nextc) { + bool needs_escaping = false; + bool follows_digit = + renderer->buffer->size > 0 && + cmark_isdigit(renderer->buffer->ptr[renderer->buffer->size - 1]); + char encoded[ENCODED_SIZE]; + int options = renderer->options; + + needs_escaping = + c < 0x80 && escape != LITERAL && + ((escape == NORMAL && + (c < 0x20 || + c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' || + c == '>' || c == '\\' || c == '`' || + (c == '!' && (!nextc || nextc == '[')) || + (c == '&' && cmark_isalpha(nextc)) || (c == '!' && nextc == '[') || + ((CMARK_OPT_SMART & options) && + ((c == '-' && nextc == '-') || + (c == '.' && nextc == '.') || + c == '"' || c == '\'')) || + (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 == '>' || cmark_isspace(c) || c == '\\' || + c == ')' || c == '(')) || + (escape == TITLE && + (c == '`' || c == '<' || c == '>' || c == '"' || c == '\\'))); + + if (needs_escaping) { + if (escape == URL && cmark_isspace(c)) { + // use percent encoding for spaces + snprintf(encoded, ENCODED_SIZE, "%%%2X", c); + cmark_strbuf_puts(renderer->buffer, encoded); + renderer->column += 3; + } else if (cmark_ispunct(c)) { + cmark_render_ascii(renderer, "\\"); + cmark_render_code_point(renderer, c); + } else { // render as entity + snprintf(encoded, ENCODED_SIZE, "&#%d;", c); + cmark_strbuf_puts(renderer->buffer, encoded); + renderer->column += (int)strlen(encoded); + } + } 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 = 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) { + // 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); + while (i <= code_len) { + if (code[i] == '`') { + current++; + } else { + if (current > 0 && current < 32) { + used |= (1U << current); + } + current = 0; + } + i++; + } + // return number of first bit that is 0: + i = 0; + while (i < 32 && used & 1) { + used = used >> 1; + i++; + } + return (int)i; +} + +static bool is_autolink(cmark_node *node) { + const unsigned char *title; + const unsigned char *url; + cmark_node *link_text; + + if (node->type != CMARK_NODE_LINK) { + return false; + } + + url = node->as.link.url; + if (url == NULL || _scan_scheme(url) == 0) { + return false; + } + + title = node->as.link.title; + // if it has a title, we can't treat it as an autolink: + if (title && title[0]) { + return false; + } + + link_text = node->first_child; + if (link_text == NULL) { + return false; + } + cmark_consolidate_text_nodes(link_text); + if (strncmp((const char *)url, "mailto:", 7) == 0) { + url += 7; + } + return link_text->data != NULL && + strcmp((const char *)url, (char *)link_text->data) == 0; +} + +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; + size_t numticks; + bool extra_spaces; + size_t i; + bool entering = (ev_type == CMARK_EVENT_ENTER); + const char *info, *code, *title; + char fencechar[2] = {'\0', '\0'}; + size_t code_len; + char listmarker[LISTMARKER_SIZE]; + const char *emph_delim; + bool first_in_list_item; + bufsize_t marker_width; + bool has_nonspace; + 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 lose the blank line between a paragraph and + // a following list. + if (entering) { + if (node->parent && node->parent->type == CMARK_NODE_ITEM) { + renderer->in_tight_list_item = node->parent->parent->as.list.tight; + } + } else { + if (node->type == CMARK_NODE_LIST) { + renderer->in_tight_list_item = + node->parent && + node->parent->type == CMARK_NODE_ITEM && + node->parent->parent->as.list.tight; + } + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + 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); + BLANKLINE(); + } + break; + + case CMARK_NODE_LIST: + if (!entering && node->next && (node->next->type == CMARK_NODE_LIST)) { + // this ensures that a following indented code block or list will be + // inteprereted correctly. + CR(); + LIT("<!-- end list -->"); + BLANKLINE(); + } + break; + + case CMARK_NODE_ITEM: + if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { + marker_width = 4; + } 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, LISTMARKER_SIZE, "%d%s%s", list_number, + list_delim == CMARK_PAREN_DELIM ? ")" : ".", + list_number < 10 ? " " : " "); + marker_width = (bufsize_t)strlen(listmarker); + } + if (entering) { + if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { + LIT(" - "); + renderer->begin_content = true; + } else { + LIT(listmarker); + renderer->begin_content = true; + } + if (node->first_child == NULL) { + BLANKLINE(); + } else { + 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_HEADING: + if (entering) { + for (i = cmark_node_get_heading_level(node); i > 0; i--) { + LIT("#"); + } + LIT(" "); + renderer->begin_content = true; + renderer->no_linebreaks = true; + } else { + renderer->no_linebreaks = false; + BLANKLINE(); + } + break; + + case CMARK_NODE_CODE_BLOCK: + + 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); + fencechar[0] = strchr(info, '`') == NULL ? '`' : '~'; + code = cmark_node_get_literal(node); + + numticks = longest_backtick_sequence(code) + 1; + if (numticks < 3) { + numticks = 3; + } + for (i = 0; i < numticks; i++) { + LIT(fencechar); + } + LIT(" "); + OUT(info, false, LITERAL); + CR(); + OUT(cmark_node_get_literal(node), false, LITERAL); + CR(); + for (i = 0; i < numticks; i++) { + LIT(fencechar); + } + + BLANKLINE(); + break; + + case CMARK_NODE_HTML_BLOCK: + BLANKLINE(); + OUT(cmark_node_get_literal(node), false, LITERAL); + BLANKLINE(); + break; + + 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(); + break; + + case CMARK_NODE_PARAGRAPH: + if (!entering) { + BLANKLINE(); + } + break; + + case CMARK_NODE_TEXT: + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + if (!(CMARK_OPT_HARDBREAKS & options)) { + LIT(" "); + } + CR(); + break; + + case CMARK_NODE_SOFTBREAK: + 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(" ", allow_wrap, LITERAL); + } + break; + + case CMARK_NODE_CODE: + code = cmark_node_get_literal(node); + code_len = strlen(code); + numticks = shortest_unused_backtick_sequence(code); + has_nonspace = false; + for (i=0; i < code_len; i++) { + if (code[i] != ' ') { + has_nonspace = true; + break; + } + } + extra_spaces = code_len == 0 || + code[0] == '`' || code[code_len - 1] == '`' || + (has_nonspace && code[0] == ' ' && code[code_len - 1] == ' '); + for (i = 0; i < numticks; i++) { + LIT("`"); + } + if (extra_spaces) { + LIT(" "); + } + OUT(cmark_node_get_literal(node), allow_wrap, LITERAL); + if (extra_spaces) { + LIT(" "); + } + for (i = 0; i < numticks; i++) { + LIT("`"); + } + break; + + 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("**"); + } 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((const char *)cmark_node_get_url(node) + 7); + } else { + LIT((const 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 (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 (strlen(title) > 0) { + OUT(" \"", allow_wrap, 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); +} diff --git a/cmark/src/entities.inc b/cmark/src/entities.inc new file mode 100644 index 0000000000..e80d9aa9a4 --- /dev/null +++ b/cmark/src/entities.inc @@ -0,0 +1,2054 @@ +/* Autogenerated by tools/make_headers_inc.py */ + +#define ENT_MIN_LENGTH 2 +#define ENT_MAX_LENGTH 32 +#define ENT_TABLE_SIZE 2125 +#define ENT_TEXT_IDX(x) ((x) & 0x7FFF) +#define ENT_NAME_SIZE(x) (((x) >> 15) & 0x1F) +#define ENT_REPL_SIZE(x) ((x) >> 20) + +static const uint32_t cmark_entities[2125] = { + 0x228000, 0x118007, 0x23000B, 0x230013, 0x22801B, 0x218022, + 0x418027, 0x23002E, 0x228036, 0x22803D, 0x318044, 0x22804A, + 0x420051, 0x368059, 0x228069, 0x420070, 0x330078, 0x230081, + 0x220089, 0x34808F, 0x32009B, 0x3300A2, 0x2180AB, 0x3380B0, + 0x3500BA, 0x2200C7, 0x4180CD, 0x4200D4, 0x2280DC, 0x3200E3, + 0x3300EA, 0x2200F3, 0x2200F9, 0x2300FF, 0x318107, 0x3A010D, + 0x338124, 0x23012E, 0x230136, 0x22813E, 0x338145, 0x22014F, + 0x238155, 0x24815E, 0x318169, 0x21816F, 0x348174, 0x358180, + 0x35018E, 0x35819B, 0x3C01A9, 0x3A81C4, 0x3781DC, 0x3281EE, + 0x3301F6, 0x3481FF, 0x33020B, 0x378214, 0x320226, 0x34822D, + 0x3F8239, 0x32825B, 0x420263, 0x31826B, 0x330271, 0x31027A, + 0x34027F, 0x22028A, 0x220290, 0x220296, 0x33029C, 0x3202A5, + 0x3282AC, 0x2302B4, 0x2182BC, 0x3182C1, 0x2282C7, 0x4182CE, + 0x2802D5, 0x2702E7, 0x2B02F7, 0x18030F, 0x280320, 0x338332, + 0x36833C, 0x42034C, 0x218354, 0x330359, 0x340362, 0x3A836D, + 0x248385, 0x378390, 0x3783A2, 0x3A03B4, 0x3683CB, 0x3983DB, + 0x3C03F1, 0x3A040C, 0x380423, 0x370436, 0x368447, 0x388457, + 0x38846B, 0x34847F, 0x36048B, 0x38049A, 0x2484AD, 0x3984B8, + 0x3884CE, 0x3704E2, 0x3884F3, 0x390507, 0x37851C, 0x39052E, + 0x338543, 0x36054D, 0x34855C, 0x420568, 0x230570, 0x218578, + 0x21857D, 0x230582, 0x23058A, 0x228592, 0x218599, 0x22059E, + 0x4185A4, 0x2305AB, 0x3385B3, 0x2285BD, 0x3805C4, 0x3A05D7, + 0x2285EE, 0x4205F5, 0x2385FD, 0x328606, 0x35060E, 0x35861B, + 0x320629, 0x320630, 0x218637, 0x22063C, 0x330642, 0x36064B, + 0x21865A, 0x41865F, 0x388666, 0x3A867A, 0x420692, 0x33069A, + 0x3506A3, 0x3206B0, 0x2206B7, 0x1106BD, 0x2286C0, 0x2306C7, + 0x2306CF, 0x2306D7, 0x2286DF, 0x2186E6, 0x2206EB, 0x4186F1, + 0x3106F8, 0x4206FD, 0x360705, 0x380714, 0x380727, 0x37073A, + 0x35874B, 0x388759, 0x36076D, 0x42077C, 0x310784, 0x230789, + 0x228791, 0x118798, 0x22879C, 0x3187A3, 0x3607A9, 0x3207B8, + 0x3707BF, 0x3207D0, 0x2307D7, 0x3607DF, 0x3487EE, 0x2207FA, + 0x228800, 0x220807, 0x23080D, 0x228815, 0x21881C, 0x220821, + 0x318827, 0x23082D, 0x310835, 0x22883A, 0x350841, 0x33884E, + 0x318858, 0x34085E, 0x360869, 0x370878, 0x370889, 0x22889A, + 0x4208A1, 0x2208A9, 0x3208AF, 0x2308B6, 0x2288BE, 0x2208C5, + 0x2288CB, 0x2188D2, 0x4188D7, 0x4208DE, 0x4208E6, 0x2308EE, + 0x2288F6, 0x2208FD, 0x220903, 0x228909, 0x230910, 0x218918, + 0x41891D, 0x420924, 0x42092C, 0x220934, 0x11093A, 0x23093D, + 0x230945, 0x32094D, 0x350954, 0x320961, 0x230968, 0x230970, + 0x218978, 0x38097D, 0x348990, 0x36099C, 0x3989AB, 0x3589C1, + 0x3889CF, 0x3889E3, 0x3709F7, 0x388A08, 0x348A1C, 0x370A28, + 0x378A39, 0x338A4B, 0x360A55, 0x368A64, 0x360A74, 0x378A83, + 0x388A95, 0x380AA9, 0x378ABC, 0x360ACE, 0x378ADD, 0x350AEF, + 0x368AFC, 0x348B0C, 0x370B18, 0x380B29, 0x368B3C, 0x358B4C, + 0x340B5A, 0x370B65, 0x348B76, 0x418B82, 0x310B89, 0x350B8E, + 0x230B9B, 0x368BA3, 0x390BB3, 0x370BC8, 0x368BD9, 0x390BE9, + 0x370BFE, 0x420C0F, 0x370C17, 0x378C28, 0x320C3A, 0x318C41, + 0x230C47, 0x310C4F, 0x318C54, 0x218C5A, 0x358C5F, 0x348C6D, + 0x418C79, 0x348C80, 0x420C8C, 0x320C94, 0x210C9B, 0x220C9F, + 0x230CA5, 0x230CAD, 0x230CB5, 0x218CBD, 0x398CC2, 0x390CD8, + 0x388CED, 0x3A8D01, 0x3A0D19, 0x370D30, 0x138D41, 0x418D49, + 0x338D50, 0x280D5A, 0x320D6C, 0x318D73, 0x360D79, 0x348D88, + 0x3A0D94, 0x350DAB, 0x340DB8, 0x568DC3, 0x348DD5, 0x350DE1, + 0x378DEE, 0x598E00, 0x588E18, 0x370E2E, 0x5A0E3F, 0x378E58, + 0x578E6A, 0x560E7E, 0x378E8F, 0x590EA1, 0x3A0EB8, 0x338ECF, + 0x360ED9, 0x370EE8, 0x558EF9, 0x588F09, 0x360F1F, 0x5B8F2E, + 0x588F4A, 0x358F60, 0x580F6E, 0x3A8F83, 0x388F9B, 0x380FAF, + 0x598FC2, 0x3A8FDA, 0x578FF2, 0x3A1006, 0x58901D, 0x3B1033, + 0x64904C, 0x37105B, 0x35906C, 0x58107A, 0x3A908F, 0x5810A7, + 0x6590BC, 0x3810CD, 0x3410E0, 0x3690EB, 0x3890FB, 0x36910F, + 0x37111F, 0x421130, 0x231138, 0x211140, 0x229144, 0x23114B, + 0x229153, 0x21915A, 0x23115F, 0x419167, 0x23116E, 0x229176, + 0x22917D, 0x239184, 0x42118D, 0x3A1195, 0x3711AC, 0x3111BD, + 0x4211C2, 0x2311CA, 0x2311D2, 0x3311DA, 0x2211E3, 0x3391E9, + 0x3491F3, 0x3591FF, 0x37920D, 0x34121F, 0x21922A, 0x41922F, + 0x219236, 0x21123B, 0x24923F, 0x36924A, 0x32125A, 0x311261, + 0x341266, 0x369271, 0x391281, 0x369296, 0x3292A6, 0x3392AE, + 0x3512B8, 0x3612C5, 0x4212D4, 0x2192DC, 0x1212E1, 0x4192E6, + 0x3212ED, 0x4212F4, 0x3292FC, 0x219304, 0x231309, 0x321311, + 0x321318, 0x33131F, 0x231328, 0x231330, 0x219338, 0x31133D, + 0x371342, 0x391353, 0x3A1368, 0x31937F, 0x219385, 0x38938A, + 0x35139E, 0x3693AB, 0x3993BB, 0x3613D1, 0x3913E0, 0x3913F5, + 0x37940A, 0x39141C, 0x351431, 0x34143E, 0x369449, 0x371459, + 0x36946A, 0x38147A, 0x39148D, 0x3894A2, 0x3814B6, 0x3694C9, + 0x3814D9, 0x3594EC, 0x3714FA, 0x35150B, 0x321518, 0x36151F, + 0x35952E, 0x32153C, 0x319543, 0x359549, 0x231557, 0x22155F, + 0x231565, 0x23156D, 0x311575, 0x23157A, 0x231582, 0x22958A, + 0x219591, 0x419596, 0x37159D, 0x3715AE, 0x3795BF, 0x3615D1, + 0x2295E0, 0x3595E7, 0x4215F5, 0x3215FD, 0x331604, 0x39160D, + 0x361622, 0x389631, 0x371645, 0x399656, 0x35966C, 0x42167A, + 0x321682, 0x319689, 0x33168F, 0x359698, 0x3416A6, 0x3696B1, + 0x3916C1, 0x3696D6, 0x3416E6, 0x3196F1, 0x3196F7, 0x3416FD, + 0x369708, 0x331718, 0x229721, 0x329728, 0x229730, 0x221737, + 0x11973D, 0x219741, 0x231746, 0x23174E, 0x219756, 0x41975B, + 0x349762, 0x22976E, 0x651775, 0x349785, 0x329791, 0x351799, + 0x3717A6, 0x3517B7, 0x4217C4, 0x3497CC, 0x4217D8, 0x2317E0, + 0x2317E8, 0x3217F0, 0x3417F7, 0x229802, 0x231809, 0x229811, + 0x219818, 0x23181D, 0x419825, 0x23182C, 0x229834, 0x14183B, + 0x351844, 0x361851, 0x381860, 0x329873, 0x34987B, 0x229887, + 0x42188E, 0x339896, 0x3518A0, 0x3818AD, 0x3598C0, 0x3698CE, + 0x3298DE, 0x3518E6, 0x3398F3, 0x3598FD, 0x37190B, 0x37991C, + 0x22192E, 0x239934, 0x22993D, 0x421944, 0x23194C, 0x221954, + 0x32995A, 0x321962, 0x219969, 0x32996E, 0x331976, 0x31997F, + 0x331985, 0x32198E, 0x359995, 0x1619A3, 0x3899B0, 0x3699C4, + 0x3699D4, 0x4199E4, 0x4219EB, 0x4219F3, 0x3319FB, 0x229A04, + 0x329A0B, 0x419A13, 0x421A1A, 0x421A22, 0x419A2A, 0x211A31, + 0x421A35, 0x421A3D, 0x221A45, 0x221A4B, 0x221A51, 0x231A57, + 0x229A5F, 0x219A66, 0x419A6B, 0x421A72, 0x421A7A, 0x221A82, + 0x221A88, 0x231A8E, 0x231A96, 0x219A9E, 0x221AA3, 0x371AA9, + 0x221ABA, 0x319AC0, 0x321AC6, 0x421ACD, 0x231AD5, 0x231ADD, + 0x311AE5, 0x519AEA, 0x319AF2, 0x229AF8, 0x229AFF, 0x219B06, + 0x229B0B, 0x311B12, 0x419B17, 0x231B1E, 0x339B26, 0x329B30, + 0x229B38, 0x229B3F, 0x329B46, 0x119B4E, 0x319B52, 0x331B58, + 0x321B61, 0x341B68, 0x321B73, 0x319B7A, 0x321B80, 0x329B87, + 0x331B8F, 0x341B98, 0x341BA3, 0x341BAE, 0x341BB9, 0x341BC4, + 0x341BCF, 0x341BDA, 0x341BE5, 0x329BF0, 0x339BF8, 0x341C02, + 0x331C0D, 0x229C16, 0x339C1D, 0x229C27, 0x421C2E, 0x311C36, + 0x319C3B, 0x331C41, 0x319C4A, 0x321C50, 0x121C57, 0x331C5C, + 0x341C65, 0x229C70, 0x421C77, 0x119C7F, 0x329C83, 0x339C8B, + 0x231C95, 0x221C9D, 0x341CA3, 0x329CAE, 0x321CB6, 0x341CBD, + 0x259CC8, 0x349CD5, 0x339CE1, 0x349CEB, 0x331CF7, 0x331D00, + 0x341D09, 0x321D14, 0x341D1B, 0x329D26, 0x219D2E, 0x329D33, + 0x331D3B, 0x339D44, 0x339D4E, 0x229D58, 0x331D5F, 0x221D68, + 0x321D6E, 0x339D75, 0x419D7F, 0x331D86, 0x339D8F, 0x331D99, + 0x339DA2, 0x341DAC, 0x349DB7, 0x341DC3, 0x339DCE, 0x379DD8, + 0x369DEA, 0x341DFA, 0x331E05, 0x341E0E, 0x331E19, 0x361E22, + 0x359E31, 0x369E3F, 0x389E4F, 0x389E63, 0x391E77, 0x329E8C, + 0x329E94, 0x329E9C, 0x329EA4, 0x329EAC, 0x419EB4, 0x639EBB, + 0x321EC8, 0x421ECF, 0x319ED7, 0x331EDD, 0x331EE6, 0x329EEF, + 0x329EF7, 0x329EFF, 0x329F07, 0x321F0F, 0x329F16, 0x329F1E, + 0x329F26, 0x329F2E, 0x329F36, 0x329F3E, 0x329F46, 0x329F4E, + 0x321F56, 0x329F5D, 0x329F65, 0x329F6D, 0x329F75, 0x329F7D, + 0x329F85, 0x331F8D, 0x329F96, 0x329F9E, 0x329FA6, 0x329FAE, + 0x321FB6, 0x329FBD, 0x329FC5, 0x329FCD, 0x329FD5, 0x341FDD, + 0x339FE8, 0x341FF2, 0x329FFD, 0x32A005, 0x32A00D, 0x32A015, + 0x32201D, 0x32A024, 0x32A02C, 0x32A034, 0x32A03C, 0x32A044, + 0x32A04C, 0x332054, 0x22A05D, 0x232064, 0x42206C, 0x32A074, + 0x32207C, 0x32A083, 0x12208B, 0x32A090, 0x342098, 0x3220A3, + 0x3320AA, 0x3220B3, 0x32A0BA, 0x32A0C2, 0x3320CA, 0x2320D3, + 0x31A0DB, 0x3320E1, 0x3420EA, 0x3320F5, 0x3320FE, 0x332107, + 0x622110, 0x32A11A, 0x22A122, 0x32A129, 0x232131, 0x232139, + 0x22A141, 0x32A148, 0x33A150, 0x22215A, 0x22A160, 0x33A167, + 0x222171, 0x24A177, 0x41A182, 0x222189, 0x32A18F, 0x34A197, + 0x21A1A3, 0x31A1A8, 0x3221AE, 0x2221B5, 0x3321BB, 0x37A1C4, + 0x3821D6, 0x2421E9, 0x3421F3, 0x3521FE, 0x35A20B, 0x35A219, + 0x322227, 0x34222E, 0x332239, 0x33A242, 0x32A24C, 0x342254, + 0x12A25F, 0x332265, 0x33A26E, 0x12A278, 0x13227E, 0x322285, + 0x33228C, 0x352295, 0x34A2A2, 0x3222AE, 0x33A2B5, 0x3322BF, + 0x4222C8, 0x3322D0, 0x2222D9, 0x3322DF, 0x32A2E8, 0x32A2F0, + 0x4222F8, 0x322300, 0x32A307, 0x32230F, 0x32A316, 0x32A31E, + 0x33A326, 0x33A330, 0x32A33A, 0x32A342, 0x33234A, 0x33A353, + 0x31A35D, 0x342363, 0x33236E, 0x332377, 0x332380, 0x32A389, + 0x622391, 0x33239B, 0x33A3A4, 0x35A3AE, 0x35A3BC, 0x3423CA, + 0x3523D5, 0x2323E2, 0x3723EA, 0x37A3FB, 0x32A40D, 0x32A415, + 0x34241D, 0x32A428, 0x332430, 0x322439, 0x322440, 0x332447, + 0x332450, 0x322459, 0x322460, 0x32A467, 0x33A46F, 0x22A479, + 0x232480, 0x21A488, 0x31248D, 0x33A492, 0x32A49C, 0x33A4A4, + 0x21A4AE, 0x22A4B3, 0x33A4BA, 0x3324C4, 0x41A4CD, 0x32A4D4, + 0x32A4DC, 0x3224E4, 0x33A4EB, 0x35A4F5, 0x32A503, 0x21A50B, + 0x23A510, 0x32A519, 0x21A521, 0x232526, 0x36A52E, 0x33253E, + 0x222547, 0x33254D, 0x332556, 0x13255F, 0x422566, 0x21A56E, + 0x32A573, 0x34257B, 0x342586, 0x33A591, 0x34A59B, 0x3725A7, + 0x34A5B8, 0x3725C4, 0x37A5D5, 0x3825E7, 0x3425FA, 0x332605, + 0x33260E, 0x422617, 0x22261F, 0x322625, 0x23262C, 0x32A634, + 0x32263C, 0x32A643, 0x32A64B, 0x32A653, 0x33A65B, 0x222665, + 0x34266B, 0x32A676, 0x32267E, 0x232685, 0x33268D, 0x232696, + 0x32269E, 0x22A6A5, 0x3326AC, 0x21A6B5, 0x2226BA, 0x3126C0, + 0x32A6C5, 0x41A6CD, 0x3126D4, 0x2326D9, 0x31A6E1, 0x3326E7, + 0x3126F0, 0x3426F5, 0x31A700, 0x31A706, 0x33270C, 0x22A715, + 0x32A71C, 0x342724, 0x33272F, 0x322738, 0x33273F, 0x332748, + 0x21A751, 0x322756, 0x22A75D, 0x422764, 0x32276C, 0x332773, + 0x32A77C, 0x222784, 0x23A78A, 0x22A793, 0x33279A, 0x33A7A3, + 0x32A7AD, 0x3527B5, 0x35A7C2, 0x1327D0, 0x3327D7, 0x32A7E0, + 0x33A7E8, 0x3427F2, 0x32A7FD, 0x32A805, 0x32280D, 0x32A814, + 0x32281C, 0x21A823, 0x21A828, 0x22282D, 0x322833, 0x12283A, + 0x32A83F, 0x35A847, 0x362855, 0x36A864, 0x21A874, 0x332879, + 0x332882, 0x32A88B, 0x332893, 0x41A89C, 0x32A8A3, 0x22A8AB, + 0x3228B2, 0x32A8B9, 0x32A8C1, 0x2228C9, 0x4228CF, 0x3328D7, + 0x3228E0, 0x32A8E7, 0x3428EF, 0x2328FA, 0x332902, 0x23290B, + 0x332913, 0x33291C, 0x332925, 0x33292E, 0x332937, 0x232940, + 0x332948, 0x332951, 0x33295A, 0x332963, 0x33296C, 0x332975, + 0x32A97E, 0x32A986, 0x42298E, 0x312996, 0x31A99B, 0x2329A1, + 0x22A9A9, 0x2329B0, 0x31A9B8, 0x2329BE, 0x22A9C6, 0x21A9CD, + 0x2229D2, 0x3129D8, 0x31A9DD, 0x31A9E3, 0x3229E9, 0x3429F0, + 0x31A9FB, 0x32AA01, 0x332A09, 0x33AA12, 0x342A1C, 0x622A27, + 0x332A31, 0x41AA3A, 0x312A41, 0x31AA46, 0x32AA4C, 0x222A54, + 0x312A5A, 0x31AA5F, 0x31AA65, 0x31AA6B, 0x31AA71, 0x322A77, + 0x342A7E, 0x31AA89, 0x322A8F, 0x32AA96, 0x32AA9E, 0x422AA6, + 0x12AAAE, 0x322AB4, 0x322ABB, 0x32AAC2, 0x32AACA, 0x112AD2, + 0x322AD5, 0x32AADC, 0x32AAE4, 0x332AEC, 0x33AAF5, 0x34AAFF, + 0x332B0B, 0x332B14, 0x34AB1D, 0x352B29, 0x33AB36, 0x332B40, + 0x64AB49, 0x622B58, 0x322B62, 0x332B69, 0x222B72, 0x332B78, + 0x232B81, 0x322B89, 0x33AB90, 0x32AB9A, 0x322BA2, 0x22ABA9, + 0x332BB0, 0x34ABB9, 0x332BC5, 0x332BCE, 0x41ABD7, 0x342BDE, + 0x342BE9, 0x32ABF4, 0x332BFC, 0x36AC05, 0x372C15, 0x422C26, + 0x332C2E, 0x422C37, 0x332C3F, 0x232C48, 0x332C50, 0x332C59, + 0x232C62, 0x312C6A, 0x22AC6F, 0x21AC76, 0x222C7B, 0x22AC81, + 0x31AC88, 0x41AC8E, 0x232C95, 0x312C9D, 0x332CA2, 0x32ACAB, + 0x332CB3, 0x32ACBC, 0x22ACC4, 0x22ACCB, 0x32ACD2, 0x342CDA, + 0x342CE5, 0x22ACF0, 0x322CF7, 0x22ACFE, 0x312D05, 0x332D0A, + 0x32AD13, 0x342D1B, 0x232D26, 0x31AD2E, 0x332D34, 0x342D3D, + 0x342D48, 0x342D53, 0x33AD5E, 0x222D68, 0x22AD6E, 0x422D75, + 0x222D7D, 0x32AD83, 0x232D8B, 0x422D93, 0x322D9B, 0x32ADA2, + 0x33ADAA, 0x32ADB4, 0x332DBC, 0x32ADC5, 0x312DCD, 0x232DD2, + 0x22ADDA, 0x222DE1, 0x22ADE7, 0x21ADEE, 0x41ADF3, 0x22ADFA, + 0x422E01, 0x422E09, 0x232E11, 0x22AE19, 0x22AE20, 0x232E27, + 0x232E2F, 0x21AE37, 0x41AE3C, 0x232E43, 0x222E4B, 0x222E51, + 0x422E57, 0x422E5F, 0x32AE67, 0x322E6F, 0x332E76, 0x32AE7F, + 0x312E87, 0x31AE8C, 0x322E92, 0x232E99, 0x342EA1, 0x332EAC, + 0x232EB5, 0x322EBD, 0x32AEC4, 0x332ECC, 0x31AED5, 0x22AEDB, + 0x322EE2, 0x32AEE9, 0x33AEF1, 0x332EFB, 0x332F04, 0x332F0D, + 0x332F16, 0x33AF1F, 0x332F29, 0x31AF32, 0x332F38, 0x322F41, + 0x62AF48, 0x32AF53, 0x32AF5B, 0x132F63, 0x132F6A, 0x32AF71, + 0x33AF79, 0x33AF83, 0x232F8D, 0x232F95, 0x32AF9D, 0x122FA5, + 0x21AFAA, 0x322FAF, 0x32AFB6, 0x332FBE, 0x33AFC7, 0x342FD1, + 0x322FDC, 0x312FE3, 0x34AFE8, 0x36AFF4, 0x37B004, 0x36B016, + 0x373026, 0x373037, 0x37B048, 0x38B05A, 0x39B06E, 0x373084, + 0x31B095, 0x31B09B, 0x3230A1, 0x3430A8, 0x31B0B3, 0x32B0B9, + 0x3330C1, 0x33B0CA, 0x3430D4, 0x6230DF, 0x3330E9, 0x3530F2, + 0x33B0FF, 0x34B109, 0x353115, 0x33B122, 0x33B12C, 0x333136, + 0x33313F, 0x41B148, 0x31314F, 0x31B154, 0x32B15A, 0x32B162, + 0x33316A, 0x32B173, 0x22317B, 0x313181, 0x32B186, 0x34318E, + 0x333199, 0x32B1A2, 0x2331AA, 0x3331B2, 0x3531BB, 0x31B1C8, + 0x3231CE, 0x3431D5, 0x31B1E0, 0x3231E6, 0x32B1ED, 0x32B1F5, + 0x32B1FD, 0x32B205, 0x32B20D, 0x36B215, 0x393225, 0x35323A, + 0x373247, 0x36B258, 0x373268, 0x32B279, 0x423281, 0x333289, + 0x33B292, 0x33329C, 0x1332A5, 0x31B2AC, 0x33B2B2, 0x3232BC, + 0x1232C3, 0x3332C8, 0x32B2D1, 0x3432D9, 0x32B2E4, 0x3332EC, + 0x31B2F5, 0x32B2FB, 0x333303, 0x42330C, 0x31B314, 0x32331A, + 0x32B321, 0x32B329, 0x123331, 0x32B336, 0x33333E, 0x233347, + 0x11334F, 0x323352, 0x32B359, 0x32B361, 0x333369, 0x333372, + 0x33337B, 0x33B384, 0x33338E, 0x323397, 0x32B39E, 0x32B3A6, + 0x3433AE, 0x33B3B9, 0x64B3C3, 0x6233D2, 0x32B3DC, 0x2233E4, + 0x3233EA, 0x3233F1, 0x33B3F8, 0x31B402, 0x333408, 0x353411, + 0x35341E, 0x34342B, 0x333436, 0x33343F, 0x21B448, 0x32B44D, + 0x36B455, 0x41B465, 0x31B46C, 0x22B472, 0x31B479, 0x13347F, + 0x333486, 0x23348F, 0x32B497, 0x33349F, 0x3334A8, 0x33B4B1, + 0x3234BB, 0x3234C2, 0x3334C9, 0x3334D2, 0x4234DB, 0x3134E3, + 0x4234E8, 0x3334F0, 0x2134F9, 0x3434FD, 0x32B508, 0x51B510, + 0x61B518, 0x523521, 0x35352A, 0x37B537, 0x51B549, 0x61B551, + 0x52355A, 0x35B563, 0x333571, 0x33357A, 0x32B583, 0x23358B, + 0x623593, 0x31B59D, 0x5235A3, 0x52B5AC, 0x22B5B6, 0x33B5BD, + 0x32B5C7, 0x33B5CF, 0x3435D9, 0x2235E4, 0x52B5EA, 0x5335F4, + 0x3235FF, 0x233606, 0x23360E, 0x32B616, 0x54361E, 0x32362B, + 0x21B632, 0x32B637, 0x31363F, 0x32B644, 0x33364C, 0x32B655, + 0x33B65D, 0x52B667, 0x333671, 0x33367A, 0x52B683, 0x33368D, + 0x33B696, 0x41B6A0, 0x51B6A7, 0x31B6AF, 0x3236B5, 0x52B6BC, + 0x54B6C6, 0x5236D4, 0x32B6DD, 0x31B6E5, 0x3236EB, 0x32B6F2, + 0x32B6FA, 0x32B702, 0x31370A, 0x31B70F, 0x323715, 0x31B71C, + 0x223722, 0x32B728, 0x51B730, 0x32B738, 0x323740, 0x31B747, + 0x35374D, 0x37B75A, 0x32376C, 0x52B773, 0x54B77D, 0x52378B, + 0x32B794, 0x32B79C, 0x31B7A4, 0x32B7AA, 0x3337B2, 0x3237BB, + 0x4237C2, 0x21B7CA, 0x32B7CF, 0x5337D7, 0x5437E2, 0x33B7EF, + 0x33B7F9, 0x33B803, 0x32B80D, 0x33B815, 0x33B81F, 0x33B829, + 0x323833, 0x34B83A, 0x633846, 0x52B852, 0x33B85C, 0x31B866, + 0x33386C, 0x523875, 0x32B87E, 0x53B886, 0x32B892, 0x32B89A, + 0x5338A2, 0x5338AD, 0x35B8B8, 0x32B8C6, 0x3338CE, 0x31B8D7, + 0x3338DD, 0x5238E6, 0x4238EF, 0x34B8F7, 0x373903, 0x323914, + 0x32B91B, 0x333923, 0x32B92C, 0x32B934, 0x33B93C, 0x33B946, + 0x323950, 0x52B957, 0x32B961, 0x63B969, 0x34B976, 0x553982, + 0x32B991, 0x53B999, 0x3239A5, 0x52B9AC, 0x32B9B6, 0x63B9BE, + 0x34B9CB, 0x5539D7, 0x3239E6, 0x2339ED, 0x3239F5, 0x36B9FC, + 0x37BA0C, 0x373A1E, 0x383A2F, 0x213A42, 0x11BA46, 0x333A4A, + 0x32BA53, 0x333A5B, 0x333A64, 0x623A6D, 0x333A77, 0x623A80, + 0x423A8A, 0x33BA92, 0x333A9C, 0x623AA5, 0x423AAF, 0x63BAB7, + 0x333AC4, 0x63BACD, 0x62BADA, 0x32BAE5, 0x333AED, 0x32BAF6, + 0x33BAFE, 0x333B08, 0x313B11, 0x233B16, 0x323B1E, 0x323B25, + 0x22BB2C, 0x21BB33, 0x32BB38, 0x233B40, 0x323B48, 0x323B4F, + 0x333B56, 0x22BB5F, 0x32BB66, 0x41BB6E, 0x223B75, 0x233B7B, + 0x31BB83, 0x32BB89, 0x21BB91, 0x323B96, 0x32BB9D, 0x32BBA5, + 0x33BBAD, 0x32BBB7, 0x31BBBF, 0x22BBC5, 0x22BBCC, 0x23BBD3, + 0x323BDC, 0x333BE3, 0x423BEC, 0x323BF4, 0x32BBFB, 0x32BC03, + 0x313C0B, 0x32BC10, 0x31BC18, 0x32BC1E, 0x33BC26, 0x223C30, + 0x223C36, 0x333C3C, 0x323C45, 0x33BC4C, 0x31BC56, 0x323C5C, + 0x233C63, 0x323C6B, 0x233C72, 0x333C7A, 0x343C83, 0x223C8E, + 0x32BC94, 0x31BC9C, 0x223CA2, 0x343CA8, 0x333CB3, 0x32BCBC, + 0x323CC4, 0x21BCCB, 0x133CD0, 0x133CD7, 0x333CDE, 0x323CE7, + 0x33BCEE, 0x41BCF8, 0x21BCFF, 0x223D04, 0x333D0A, 0x32BD13, + 0x213D1B, 0x34BD1F, 0x21BD2B, 0x333D30, 0x33BD39, 0x333D43, + 0x123D4C, 0x343D51, 0x32BD5C, 0x33BD64, 0x333D6E, 0x333D77, + 0x32BD80, 0x233D88, 0x33BD90, 0x33BD9A, 0x213DA4, 0x343DA8, + 0x423DB3, 0x22BDBB, 0x313DC2, 0x31BDC7, 0x323DCD, 0x32BDD4, + 0x31BDDC, 0x323DE2, 0x353DE9, 0x35BDF6, 0x333E04, 0x35BE0D, + 0x343E1B, 0x343E26, 0x33BE31, 0x32BE3B, 0x333E43, 0x323E4C, + 0x32BE53, 0x333E5B, 0x323E64, 0x343E6B, 0x343E76, 0x343E81, + 0x323E8C, 0x333E93, 0x32BE9C, 0x333EA4, 0x423EAD, 0x21BEB5, + 0x333EBA, 0x41BEC3, 0x323ECA, 0x423ED1, 0x333ED9, 0x423EE2, + 0x35BEEA, 0x33BEF8, 0x12BF02, 0x33BF08, 0x123F12, 0x32BF17, + 0x323F1F, 0x333F26, 0x32BF2F, 0x323F37, 0x523F3E, 0x233F47, + 0x32BF4F, 0x343F57, 0x323F62, 0x32BF69, 0x32BF71, 0x333F79, + 0x22BF82, 0x323F89, 0x333F90, 0x32BF99, 0x33BFA1, 0x32BFAB, + 0x333FB3, 0x333FBC, 0x333FC5, 0x333FCE, 0x33BFD7, 0x333FE1, + 0x32BFEA, 0x333FF2, 0x32BFFB, 0x34C003, 0x32C00F, 0x32C017, + 0x13401F, 0x134026, 0x32C02D, 0x33C035, 0x33C03F, 0x234049, + 0x234051, 0x32C059, 0x124061, 0x21C066, 0x32406B, 0x33C072, + 0x32C07C, 0x334084, 0x32408D, 0x324094, 0x33C09B, 0x3440A5, + 0x32C0B0, 0x3240B8, 0x21C0BF, 0x3340C4, 0x3340CD, 0x41C0D6, + 0x32C0DD, 0x32C0E5, 0x3340ED, 0x21C0F6, 0x2240FB, 0x354101, + 0x37410E, 0x38411F, 0x374132, 0x37C143, 0x38C155, 0x384169, + 0x37C17C, 0x37C18E, 0x2241A0, 0x3641A6, 0x32C1B5, 0x32C1BD, + 0x31C1C5, 0x3341CB, 0x3541D4, 0x32C1E1, 0x32C1E9, 0x32C1F1, + 0x32C1F9, 0x32C201, 0x424209, 0x334211, 0x33C21A, 0x124224, + 0x334229, 0x344232, 0x32C23D, 0x334245, 0x42424E, 0x31C256, + 0x12425C, 0x32C261, 0x334269, 0x334272, 0x33427B, 0x324284, + 0x32C28B, 0x32C293, 0x34429B, 0x33C2A6, 0x3142B0, 0x2342B5, + 0x32C2BD, 0x3142C5, 0x31C2CA, 0x3242D0, 0x2342D7, 0x32C2DF, + 0x31C2E7, 0x2342ED, 0x22C2F5, 0x3242FC, 0x32C303, 0x33430B, + 0x344314, 0x32C31F, 0x21C327, 0x32432C, 0x32C333, 0x32C33B, + 0x32C343, 0x33434B, 0x32C354, 0x33C35C, 0x224366, 0x12436C, + 0x334371, 0x34437A, 0x32C385, 0x32438D, 0x41C394, 0x33439B, + 0x32C3A4, 0x2343AC, 0x2243B4, 0x3443BA, 0x36C3C5, 0x21C3D5, + 0x22C3DA, 0x2343E1, 0x2343E9, 0x31C3F1, 0x3343F7, 0x324400, + 0x32C407, 0x32440F, 0x32C416, 0x32441E, 0x32C425, 0x32C42D, + 0x33C435, 0x33C43F, 0x32C449, 0x36C451, 0x334461, 0x34446A, + 0x324475, 0x32C47C, 0x31C484, 0x32448A, 0x62C491, 0x23449C, + 0x11C4A4, 0x3244A8, 0x3344AF, 0x4244B8, 0x3344C0, 0x34C4C9, + 0x3244D5, 0x32C4DC, 0x6344E4, 0x32C4F0, 0x6344F8, 0x32C504, + 0x33450C, 0x344515, 0x354520, 0x32C52D, 0x334535, 0x34453E, + 0x354549, 0x31C556, 0x33455C, 0x334565, 0x32456E, 0x32C575, + 0x42457D, 0x334585, 0x33458E, 0x334597, 0x3245A0, 0x32C5A7, + 0x27C5AF, 0x25C5C0, 0x22C5CD, 0x31C5D4, 0x3245DA, 0x3345E1, + 0x3245EA, 0x33C5F1, 0x33C5FB, 0x32C605, 0x32C60D, 0x33C615, + 0x33C61F, 0x334629, 0x344632, 0x34C63D, 0x34C649, 0x354655, + 0x334662, 0x33466B, 0x334674, 0x32467D, 0x354684, 0x35C691, + 0x33469F, 0x35C6A8, 0x3446B6, 0x3446C1, 0x33C6CC, 0x31C6D6, + 0x3246DC, 0x31C6E3, 0x2246E9, 0x2246EF, 0x2246F5, 0x3246FB, + 0x334702, 0x33C70B, 0x324715, 0x33C71C, 0x33C726, 0x33C730, + 0x33C73A, 0x33C744, 0x32C74E, 0x32C756, 0x33C75E, 0x334768, + 0x344771, 0x34C77C, 0x34C788, 0x354794, 0x3347A1, 0x3347AA, + 0x3347B3, 0x32C7BC, 0x3347C4, 0x32C7CD, 0x33C7D5, 0x3347DF, + 0x22C7E8, 0x3347EF, 0x21C7F8, 0x3247FD, 0x234804, 0x23480C, + 0x21C814, 0x324819, 0x334820, 0x41C829, 0x334830, 0x34C839, + 0x22C845, 0x24484C, 0x234856, 0x35C85E, 0x34486C, 0x334877, + 0x32C880, 0x334888, 0x22C891, 0x22C898, 0x22C89F, 0x3348A6, + 0x3448AF, 0x3348BA, 0x3248C3, 0x3248CA, 0x31C8D1, 0x3348D7, + 0x3348E0, 0x4248E9, 0x33C8F1, 0x3248FB, 0x334902, 0x32C90B, + 0x344913, 0x36491E, 0x36492D, 0x37493C, 0x34C94D, 0x36C959, + 0x37C969, 0x33497B, 0x324984, 0x34498B, 0x33C996, 0x32C9A0, + 0x33C9A8, 0x3449B2, 0x4249BD, 0x2249C5, 0x22C9CB, 0x2349D2, + 0x32C9DA, 0x3849E2, 0x38C9F5, 0x324A09, 0x324A10, 0x234A17, + 0x324A1F, 0x22CA26, 0x234A2D, 0x22CA35, 0x21CA3C, 0x32CA41, + 0x234A49, 0x32CA51, 0x334A59, 0x41CA62, 0x234A69, 0x32CA71, + 0x32CA79, 0x32CA81, 0x334A89, 0x344A92, 0x334A9D, 0x32CAA6, + 0x22CAAE, 0x21CAB5, 0x22CABA, 0x424AC1, 0x33CAC9, 0x35CAD3, + 0x36CAE1, 0x374AF1, 0x32CB02, 0x224B0A, 0x22CB10, 0x23CB17, + 0x354B20, 0x334B2D, 0x344B36, 0x334B41, 0x22CB4A, 0x32CB51, + 0x424B59, 0x32CB61, 0x234B69, 0x324B71, 0x32CB78, 0x32CB80, + 0x224B88, 0x33CB8E, 0x324B98, 0x324B9F, 0x32CBA6, 0x32CBAE, + 0x334BB6, 0x254BBF, 0x244BCB, 0x354BD5, 0x234BE2, 0x22CBEA, + 0x34CBF1, 0x324BFD, 0x234C04, 0x244C0C, 0x664C16, 0x66CC28, + 0x664C3B, 0x66CC4D, 0x244C60, 0x37CC6A, 0x384C7C, 0x21CC8F, + 0x32CC94, 0x31CC9C, 0x334CA2, 0x32CCAB, 0x334CB3, 0x134CBC, + 0x124CC3, 0x41CCC8, 0x32CCCF, 0x62CCD7, 0x62CCE2, 0x424CED, + 0x32CCF5, 0x32CCFD, 0x424D05, 0x634D0D, 0x634D19, 0x634D25, + 0x634D31, 0x33CD3D, 0x22CD47, 0x334D4E, 0x32CD57, 0x334D5F, + 0x334D68, 0x41CD71, 0x424D78, 0x314D80, 0x314D85, 0x334D8A, + 0x424D93, 0x324D9B, 0x32CDA2, 0x324DAA, 0x32CDB1, 0x41CDB9, + 0x32CDC0, 0x32CDC8, 0x214DD0, 0x32CDD4, 0x32CDDC, 0x324DE4, + 0x324DEB, 0x32CDF2, 0x424DFA, 0x334E02, 0x334E0B, 0x32CE14, + 0x32CE1C, 0x424E24, 0x334E2C, 0x334E35, 0x32CE3E, 0x324E46, + 0x334E4D, 0x234E56, 0x224E5E, 0x22CE64, 0x21CE6B, 0x21CE70, + 0x41CE75, 0x224E7C, 0x424E82, 0x424E8A, 0x224E92, 0x224E98, + 0x234E9E, 0x234EA6, 0x21CEAE, 0x224EB3, 0x334EB9, 0x224EC2, + 0x41CEC8, 0x224ECF, 0x33CED5, 0x424EDF, 0x424EE7, 0x31CEEF, + 0x324EF5 +}; + +static const unsigned char cmark_entity_text[20220] = { + 0x41, 0x45, 0x6C, 0x69, 0x67, 0xC3, 0x86, 0x41, 0x4D, 0x50, 0x26, 0x41, + 0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, 0x81, 0x41, 0x62, 0x72, 0x65, 0x76, + 0x65, 0xC4, 0x82, 0x41, 0x63, 0x69, 0x72, 0x63, 0xC3, 0x82, 0x41, 0x63, + 0x79, 0xD0, 0x90, 0x41, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x84, 0x41, 0x67, + 0x72, 0x61, 0x76, 0x65, 0xC3, 0x80, 0x41, 0x6C, 0x70, 0x68, 0x61, 0xCE, + 0x91, 0x41, 0x6D, 0x61, 0x63, 0x72, 0xC4, 0x80, 0x41, 0x6E, 0x64, 0xE2, + 0xA9, 0x93, 0x41, 0x6F, 0x67, 0x6F, 0x6E, 0xC4, 0x84, 0x41, 0x6F, 0x70, + 0x66, 0xF0, 0x9D, 0x94, 0xB8, 0x41, 0x70, 0x70, 0x6C, 0x79, 0x46, 0x75, + 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xE2, 0x81, 0xA1, 0x41, 0x72, 0x69, + 0x6E, 0x67, 0xC3, 0x85, 0x41, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0x9C, + 0x41, 0x73, 0x73, 0x69, 0x67, 0x6E, 0xE2, 0x89, 0x94, 0x41, 0x74, 0x69, + 0x6C, 0x64, 0x65, 0xC3, 0x83, 0x41, 0x75, 0x6D, 0x6C, 0xC3, 0x84, 0x42, + 0x61, 0x63, 0x6B, 0x73, 0x6C, 0x61, 0x73, 0x68, 0xE2, 0x88, 0x96, 0x42, + 0x61, 0x72, 0x76, 0xE2, 0xAB, 0xA7, 0x42, 0x61, 0x72, 0x77, 0x65, 0x64, + 0xE2, 0x8C, 0x86, 0x42, 0x63, 0x79, 0xD0, 0x91, 0x42, 0x65, 0x63, 0x61, + 0x75, 0x73, 0x65, 0xE2, 0x88, 0xB5, 0x42, 0x65, 0x72, 0x6E, 0x6F, 0x75, + 0x6C, 0x6C, 0x69, 0x73, 0xE2, 0x84, 0xAC, 0x42, 0x65, 0x74, 0x61, 0xCE, + 0x92, 0x42, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x85, 0x42, 0x6F, 0x70, 0x66, + 0xF0, 0x9D, 0x94, 0xB9, 0x42, 0x72, 0x65, 0x76, 0x65, 0xCB, 0x98, 0x42, + 0x73, 0x63, 0x72, 0xE2, 0x84, 0xAC, 0x42, 0x75, 0x6D, 0x70, 0x65, 0x71, + 0xE2, 0x89, 0x8E, 0x43, 0x48, 0x63, 0x79, 0xD0, 0xA7, 0x43, 0x4F, 0x50, + 0x59, 0xC2, 0xA9, 0x43, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC4, 0x86, 0x43, + 0x61, 0x70, 0xE2, 0x8B, 0x92, 0x43, 0x61, 0x70, 0x69, 0x74, 0x61, 0x6C, + 0x44, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x69, 0x61, 0x6C, + 0x44, 0xE2, 0x85, 0x85, 0x43, 0x61, 0x79, 0x6C, 0x65, 0x79, 0x73, 0xE2, + 0x84, 0xAD, 0x43, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC4, 0x8C, 0x43, 0x63, + 0x65, 0x64, 0x69, 0x6C, 0xC3, 0x87, 0x43, 0x63, 0x69, 0x72, 0x63, 0xC4, + 0x88, 0x43, 0x63, 0x6F, 0x6E, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xB0, 0x43, + 0x64, 0x6F, 0x74, 0xC4, 0x8A, 0x43, 0x65, 0x64, 0x69, 0x6C, 0x6C, 0x61, + 0xC2, 0xB8, 0x43, 0x65, 0x6E, 0x74, 0x65, 0x72, 0x44, 0x6F, 0x74, 0xC2, + 0xB7, 0x43, 0x66, 0x72, 0xE2, 0x84, 0xAD, 0x43, 0x68, 0x69, 0xCE, 0xA7, + 0x43, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x44, 0x6F, 0x74, 0xE2, 0x8A, 0x99, + 0x43, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x4D, 0x69, 0x6E, 0x75, 0x73, 0xE2, + 0x8A, 0x96, 0x43, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x50, 0x6C, 0x75, 0x73, + 0xE2, 0x8A, 0x95, 0x43, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x54, 0x69, 0x6D, + 0x65, 0x73, 0xE2, 0x8A, 0x97, 0x43, 0x6C, 0x6F, 0x63, 0x6B, 0x77, 0x69, + 0x73, 0x65, 0x43, 0x6F, 0x6E, 0x74, 0x6F, 0x75, 0x72, 0x49, 0x6E, 0x74, + 0x65, 0x67, 0x72, 0x61, 0x6C, 0xE2, 0x88, 0xB2, 0x43, 0x6C, 0x6F, 0x73, + 0x65, 0x43, 0x75, 0x72, 0x6C, 0x79, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, + 0x51, 0x75, 0x6F, 0x74, 0x65, 0xE2, 0x80, 0x9D, 0x43, 0x6C, 0x6F, 0x73, + 0x65, 0x43, 0x75, 0x72, 0x6C, 0x79, 0x51, 0x75, 0x6F, 0x74, 0x65, 0xE2, + 0x80, 0x99, 0x43, 0x6F, 0x6C, 0x6F, 0x6E, 0xE2, 0x88, 0xB7, 0x43, 0x6F, + 0x6C, 0x6F, 0x6E, 0x65, 0xE2, 0xA9, 0xB4, 0x43, 0x6F, 0x6E, 0x67, 0x72, + 0x75, 0x65, 0x6E, 0x74, 0xE2, 0x89, 0xA1, 0x43, 0x6F, 0x6E, 0x69, 0x6E, + 0x74, 0xE2, 0x88, 0xAF, 0x43, 0x6F, 0x6E, 0x74, 0x6F, 0x75, 0x72, 0x49, + 0x6E, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6C, 0xE2, 0x88, 0xAE, 0x43, 0x6F, + 0x70, 0x66, 0xE2, 0x84, 0x82, 0x43, 0x6F, 0x70, 0x72, 0x6F, 0x64, 0x75, + 0x63, 0x74, 0xE2, 0x88, 0x90, 0x43, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x72, + 0x43, 0x6C, 0x6F, 0x63, 0x6B, 0x77, 0x69, 0x73, 0x65, 0x43, 0x6F, 0x6E, + 0x74, 0x6F, 0x75, 0x72, 0x49, 0x6E, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6C, + 0xE2, 0x88, 0xB3, 0x43, 0x72, 0x6F, 0x73, 0x73, 0xE2, 0xA8, 0xAF, 0x43, + 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0x9E, 0x43, 0x75, 0x70, 0xE2, 0x8B, + 0x93, 0x43, 0x75, 0x70, 0x43, 0x61, 0x70, 0xE2, 0x89, 0x8D, 0x44, 0x44, + 0xE2, 0x85, 0x85, 0x44, 0x44, 0x6F, 0x74, 0x72, 0x61, 0x68, 0x64, 0xE2, + 0xA4, 0x91, 0x44, 0x4A, 0x63, 0x79, 0xD0, 0x82, 0x44, 0x53, 0x63, 0x79, + 0xD0, 0x85, 0x44, 0x5A, 0x63, 0x79, 0xD0, 0x8F, 0x44, 0x61, 0x67, 0x67, + 0x65, 0x72, 0xE2, 0x80, 0xA1, 0x44, 0x61, 0x72, 0x72, 0xE2, 0x86, 0xA1, + 0x44, 0x61, 0x73, 0x68, 0x76, 0xE2, 0xAB, 0xA4, 0x44, 0x63, 0x61, 0x72, + 0x6F, 0x6E, 0xC4, 0x8E, 0x44, 0x63, 0x79, 0xD0, 0x94, 0x44, 0x65, 0x6C, + 0xE2, 0x88, 0x87, 0x44, 0x65, 0x6C, 0x74, 0x61, 0xCE, 0x94, 0x44, 0x66, + 0x72, 0xF0, 0x9D, 0x94, 0x87, 0x44, 0x69, 0x61, 0x63, 0x72, 0x69, 0x74, + 0x69, 0x63, 0x61, 0x6C, 0x41, 0x63, 0x75, 0x74, 0x65, 0xC2, 0xB4, 0x44, + 0x69, 0x61, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x44, 0x6F, + 0x74, 0xCB, 0x99, 0x44, 0x69, 0x61, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, + 0x61, 0x6C, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x41, 0x63, 0x75, 0x74, + 0x65, 0xCB, 0x9D, 0x44, 0x69, 0x61, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, + 0x61, 0x6C, 0x47, 0x72, 0x61, 0x76, 0x65, 0x60, 0x44, 0x69, 0x61, 0x63, + 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x54, 0x69, 0x6C, 0x64, 0x65, + 0xCB, 0x9C, 0x44, 0x69, 0x61, 0x6D, 0x6F, 0x6E, 0x64, 0xE2, 0x8B, 0x84, + 0x44, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x69, 0x61, 0x6C, + 0x44, 0xE2, 0x85, 0x86, 0x44, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x94, 0xBB, + 0x44, 0x6F, 0x74, 0xC2, 0xA8, 0x44, 0x6F, 0x74, 0x44, 0x6F, 0x74, 0xE2, + 0x83, 0x9C, 0x44, 0x6F, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, + 0x90, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x43, 0x6F, 0x6E, 0x74, 0x6F, + 0x75, 0x72, 0x49, 0x6E, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6C, 0xE2, 0x88, + 0xAF, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x44, 0x6F, 0x74, 0xC2, 0xA8, + 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72, + 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x93, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, + 0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x90, + 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x4C, 0x65, 0x66, 0x74, 0x52, 0x69, + 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x94, 0x44, + 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x4C, 0x65, 0x66, 0x74, 0x54, 0x65, 0x65, + 0xE2, 0xAB, 0xA4, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x4C, 0x6F, 0x6E, + 0x67, 0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, + 0xB8, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x4C, 0x6F, 0x6E, 0x67, 0x4C, + 0x65, 0x66, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, + 0x77, 0xE2, 0x9F, 0xBA, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x4C, 0x6F, + 0x6E, 0x67, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, + 0xE2, 0x9F, 0xB9, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x52, 0x69, 0x67, + 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x92, 0x44, 0x6F, + 0x75, 0x62, 0x6C, 0x65, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, 0x65, 0x65, + 0xE2, 0x8A, 0xA8, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x55, 0x70, 0x41, + 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x91, 0x44, 0x6F, 0x75, 0x62, 0x6C, + 0x65, 0x55, 0x70, 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, + 0xE2, 0x87, 0x95, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x56, 0x65, 0x72, + 0x74, 0x69, 0x63, 0x61, 0x6C, 0x42, 0x61, 0x72, 0xE2, 0x88, 0xA5, 0x44, + 0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x93, 0x44, + 0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, 0x42, 0x61, 0x72, 0xE2, + 0xA4, 0x93, 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, 0x55, + 0x70, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0xB5, 0x44, 0x6F, 0x77, + 0x6E, 0x42, 0x72, 0x65, 0x76, 0x65, 0xCC, 0x91, 0x44, 0x6F, 0x77, 0x6E, + 0x4C, 0x65, 0x66, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x56, 0x65, 0x63, + 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x90, 0x44, 0x6F, 0x77, 0x6E, 0x4C, 0x65, + 0x66, 0x74, 0x54, 0x65, 0x65, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, + 0xA5, 0x9E, 0x44, 0x6F, 0x77, 0x6E, 0x4C, 0x65, 0x66, 0x74, 0x56, 0x65, + 0x63, 0x74, 0x6F, 0x72, 0xE2, 0x86, 0xBD, 0x44, 0x6F, 0x77, 0x6E, 0x4C, + 0x65, 0x66, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x42, 0x61, 0x72, + 0xE2, 0xA5, 0x96, 0x44, 0x6F, 0x77, 0x6E, 0x52, 0x69, 0x67, 0x68, 0x74, + 0x54, 0x65, 0x65, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x9F, + 0x44, 0x6F, 0x77, 0x6E, 0x52, 0x69, 0x67, 0x68, 0x74, 0x56, 0x65, 0x63, + 0x74, 0x6F, 0x72, 0xE2, 0x87, 0x81, 0x44, 0x6F, 0x77, 0x6E, 0x52, 0x69, + 0x67, 0x68, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x42, 0x61, 0x72, + 0xE2, 0xA5, 0x97, 0x44, 0x6F, 0x77, 0x6E, 0x54, 0x65, 0x65, 0xE2, 0x8A, + 0xA4, 0x44, 0x6F, 0x77, 0x6E, 0x54, 0x65, 0x65, 0x41, 0x72, 0x72, 0x6F, + 0x77, 0xE2, 0x86, 0xA7, 0x44, 0x6F, 0x77, 0x6E, 0x61, 0x72, 0x72, 0x6F, + 0x77, 0xE2, 0x87, 0x93, 0x44, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0x9F, + 0x44, 0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC4, 0x90, 0x45, 0x4E, 0x47, 0xC5, + 0x8A, 0x45, 0x54, 0x48, 0xC3, 0x90, 0x45, 0x61, 0x63, 0x75, 0x74, 0x65, + 0xC3, 0x89, 0x45, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC4, 0x9A, 0x45, 0x63, + 0x69, 0x72, 0x63, 0xC3, 0x8A, 0x45, 0x63, 0x79, 0xD0, 0xAD, 0x45, 0x64, + 0x6F, 0x74, 0xC4, 0x96, 0x45, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x88, 0x45, + 0x67, 0x72, 0x61, 0x76, 0x65, 0xC3, 0x88, 0x45, 0x6C, 0x65, 0x6D, 0x65, + 0x6E, 0x74, 0xE2, 0x88, 0x88, 0x45, 0x6D, 0x61, 0x63, 0x72, 0xC4, 0x92, + 0x45, 0x6D, 0x70, 0x74, 0x79, 0x53, 0x6D, 0x61, 0x6C, 0x6C, 0x53, 0x71, + 0x75, 0x61, 0x72, 0x65, 0xE2, 0x97, 0xBB, 0x45, 0x6D, 0x70, 0x74, 0x79, + 0x56, 0x65, 0x72, 0x79, 0x53, 0x6D, 0x61, 0x6C, 0x6C, 0x53, 0x71, 0x75, + 0x61, 0x72, 0x65, 0xE2, 0x96, 0xAB, 0x45, 0x6F, 0x67, 0x6F, 0x6E, 0xC4, + 0x98, 0x45, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x94, 0xBC, 0x45, 0x70, 0x73, + 0x69, 0x6C, 0x6F, 0x6E, 0xCE, 0x95, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, + 0xA9, 0xB5, 0x45, 0x71, 0x75, 0x61, 0x6C, 0x54, 0x69, 0x6C, 0x64, 0x65, + 0xE2, 0x89, 0x82, 0x45, 0x71, 0x75, 0x69, 0x6C, 0x69, 0x62, 0x72, 0x69, + 0x75, 0x6D, 0xE2, 0x87, 0x8C, 0x45, 0x73, 0x63, 0x72, 0xE2, 0x84, 0xB0, + 0x45, 0x73, 0x69, 0x6D, 0xE2, 0xA9, 0xB3, 0x45, 0x74, 0x61, 0xCE, 0x97, + 0x45, 0x75, 0x6D, 0x6C, 0xC3, 0x8B, 0x45, 0x78, 0x69, 0x73, 0x74, 0x73, + 0xE2, 0x88, 0x83, 0x45, 0x78, 0x70, 0x6F, 0x6E, 0x65, 0x6E, 0x74, 0x69, + 0x61, 0x6C, 0x45, 0xE2, 0x85, 0x87, 0x46, 0x63, 0x79, 0xD0, 0xA4, 0x46, + 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x89, 0x46, 0x69, 0x6C, 0x6C, 0x65, 0x64, + 0x53, 0x6D, 0x61, 0x6C, 0x6C, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0xE2, + 0x97, 0xBC, 0x46, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0x56, 0x65, 0x72, 0x79, + 0x53, 0x6D, 0x61, 0x6C, 0x6C, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0xE2, + 0x96, 0xAA, 0x46, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x94, 0xBD, 0x46, 0x6F, + 0x72, 0x41, 0x6C, 0x6C, 0xE2, 0x88, 0x80, 0x46, 0x6F, 0x75, 0x72, 0x69, + 0x65, 0x72, 0x74, 0x72, 0x66, 0xE2, 0x84, 0xB1, 0x46, 0x73, 0x63, 0x72, + 0xE2, 0x84, 0xB1, 0x47, 0x4A, 0x63, 0x79, 0xD0, 0x83, 0x47, 0x54, 0x3E, + 0x47, 0x61, 0x6D, 0x6D, 0x61, 0xCE, 0x93, 0x47, 0x61, 0x6D, 0x6D, 0x61, + 0x64, 0xCF, 0x9C, 0x47, 0x62, 0x72, 0x65, 0x76, 0x65, 0xC4, 0x9E, 0x47, + 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC4, 0xA2, 0x47, 0x63, 0x69, 0x72, 0x63, + 0xC4, 0x9C, 0x47, 0x63, 0x79, 0xD0, 0x93, 0x47, 0x64, 0x6F, 0x74, 0xC4, + 0xA0, 0x47, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x8A, 0x47, 0x67, 0xE2, 0x8B, + 0x99, 0x47, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x94, 0xBE, 0x47, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x72, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xA5, + 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x45, 0x71, 0x75, 0x61, 0x6C, + 0x4C, 0x65, 0x73, 0x73, 0xE2, 0x8B, 0x9B, 0x47, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x72, 0x46, 0x75, 0x6C, 0x6C, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, + 0x89, 0xA7, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x47, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x72, 0xE2, 0xAA, 0xA2, 0x47, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x72, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xB7, 0x47, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x72, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71, 0x75, + 0x61, 0x6C, 0xE2, 0xA9, 0xBE, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, + 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xB3, 0x47, 0x73, 0x63, 0x72, + 0xF0, 0x9D, 0x92, 0xA2, 0x47, 0x74, 0xE2, 0x89, 0xAB, 0x48, 0x41, 0x52, + 0x44, 0x63, 0x79, 0xD0, 0xAA, 0x48, 0x61, 0x63, 0x65, 0x6B, 0xCB, 0x87, + 0x48, 0x61, 0x74, 0x5E, 0x48, 0x63, 0x69, 0x72, 0x63, 0xC4, 0xA4, 0x48, + 0x66, 0x72, 0xE2, 0x84, 0x8C, 0x48, 0x69, 0x6C, 0x62, 0x65, 0x72, 0x74, + 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, 0x84, 0x8B, 0x48, 0x6F, 0x70, 0x66, + 0xE2, 0x84, 0x8D, 0x48, 0x6F, 0x72, 0x69, 0x7A, 0x6F, 0x6E, 0x74, 0x61, + 0x6C, 0x4C, 0x69, 0x6E, 0x65, 0xE2, 0x94, 0x80, 0x48, 0x73, 0x63, 0x72, + 0xE2, 0x84, 0x8B, 0x48, 0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC4, 0xA6, 0x48, + 0x75, 0x6D, 0x70, 0x44, 0x6F, 0x77, 0x6E, 0x48, 0x75, 0x6D, 0x70, 0xE2, + 0x89, 0x8E, 0x48, 0x75, 0x6D, 0x70, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, + 0x89, 0x8F, 0x49, 0x45, 0x63, 0x79, 0xD0, 0x95, 0x49, 0x4A, 0x6C, 0x69, + 0x67, 0xC4, 0xB2, 0x49, 0x4F, 0x63, 0x79, 0xD0, 0x81, 0x49, 0x61, 0x63, + 0x75, 0x74, 0x65, 0xC3, 0x8D, 0x49, 0x63, 0x69, 0x72, 0x63, 0xC3, 0x8E, + 0x49, 0x63, 0x79, 0xD0, 0x98, 0x49, 0x64, 0x6F, 0x74, 0xC4, 0xB0, 0x49, + 0x66, 0x72, 0xE2, 0x84, 0x91, 0x49, 0x67, 0x72, 0x61, 0x76, 0x65, 0xC3, + 0x8C, 0x49, 0x6D, 0xE2, 0x84, 0x91, 0x49, 0x6D, 0x61, 0x63, 0x72, 0xC4, + 0xAA, 0x49, 0x6D, 0x61, 0x67, 0x69, 0x6E, 0x61, 0x72, 0x79, 0x49, 0xE2, + 0x85, 0x88, 0x49, 0x6D, 0x70, 0x6C, 0x69, 0x65, 0x73, 0xE2, 0x87, 0x92, + 0x49, 0x6E, 0x74, 0xE2, 0x88, 0xAC, 0x49, 0x6E, 0x74, 0x65, 0x67, 0x72, + 0x61, 0x6C, 0xE2, 0x88, 0xAB, 0x49, 0x6E, 0x74, 0x65, 0x72, 0x73, 0x65, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xE2, 0x8B, 0x82, 0x49, 0x6E, 0x76, 0x69, + 0x73, 0x69, 0x62, 0x6C, 0x65, 0x43, 0x6F, 0x6D, 0x6D, 0x61, 0xE2, 0x81, + 0xA3, 0x49, 0x6E, 0x76, 0x69, 0x73, 0x69, 0x62, 0x6C, 0x65, 0x54, 0x69, + 0x6D, 0x65, 0x73, 0xE2, 0x81, 0xA2, 0x49, 0x6F, 0x67, 0x6F, 0x6E, 0xC4, + 0xAE, 0x49, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x80, 0x49, 0x6F, 0x74, + 0x61, 0xCE, 0x99, 0x49, 0x73, 0x63, 0x72, 0xE2, 0x84, 0x90, 0x49, 0x74, + 0x69, 0x6C, 0x64, 0x65, 0xC4, 0xA8, 0x49, 0x75, 0x6B, 0x63, 0x79, 0xD0, + 0x86, 0x49, 0x75, 0x6D, 0x6C, 0xC3, 0x8F, 0x4A, 0x63, 0x69, 0x72, 0x63, + 0xC4, 0xB4, 0x4A, 0x63, 0x79, 0xD0, 0x99, 0x4A, 0x66, 0x72, 0xF0, 0x9D, + 0x94, 0x8D, 0x4A, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x81, 0x4A, 0x73, + 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xA5, 0x4A, 0x73, 0x65, 0x72, 0x63, 0x79, + 0xD0, 0x88, 0x4A, 0x75, 0x6B, 0x63, 0x79, 0xD0, 0x84, 0x4B, 0x48, 0x63, + 0x79, 0xD0, 0xA5, 0x4B, 0x4A, 0x63, 0x79, 0xD0, 0x8C, 0x4B, 0x61, 0x70, + 0x70, 0x61, 0xCE, 0x9A, 0x4B, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC4, 0xB6, + 0x4B, 0x63, 0x79, 0xD0, 0x9A, 0x4B, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x8E, + 0x4B, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x82, 0x4B, 0x73, 0x63, 0x72, + 0xF0, 0x9D, 0x92, 0xA6, 0x4C, 0x4A, 0x63, 0x79, 0xD0, 0x89, 0x4C, 0x54, + 0x3C, 0x4C, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC4, 0xB9, 0x4C, 0x61, 0x6D, + 0x62, 0x64, 0x61, 0xCE, 0x9B, 0x4C, 0x61, 0x6E, 0x67, 0xE2, 0x9F, 0xAA, + 0x4C, 0x61, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x74, 0x72, 0x66, 0xE2, 0x84, + 0x92, 0x4C, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x9E, 0x4C, 0x63, 0x61, 0x72, + 0x6F, 0x6E, 0xC4, 0xBD, 0x4C, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC4, 0xBB, + 0x4C, 0x63, 0x79, 0xD0, 0x9B, 0x4C, 0x65, 0x66, 0x74, 0x41, 0x6E, 0x67, + 0x6C, 0x65, 0x42, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0xE2, 0x9F, 0xA8, + 0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x90, + 0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0x42, 0x61, 0x72, + 0xE2, 0x87, 0xA4, 0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, + 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, + 0x86, 0x4C, 0x65, 0x66, 0x74, 0x43, 0x65, 0x69, 0x6C, 0x69, 0x6E, 0x67, + 0xE2, 0x8C, 0x88, 0x4C, 0x65, 0x66, 0x74, 0x44, 0x6F, 0x75, 0x62, 0x6C, + 0x65, 0x42, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0xE2, 0x9F, 0xA6, 0x4C, + 0x65, 0x66, 0x74, 0x44, 0x6F, 0x77, 0x6E, 0x54, 0x65, 0x65, 0x56, 0x65, + 0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0xA1, 0x4C, 0x65, 0x66, 0x74, 0x44, + 0x6F, 0x77, 0x6E, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0x87, 0x83, + 0x4C, 0x65, 0x66, 0x74, 0x44, 0x6F, 0x77, 0x6E, 0x56, 0x65, 0x63, 0x74, + 0x6F, 0x72, 0x42, 0x61, 0x72, 0xE2, 0xA5, 0x99, 0x4C, 0x65, 0x66, 0x74, + 0x46, 0x6C, 0x6F, 0x6F, 0x72, 0xE2, 0x8C, 0x8A, 0x4C, 0x65, 0x66, 0x74, + 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, + 0x94, 0x4C, 0x65, 0x66, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x56, 0x65, + 0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x8E, 0x4C, 0x65, 0x66, 0x74, 0x54, + 0x65, 0x65, 0xE2, 0x8A, 0xA3, 0x4C, 0x65, 0x66, 0x74, 0x54, 0x65, 0x65, + 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0xA4, 0x4C, 0x65, 0x66, 0x74, + 0x54, 0x65, 0x65, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x9A, + 0x4C, 0x65, 0x66, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, + 0xE2, 0x8A, 0xB2, 0x4C, 0x65, 0x66, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, + 0x67, 0x6C, 0x65, 0x42, 0x61, 0x72, 0xE2, 0xA7, 0x8F, 0x4C, 0x65, 0x66, + 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x45, 0x71, 0x75, + 0x61, 0x6C, 0xE2, 0x8A, 0xB4, 0x4C, 0x65, 0x66, 0x74, 0x55, 0x70, 0x44, + 0x6F, 0x77, 0x6E, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x91, + 0x4C, 0x65, 0x66, 0x74, 0x55, 0x70, 0x54, 0x65, 0x65, 0x56, 0x65, 0x63, + 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0xA0, 0x4C, 0x65, 0x66, 0x74, 0x55, 0x70, + 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0x86, 0xBF, 0x4C, 0x65, 0x66, + 0x74, 0x55, 0x70, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x42, 0x61, 0x72, + 0xE2, 0xA5, 0x98, 0x4C, 0x65, 0x66, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6F, + 0x72, 0xE2, 0x86, 0xBC, 0x4C, 0x65, 0x66, 0x74, 0x56, 0x65, 0x63, 0x74, + 0x6F, 0x72, 0x42, 0x61, 0x72, 0xE2, 0xA5, 0x92, 0x4C, 0x65, 0x66, 0x74, + 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x90, 0x4C, 0x65, 0x66, 0x74, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, + 0x94, 0x4C, 0x65, 0x73, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6C, 0x47, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x72, 0xE2, 0x8B, 0x9A, 0x4C, 0x65, 0x73, 0x73, + 0x46, 0x75, 0x6C, 0x6C, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xA6, + 0x4C, 0x65, 0x73, 0x73, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0xE2, + 0x89, 0xB6, 0x4C, 0x65, 0x73, 0x73, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0xAA, + 0xA1, 0x4C, 0x65, 0x73, 0x73, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71, + 0x75, 0x61, 0x6C, 0xE2, 0xA9, 0xBD, 0x4C, 0x65, 0x73, 0x73, 0x54, 0x69, + 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xB2, 0x4C, 0x66, 0x72, 0xF0, 0x9D, 0x94, + 0x8F, 0x4C, 0x6C, 0xE2, 0x8B, 0x98, 0x4C, 0x6C, 0x65, 0x66, 0x74, 0x61, + 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x9A, 0x4C, 0x6D, 0x69, 0x64, 0x6F, + 0x74, 0xC4, 0xBF, 0x4C, 0x6F, 0x6E, 0x67, 0x4C, 0x65, 0x66, 0x74, 0x41, + 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xB5, 0x4C, 0x6F, 0x6E, 0x67, 0x4C, + 0x65, 0x66, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, + 0x77, 0xE2, 0x9F, 0xB7, 0x4C, 0x6F, 0x6E, 0x67, 0x52, 0x69, 0x67, 0x68, + 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xB6, 0x4C, 0x6F, 0x6E, + 0x67, 0x6C, 0x65, 0x66, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, + 0xB8, 0x4C, 0x6F, 0x6E, 0x67, 0x6C, 0x65, 0x66, 0x74, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xBA, 0x4C, 0x6F, + 0x6E, 0x67, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, + 0xE2, 0x9F, 0xB9, 0x4C, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x83, 0x4C, + 0x6F, 0x77, 0x65, 0x72, 0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, + 0x77, 0xE2, 0x86, 0x99, 0x4C, 0x6F, 0x77, 0x65, 0x72, 0x52, 0x69, 0x67, + 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x98, 0x4C, 0x73, + 0x63, 0x72, 0xE2, 0x84, 0x92, 0x4C, 0x73, 0x68, 0xE2, 0x86, 0xB0, 0x4C, + 0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC5, 0x81, 0x4C, 0x74, 0xE2, 0x89, 0xAA, + 0x4D, 0x61, 0x70, 0xE2, 0xA4, 0x85, 0x4D, 0x63, 0x79, 0xD0, 0x9C, 0x4D, + 0x65, 0x64, 0x69, 0x75, 0x6D, 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, 0x81, + 0x9F, 0x4D, 0x65, 0x6C, 0x6C, 0x69, 0x6E, 0x74, 0x72, 0x66, 0xE2, 0x84, + 0xB3, 0x4D, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x90, 0x4D, 0x69, 0x6E, 0x75, + 0x73, 0x50, 0x6C, 0x75, 0x73, 0xE2, 0x88, 0x93, 0x4D, 0x6F, 0x70, 0x66, + 0xF0, 0x9D, 0x95, 0x84, 0x4D, 0x73, 0x63, 0x72, 0xE2, 0x84, 0xB3, 0x4D, + 0x75, 0xCE, 0x9C, 0x4E, 0x4A, 0x63, 0x79, 0xD0, 0x8A, 0x4E, 0x61, 0x63, + 0x75, 0x74, 0x65, 0xC5, 0x83, 0x4E, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5, + 0x87, 0x4E, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0x85, 0x4E, 0x63, 0x79, + 0xD0, 0x9D, 0x4E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4D, 0x65, + 0x64, 0x69, 0x75, 0x6D, 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, 0x80, 0x8B, + 0x4E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x54, 0x68, 0x69, 0x63, + 0x6B, 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, 0x80, 0x8B, 0x4E, 0x65, 0x67, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x54, 0x68, 0x69, 0x6E, 0x53, 0x70, 0x61, + 0x63, 0x65, 0xE2, 0x80, 0x8B, 0x4E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, + 0x65, 0x56, 0x65, 0x72, 0x79, 0x54, 0x68, 0x69, 0x6E, 0x53, 0x70, 0x61, + 0x63, 0x65, 0xE2, 0x80, 0x8B, 0x4E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x47, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x72, 0xE2, 0x89, 0xAB, 0x4E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4C, 0x65, + 0x73, 0x73, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xAA, 0x4E, 0x65, 0x77, + 0x4C, 0x69, 0x6E, 0x65, 0x0A, 0x4E, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x91, + 0x4E, 0x6F, 0x42, 0x72, 0x65, 0x61, 0x6B, 0xE2, 0x81, 0xA0, 0x4E, 0x6F, + 0x6E, 0x42, 0x72, 0x65, 0x61, 0x6B, 0x69, 0x6E, 0x67, 0x53, 0x70, 0x61, + 0x63, 0x65, 0xC2, 0xA0, 0x4E, 0x6F, 0x70, 0x66, 0xE2, 0x84, 0x95, 0x4E, + 0x6F, 0x74, 0xE2, 0xAB, 0xAC, 0x4E, 0x6F, 0x74, 0x43, 0x6F, 0x6E, 0x67, + 0x72, 0x75, 0x65, 0x6E, 0x74, 0xE2, 0x89, 0xA2, 0x4E, 0x6F, 0x74, 0x43, + 0x75, 0x70, 0x43, 0x61, 0x70, 0xE2, 0x89, 0xAD, 0x4E, 0x6F, 0x74, 0x44, + 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x56, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, + 0x6C, 0x42, 0x61, 0x72, 0xE2, 0x88, 0xA6, 0x4E, 0x6F, 0x74, 0x45, 0x6C, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0xE2, 0x88, 0x89, 0x4E, 0x6F, 0x74, 0x45, + 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xA0, 0x4E, 0x6F, 0x74, 0x45, 0x71, + 0x75, 0x61, 0x6C, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0x82, 0xCC, + 0xB8, 0x4E, 0x6F, 0x74, 0x45, 0x78, 0x69, 0x73, 0x74, 0x73, 0xE2, 0x88, + 0x84, 0x4E, 0x6F, 0x74, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0xE2, + 0x89, 0xAF, 0x4E, 0x6F, 0x74, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, + 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xB1, 0x4E, 0x6F, 0x74, 0x47, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x46, 0x75, 0x6C, 0x6C, 0x45, 0x71, + 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xA7, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x47, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x72, 0xE2, 0x89, 0xAB, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x47, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x72, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xB9, 0x4E, + 0x6F, 0x74, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x53, 0x6C, 0x61, + 0x6E, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0xA9, 0xBE, 0xCC, 0xB8, + 0x4E, 0x6F, 0x74, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x54, 0x69, + 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xB5, 0x4E, 0x6F, 0x74, 0x48, 0x75, 0x6D, + 0x70, 0x44, 0x6F, 0x77, 0x6E, 0x48, 0x75, 0x6D, 0x70, 0xE2, 0x89, 0x8E, + 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x48, 0x75, 0x6D, 0x70, 0x45, 0x71, 0x75, + 0x61, 0x6C, 0xE2, 0x89, 0x8F, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x4C, 0x65, + 0x66, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x8B, + 0xAA, 0x4E, 0x6F, 0x74, 0x4C, 0x65, 0x66, 0x74, 0x54, 0x72, 0x69, 0x61, + 0x6E, 0x67, 0x6C, 0x65, 0x42, 0x61, 0x72, 0xE2, 0xA7, 0x8F, 0xCC, 0xB8, + 0x4E, 0x6F, 0x74, 0x4C, 0x65, 0x66, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, + 0x67, 0x6C, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8B, 0xAC, 0x4E, + 0x6F, 0x74, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xAE, 0x4E, 0x6F, 0x74, + 0x4C, 0x65, 0x73, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xB0, + 0x4E, 0x6F, 0x74, 0x4C, 0x65, 0x73, 0x73, 0x47, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x72, 0xE2, 0x89, 0xB8, 0x4E, 0x6F, 0x74, 0x4C, 0x65, 0x73, 0x73, + 0x4C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xAA, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, + 0x4C, 0x65, 0x73, 0x73, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71, 0x75, + 0x61, 0x6C, 0xE2, 0xA9, 0xBD, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x4C, 0x65, + 0x73, 0x73, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xB4, 0x4E, 0x6F, + 0x74, 0x4E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x47, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x72, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0xE2, 0xAA, 0xA2, + 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x4E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4C, + 0x65, 0x73, 0x73, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0xAA, 0xA1, 0xCC, 0xB8, + 0x4E, 0x6F, 0x74, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65, 0x73, 0xE2, + 0x8A, 0x80, 0x4E, 0x6F, 0x74, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65, + 0x73, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0xAA, 0xAF, 0xCC, 0xB8, 0x4E, + 0x6F, 0x74, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65, 0x73, 0x53, 0x6C, + 0x61, 0x6E, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8B, 0xA0, 0x4E, + 0x6F, 0x74, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x45, 0x6C, 0x65, + 0x6D, 0x65, 0x6E, 0x74, 0xE2, 0x88, 0x8C, 0x4E, 0x6F, 0x74, 0x52, 0x69, + 0x67, 0x68, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, + 0x8B, 0xAB, 0x4E, 0x6F, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, 0x72, + 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x42, 0x61, 0x72, 0xE2, 0xA7, 0x90, + 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, 0x72, + 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, + 0x8B, 0xAD, 0x4E, 0x6F, 0x74, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53, + 0x75, 0x62, 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x8F, 0xCC, 0xB8, 0x4E, 0x6F, + 0x74, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53, 0x75, 0x62, 0x73, 0x65, + 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8B, 0xA2, 0x4E, 0x6F, 0x74, + 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x73, + 0x65, 0x74, 0xE2, 0x8A, 0x90, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x53, 0x71, + 0x75, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x73, 0x65, 0x74, + 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8B, 0xA3, 0x4E, 0x6F, 0x74, 0x53, + 0x75, 0x62, 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x82, 0xE2, 0x83, 0x92, 0x4E, + 0x6F, 0x74, 0x53, 0x75, 0x62, 0x73, 0x65, 0x74, 0x45, 0x71, 0x75, 0x61, + 0x6C, 0xE2, 0x8A, 0x88, 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x63, 0x63, 0x65, + 0x65, 0x64, 0x73, 0xE2, 0x8A, 0x81, 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x63, + 0x63, 0x65, 0x65, 0x64, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0xAA, + 0xB0, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, + 0x64, 0x73, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, + 0xE2, 0x8B, 0xA1, 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, + 0x64, 0x73, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xBF, 0xCC, 0xB8, + 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x70, 0x65, 0x72, 0x73, 0x65, 0x74, 0xE2, + 0x8A, 0x83, 0xE2, 0x83, 0x92, 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x70, 0x65, + 0x72, 0x73, 0x65, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8A, 0x89, + 0x4E, 0x6F, 0x74, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0x81, 0x4E, + 0x6F, 0x74, 0x54, 0x69, 0x6C, 0x64, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6C, + 0xE2, 0x89, 0x84, 0x4E, 0x6F, 0x74, 0x54, 0x69, 0x6C, 0x64, 0x65, 0x46, + 0x75, 0x6C, 0x6C, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0x87, 0x4E, + 0x6F, 0x74, 0x54, 0x69, 0x6C, 0x64, 0x65, 0x54, 0x69, 0x6C, 0x64, 0x65, + 0xE2, 0x89, 0x89, 0x4E, 0x6F, 0x74, 0x56, 0x65, 0x72, 0x74, 0x69, 0x63, + 0x61, 0x6C, 0x42, 0x61, 0x72, 0xE2, 0x88, 0xA4, 0x4E, 0x73, 0x63, 0x72, + 0xF0, 0x9D, 0x92, 0xA9, 0x4E, 0x74, 0x69, 0x6C, 0x64, 0x65, 0xC3, 0x91, + 0x4E, 0x75, 0xCE, 0x9D, 0x4F, 0x45, 0x6C, 0x69, 0x67, 0xC5, 0x92, 0x4F, + 0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, 0x93, 0x4F, 0x63, 0x69, 0x72, 0x63, + 0xC3, 0x94, 0x4F, 0x63, 0x79, 0xD0, 0x9E, 0x4F, 0x64, 0x62, 0x6C, 0x61, + 0x63, 0xC5, 0x90, 0x4F, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x92, 0x4F, 0x67, + 0x72, 0x61, 0x76, 0x65, 0xC3, 0x92, 0x4F, 0x6D, 0x61, 0x63, 0x72, 0xC5, + 0x8C, 0x4F, 0x6D, 0x65, 0x67, 0x61, 0xCE, 0xA9, 0x4F, 0x6D, 0x69, 0x63, + 0x72, 0x6F, 0x6E, 0xCE, 0x9F, 0x4F, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, + 0x86, 0x4F, 0x70, 0x65, 0x6E, 0x43, 0x75, 0x72, 0x6C, 0x79, 0x44, 0x6F, + 0x75, 0x62, 0x6C, 0x65, 0x51, 0x75, 0x6F, 0x74, 0x65, 0xE2, 0x80, 0x9C, + 0x4F, 0x70, 0x65, 0x6E, 0x43, 0x75, 0x72, 0x6C, 0x79, 0x51, 0x75, 0x6F, + 0x74, 0x65, 0xE2, 0x80, 0x98, 0x4F, 0x72, 0xE2, 0xA9, 0x94, 0x4F, 0x73, + 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xAA, 0x4F, 0x73, 0x6C, 0x61, 0x73, 0x68, + 0xC3, 0x98, 0x4F, 0x74, 0x69, 0x6C, 0x64, 0x65, 0xC3, 0x95, 0x4F, 0x74, + 0x69, 0x6D, 0x65, 0x73, 0xE2, 0xA8, 0xB7, 0x4F, 0x75, 0x6D, 0x6C, 0xC3, + 0x96, 0x4F, 0x76, 0x65, 0x72, 0x42, 0x61, 0x72, 0xE2, 0x80, 0xBE, 0x4F, + 0x76, 0x65, 0x72, 0x42, 0x72, 0x61, 0x63, 0x65, 0xE2, 0x8F, 0x9E, 0x4F, + 0x76, 0x65, 0x72, 0x42, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0xE2, 0x8E, + 0xB4, 0x4F, 0x76, 0x65, 0x72, 0x50, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x68, + 0x65, 0x73, 0x69, 0x73, 0xE2, 0x8F, 0x9C, 0x50, 0x61, 0x72, 0x74, 0x69, + 0x61, 0x6C, 0x44, 0xE2, 0x88, 0x82, 0x50, 0x63, 0x79, 0xD0, 0x9F, 0x50, + 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x93, 0x50, 0x68, 0x69, 0xCE, 0xA6, 0x50, + 0x69, 0xCE, 0xA0, 0x50, 0x6C, 0x75, 0x73, 0x4D, 0x69, 0x6E, 0x75, 0x73, + 0xC2, 0xB1, 0x50, 0x6F, 0x69, 0x6E, 0x63, 0x61, 0x72, 0x65, 0x70, 0x6C, + 0x61, 0x6E, 0x65, 0xE2, 0x84, 0x8C, 0x50, 0x6F, 0x70, 0x66, 0xE2, 0x84, + 0x99, 0x50, 0x72, 0xE2, 0xAA, 0xBB, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64, + 0x65, 0x73, 0xE2, 0x89, 0xBA, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65, + 0x73, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0xAA, 0xAF, 0x50, 0x72, 0x65, + 0x63, 0x65, 0x64, 0x65, 0x73, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71, + 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xBC, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64, + 0x65, 0x73, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xBE, 0x50, 0x72, + 0x69, 0x6D, 0x65, 0xE2, 0x80, 0xB3, 0x50, 0x72, 0x6F, 0x64, 0x75, 0x63, + 0x74, 0xE2, 0x88, 0x8F, 0x50, 0x72, 0x6F, 0x70, 0x6F, 0x72, 0x74, 0x69, + 0x6F, 0x6E, 0xE2, 0x88, 0xB7, 0x50, 0x72, 0x6F, 0x70, 0x6F, 0x72, 0x74, + 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0xE2, 0x88, 0x9D, 0x50, 0x73, 0x63, 0x72, + 0xF0, 0x9D, 0x92, 0xAB, 0x50, 0x73, 0x69, 0xCE, 0xA8, 0x51, 0x55, 0x4F, + 0x54, 0x22, 0x51, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x94, 0x51, 0x6F, 0x70, + 0x66, 0xE2, 0x84, 0x9A, 0x51, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xAC, + 0x52, 0x42, 0x61, 0x72, 0x72, 0xE2, 0xA4, 0x90, 0x52, 0x45, 0x47, 0xC2, + 0xAE, 0x52, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0x94, 0x52, 0x61, 0x6E, + 0x67, 0xE2, 0x9F, 0xAB, 0x52, 0x61, 0x72, 0x72, 0xE2, 0x86, 0xA0, 0x52, + 0x61, 0x72, 0x72, 0x74, 0x6C, 0xE2, 0xA4, 0x96, 0x52, 0x63, 0x61, 0x72, + 0x6F, 0x6E, 0xC5, 0x98, 0x52, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0x96, + 0x52, 0x63, 0x79, 0xD0, 0xA0, 0x52, 0x65, 0xE2, 0x84, 0x9C, 0x52, 0x65, + 0x76, 0x65, 0x72, 0x73, 0x65, 0x45, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, + 0xE2, 0x88, 0x8B, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x45, 0x71, + 0x75, 0x69, 0x6C, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6D, 0xE2, 0x87, 0x8B, + 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x55, 0x70, 0x45, 0x71, 0x75, + 0x69, 0x6C, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6D, 0xE2, 0xA5, 0xAF, 0x52, + 0x66, 0x72, 0xE2, 0x84, 0x9C, 0x52, 0x68, 0x6F, 0xCE, 0xA1, 0x52, 0x69, + 0x67, 0x68, 0x74, 0x41, 0x6E, 0x67, 0x6C, 0x65, 0x42, 0x72, 0x61, 0x63, + 0x6B, 0x65, 0x74, 0xE2, 0x9F, 0xA9, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, + 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x92, 0x52, 0x69, 0x67, 0x68, 0x74, + 0x41, 0x72, 0x72, 0x6F, 0x77, 0x42, 0x61, 0x72, 0xE2, 0x87, 0xA5, 0x52, + 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0x4C, 0x65, 0x66, + 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x84, 0x52, 0x69, 0x67, + 0x68, 0x74, 0x43, 0x65, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0xE2, 0x8C, 0x89, + 0x52, 0x69, 0x67, 0x68, 0x74, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x42, + 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0xE2, 0x9F, 0xA7, 0x52, 0x69, 0x67, + 0x68, 0x74, 0x44, 0x6F, 0x77, 0x6E, 0x54, 0x65, 0x65, 0x56, 0x65, 0x63, + 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x9D, 0x52, 0x69, 0x67, 0x68, 0x74, 0x44, + 0x6F, 0x77, 0x6E, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0x87, 0x82, + 0x52, 0x69, 0x67, 0x68, 0x74, 0x44, 0x6F, 0x77, 0x6E, 0x56, 0x65, 0x63, + 0x74, 0x6F, 0x72, 0x42, 0x61, 0x72, 0xE2, 0xA5, 0x95, 0x52, 0x69, 0x67, + 0x68, 0x74, 0x46, 0x6C, 0x6F, 0x6F, 0x72, 0xE2, 0x8C, 0x8B, 0x52, 0x69, + 0x67, 0x68, 0x74, 0x54, 0x65, 0x65, 0xE2, 0x8A, 0xA2, 0x52, 0x69, 0x67, + 0x68, 0x74, 0x54, 0x65, 0x65, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, + 0xA6, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, 0x65, 0x65, 0x56, 0x65, 0x63, + 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x9B, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, + 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x8A, 0xB3, 0x52, 0x69, + 0x67, 0x68, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x42, + 0x61, 0x72, 0xE2, 0xA7, 0x90, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, 0x72, + 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, + 0x8A, 0xB5, 0x52, 0x69, 0x67, 0x68, 0x74, 0x55, 0x70, 0x44, 0x6F, 0x77, + 0x6E, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x8F, 0x52, 0x69, + 0x67, 0x68, 0x74, 0x55, 0x70, 0x54, 0x65, 0x65, 0x56, 0x65, 0x63, 0x74, + 0x6F, 0x72, 0xE2, 0xA5, 0x9C, 0x52, 0x69, 0x67, 0x68, 0x74, 0x55, 0x70, + 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0x86, 0xBE, 0x52, 0x69, 0x67, + 0x68, 0x74, 0x55, 0x70, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x42, 0x61, + 0x72, 0xE2, 0xA5, 0x94, 0x52, 0x69, 0x67, 0x68, 0x74, 0x56, 0x65, 0x63, + 0x74, 0x6F, 0x72, 0xE2, 0x87, 0x80, 0x52, 0x69, 0x67, 0x68, 0x74, 0x56, + 0x65, 0x63, 0x74, 0x6F, 0x72, 0x42, 0x61, 0x72, 0xE2, 0xA5, 0x93, 0x52, + 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x92, + 0x52, 0x6F, 0x70, 0x66, 0xE2, 0x84, 0x9D, 0x52, 0x6F, 0x75, 0x6E, 0x64, + 0x49, 0x6D, 0x70, 0x6C, 0x69, 0x65, 0x73, 0xE2, 0xA5, 0xB0, 0x52, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x9B, + 0x52, 0x73, 0x63, 0x72, 0xE2, 0x84, 0x9B, 0x52, 0x73, 0x68, 0xE2, 0x86, + 0xB1, 0x52, 0x75, 0x6C, 0x65, 0x44, 0x65, 0x6C, 0x61, 0x79, 0x65, 0x64, + 0xE2, 0xA7, 0xB4, 0x53, 0x48, 0x43, 0x48, 0x63, 0x79, 0xD0, 0xA9, 0x53, + 0x48, 0x63, 0x79, 0xD0, 0xA8, 0x53, 0x4F, 0x46, 0x54, 0x63, 0x79, 0xD0, + 0xAC, 0x53, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0x9A, 0x53, 0x63, 0xE2, + 0xAA, 0xBC, 0x53, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5, 0xA0, 0x53, 0x63, + 0x65, 0x64, 0x69, 0x6C, 0xC5, 0x9E, 0x53, 0x63, 0x69, 0x72, 0x63, 0xC5, + 0x9C, 0x53, 0x63, 0x79, 0xD0, 0xA1, 0x53, 0x66, 0x72, 0xF0, 0x9D, 0x94, + 0x96, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72, + 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x93, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x4C, + 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x90, 0x53, + 0x68, 0x6F, 0x72, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, + 0x6F, 0x77, 0xE2, 0x86, 0x92, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x55, 0x70, + 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x91, 0x53, 0x69, 0x67, 0x6D, + 0x61, 0xCE, 0xA3, 0x53, 0x6D, 0x61, 0x6C, 0x6C, 0x43, 0x69, 0x72, 0x63, + 0x6C, 0x65, 0xE2, 0x88, 0x98, 0x53, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, + 0x8A, 0x53, 0x71, 0x72, 0x74, 0xE2, 0x88, 0x9A, 0x53, 0x71, 0x75, 0x61, + 0x72, 0x65, 0xE2, 0x96, 0xA1, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x49, + 0x6E, 0x74, 0x65, 0x72, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xE2, + 0x8A, 0x93, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53, 0x75, 0x62, 0x73, + 0x65, 0x74, 0xE2, 0x8A, 0x8F, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53, + 0x75, 0x62, 0x73, 0x65, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8A, + 0x91, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, + 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x90, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, + 0x53, 0x75, 0x70, 0x65, 0x72, 0x73, 0x65, 0x74, 0x45, 0x71, 0x75, 0x61, + 0x6C, 0xE2, 0x8A, 0x92, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x55, 0x6E, + 0x69, 0x6F, 0x6E, 0xE2, 0x8A, 0x94, 0x53, 0x73, 0x63, 0x72, 0xF0, 0x9D, + 0x92, 0xAE, 0x53, 0x74, 0x61, 0x72, 0xE2, 0x8B, 0x86, 0x53, 0x75, 0x62, + 0xE2, 0x8B, 0x90, 0x53, 0x75, 0x62, 0x73, 0x65, 0x74, 0xE2, 0x8B, 0x90, + 0x53, 0x75, 0x62, 0x73, 0x65, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, + 0x8A, 0x86, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x73, 0xE2, 0x89, + 0xBB, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x73, 0x45, 0x71, 0x75, + 0x61, 0x6C, 0xE2, 0xAA, 0xB0, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, + 0x73, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, + 0x89, 0xBD, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x73, 0x54, 0x69, + 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xBF, 0x53, 0x75, 0x63, 0x68, 0x54, 0x68, + 0x61, 0x74, 0xE2, 0x88, 0x8B, 0x53, 0x75, 0x6D, 0xE2, 0x88, 0x91, 0x53, + 0x75, 0x70, 0xE2, 0x8B, 0x91, 0x53, 0x75, 0x70, 0x65, 0x72, 0x73, 0x65, + 0x74, 0xE2, 0x8A, 0x83, 0x53, 0x75, 0x70, 0x65, 0x72, 0x73, 0x65, 0x74, + 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8A, 0x87, 0x53, 0x75, 0x70, 0x73, + 0x65, 0x74, 0xE2, 0x8B, 0x91, 0x54, 0x48, 0x4F, 0x52, 0x4E, 0xC3, 0x9E, + 0x54, 0x52, 0x41, 0x44, 0x45, 0xE2, 0x84, 0xA2, 0x54, 0x53, 0x48, 0x63, + 0x79, 0xD0, 0x8B, 0x54, 0x53, 0x63, 0x79, 0xD0, 0xA6, 0x54, 0x61, 0x62, + 0x09, 0x54, 0x61, 0x75, 0xCE, 0xA4, 0x54, 0x63, 0x61, 0x72, 0x6F, 0x6E, + 0xC5, 0xA4, 0x54, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0xA2, 0x54, 0x63, + 0x79, 0xD0, 0xA2, 0x54, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x97, 0x54, 0x68, + 0x65, 0x72, 0x65, 0x66, 0x6F, 0x72, 0x65, 0xE2, 0x88, 0xB4, 0x54, 0x68, + 0x65, 0x74, 0x61, 0xCE, 0x98, 0x54, 0x68, 0x69, 0x63, 0x6B, 0x53, 0x70, + 0x61, 0x63, 0x65, 0xE2, 0x81, 0x9F, 0xE2, 0x80, 0x8A, 0x54, 0x68, 0x69, + 0x6E, 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, 0x80, 0x89, 0x54, 0x69, 0x6C, + 0x64, 0x65, 0xE2, 0x88, 0xBC, 0x54, 0x69, 0x6C, 0x64, 0x65, 0x45, 0x71, + 0x75, 0x61, 0x6C, 0xE2, 0x89, 0x83, 0x54, 0x69, 0x6C, 0x64, 0x65, 0x46, + 0x75, 0x6C, 0x6C, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0x85, 0x54, + 0x69, 0x6C, 0x64, 0x65, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0x88, + 0x54, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x8B, 0x54, 0x72, 0x69, 0x70, + 0x6C, 0x65, 0x44, 0x6F, 0x74, 0xE2, 0x83, 0x9B, 0x54, 0x73, 0x63, 0x72, + 0xF0, 0x9D, 0x92, 0xAF, 0x54, 0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC5, 0xA6, + 0x55, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, 0x9A, 0x55, 0x61, 0x72, 0x72, + 0xE2, 0x86, 0x9F, 0x55, 0x61, 0x72, 0x72, 0x6F, 0x63, 0x69, 0x72, 0xE2, + 0xA5, 0x89, 0x55, 0x62, 0x72, 0x63, 0x79, 0xD0, 0x8E, 0x55, 0x62, 0x72, + 0x65, 0x76, 0x65, 0xC5, 0xAC, 0x55, 0x63, 0x69, 0x72, 0x63, 0xC3, 0x9B, + 0x55, 0x63, 0x79, 0xD0, 0xA3, 0x55, 0x64, 0x62, 0x6C, 0x61, 0x63, 0xC5, + 0xB0, 0x55, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x98, 0x55, 0x67, 0x72, 0x61, + 0x76, 0x65, 0xC3, 0x99, 0x55, 0x6D, 0x61, 0x63, 0x72, 0xC5, 0xAA, 0x55, + 0x6E, 0x64, 0x65, 0x72, 0x42, 0x61, 0x72, 0x5F, 0x55, 0x6E, 0x64, 0x65, + 0x72, 0x42, 0x72, 0x61, 0x63, 0x65, 0xE2, 0x8F, 0x9F, 0x55, 0x6E, 0x64, + 0x65, 0x72, 0x42, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0xE2, 0x8E, 0xB5, + 0x55, 0x6E, 0x64, 0x65, 0x72, 0x50, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x68, + 0x65, 0x73, 0x69, 0x73, 0xE2, 0x8F, 0x9D, 0x55, 0x6E, 0x69, 0x6F, 0x6E, + 0xE2, 0x8B, 0x83, 0x55, 0x6E, 0x69, 0x6F, 0x6E, 0x50, 0x6C, 0x75, 0x73, + 0xE2, 0x8A, 0x8E, 0x55, 0x6F, 0x67, 0x6F, 0x6E, 0xC5, 0xB2, 0x55, 0x6F, + 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x8C, 0x55, 0x70, 0x41, 0x72, 0x72, 0x6F, + 0x77, 0xE2, 0x86, 0x91, 0x55, 0x70, 0x41, 0x72, 0x72, 0x6F, 0x77, 0x42, + 0x61, 0x72, 0xE2, 0xA4, 0x92, 0x55, 0x70, 0x41, 0x72, 0x72, 0x6F, 0x77, + 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x85, + 0x55, 0x70, 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, + 0x86, 0x95, 0x55, 0x70, 0x45, 0x71, 0x75, 0x69, 0x6C, 0x69, 0x62, 0x72, + 0x69, 0x75, 0x6D, 0xE2, 0xA5, 0xAE, 0x55, 0x70, 0x54, 0x65, 0x65, 0xE2, + 0x8A, 0xA5, 0x55, 0x70, 0x54, 0x65, 0x65, 0x41, 0x72, 0x72, 0x6F, 0x77, + 0xE2, 0x86, 0xA5, 0x55, 0x70, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, + 0x91, 0x55, 0x70, 0x64, 0x6F, 0x77, 0x6E, 0x61, 0x72, 0x72, 0x6F, 0x77, + 0xE2, 0x87, 0x95, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4C, 0x65, 0x66, 0x74, + 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x96, 0x55, 0x70, 0x70, 0x65, + 0x72, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, + 0x86, 0x97, 0x55, 0x70, 0x73, 0x69, 0xCF, 0x92, 0x55, 0x70, 0x73, 0x69, + 0x6C, 0x6F, 0x6E, 0xCE, 0xA5, 0x55, 0x72, 0x69, 0x6E, 0x67, 0xC5, 0xAE, + 0x55, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xB0, 0x55, 0x74, 0x69, 0x6C, + 0x64, 0x65, 0xC5, 0xA8, 0x55, 0x75, 0x6D, 0x6C, 0xC3, 0x9C, 0x56, 0x44, + 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAB, 0x56, 0x62, 0x61, 0x72, 0xE2, 0xAB, + 0xAB, 0x56, 0x63, 0x79, 0xD0, 0x92, 0x56, 0x64, 0x61, 0x73, 0x68, 0xE2, + 0x8A, 0xA9, 0x56, 0x64, 0x61, 0x73, 0x68, 0x6C, 0xE2, 0xAB, 0xA6, 0x56, + 0x65, 0x65, 0xE2, 0x8B, 0x81, 0x56, 0x65, 0x72, 0x62, 0x61, 0x72, 0xE2, + 0x80, 0x96, 0x56, 0x65, 0x72, 0x74, 0xE2, 0x80, 0x96, 0x56, 0x65, 0x72, + 0x74, 0x69, 0x63, 0x61, 0x6C, 0x42, 0x61, 0x72, 0xE2, 0x88, 0xA3, 0x56, + 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x4C, 0x69, 0x6E, 0x65, 0x7C, + 0x56, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x53, 0x65, 0x70, 0x61, + 0x72, 0x61, 0x74, 0x6F, 0x72, 0xE2, 0x9D, 0x98, 0x56, 0x65, 0x72, 0x74, + 0x69, 0x63, 0x61, 0x6C, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0x80, + 0x56, 0x65, 0x72, 0x79, 0x54, 0x68, 0x69, 0x6E, 0x53, 0x70, 0x61, 0x63, + 0x65, 0xE2, 0x80, 0x8A, 0x56, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x99, 0x56, + 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x8D, 0x56, 0x73, 0x63, 0x72, 0xF0, + 0x9D, 0x92, 0xB1, 0x56, 0x76, 0x64, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAA, + 0x57, 0x63, 0x69, 0x72, 0x63, 0xC5, 0xB4, 0x57, 0x65, 0x64, 0x67, 0x65, + 0xE2, 0x8B, 0x80, 0x57, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x9A, 0x57, 0x6F, + 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x8E, 0x57, 0x73, 0x63, 0x72, 0xF0, 0x9D, + 0x92, 0xB2, 0x58, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x9B, 0x58, 0x69, 0xCE, + 0x9E, 0x58, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x8F, 0x58, 0x73, 0x63, + 0x72, 0xF0, 0x9D, 0x92, 0xB3, 0x59, 0x41, 0x63, 0x79, 0xD0, 0xAF, 0x59, + 0x49, 0x63, 0x79, 0xD0, 0x87, 0x59, 0x55, 0x63, 0x79, 0xD0, 0xAE, 0x59, + 0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, 0x9D, 0x59, 0x63, 0x69, 0x72, 0x63, + 0xC5, 0xB6, 0x59, 0x63, 0x79, 0xD0, 0xAB, 0x59, 0x66, 0x72, 0xF0, 0x9D, + 0x94, 0x9C, 0x59, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x90, 0x59, 0x73, + 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xB4, 0x59, 0x75, 0x6D, 0x6C, 0xC5, 0xB8, + 0x5A, 0x48, 0x63, 0x79, 0xD0, 0x96, 0x5A, 0x61, 0x63, 0x75, 0x74, 0x65, + 0xC5, 0xB9, 0x5A, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5, 0xBD, 0x5A, 0x63, + 0x79, 0xD0, 0x97, 0x5A, 0x64, 0x6F, 0x74, 0xC5, 0xBB, 0x5A, 0x65, 0x72, + 0x6F, 0x57, 0x69, 0x64, 0x74, 0x68, 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, + 0x80, 0x8B, 0x5A, 0x65, 0x74, 0x61, 0xCE, 0x96, 0x5A, 0x66, 0x72, 0xE2, + 0x84, 0xA8, 0x5A, 0x6F, 0x70, 0x66, 0xE2, 0x84, 0xA4, 0x5A, 0x73, 0x63, + 0x72, 0xF0, 0x9D, 0x92, 0xB5, 0x61, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, + 0xA1, 0x61, 0x62, 0x72, 0x65, 0x76, 0x65, 0xC4, 0x83, 0x61, 0x63, 0xE2, + 0x88, 0xBE, 0x61, 0x63, 0x45, 0xE2, 0x88, 0xBE, 0xCC, 0xB3, 0x61, 0x63, + 0x64, 0xE2, 0x88, 0xBF, 0x61, 0x63, 0x69, 0x72, 0x63, 0xC3, 0xA2, 0x61, + 0x63, 0x75, 0x74, 0x65, 0xC2, 0xB4, 0x61, 0x63, 0x79, 0xD0, 0xB0, 0x61, + 0x65, 0x6C, 0x69, 0x67, 0xC3, 0xA6, 0x61, 0x66, 0xE2, 0x81, 0xA1, 0x61, + 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x9E, 0x61, 0x67, 0x72, 0x61, 0x76, 0x65, + 0xC3, 0xA0, 0x61, 0x6C, 0x65, 0x66, 0x73, 0x79, 0x6D, 0xE2, 0x84, 0xB5, + 0x61, 0x6C, 0x65, 0x70, 0x68, 0xE2, 0x84, 0xB5, 0x61, 0x6C, 0x70, 0x68, + 0x61, 0xCE, 0xB1, 0x61, 0x6D, 0x61, 0x63, 0x72, 0xC4, 0x81, 0x61, 0x6D, + 0x61, 0x6C, 0x67, 0xE2, 0xA8, 0xBF, 0x61, 0x6D, 0x70, 0x26, 0x61, 0x6E, + 0x64, 0xE2, 0x88, 0xA7, 0x61, 0x6E, 0x64, 0x61, 0x6E, 0x64, 0xE2, 0xA9, + 0x95, 0x61, 0x6E, 0x64, 0x64, 0xE2, 0xA9, 0x9C, 0x61, 0x6E, 0x64, 0x73, + 0x6C, 0x6F, 0x70, 0x65, 0xE2, 0xA9, 0x98, 0x61, 0x6E, 0x64, 0x76, 0xE2, + 0xA9, 0x9A, 0x61, 0x6E, 0x67, 0xE2, 0x88, 0xA0, 0x61, 0x6E, 0x67, 0x65, + 0xE2, 0xA6, 0xA4, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x88, 0xA0, 0x61, + 0x6E, 0x67, 0x6D, 0x73, 0x64, 0xE2, 0x88, 0xA1, 0x61, 0x6E, 0x67, 0x6D, + 0x73, 0x64, 0x61, 0x61, 0xE2, 0xA6, 0xA8, 0x61, 0x6E, 0x67, 0x6D, 0x73, + 0x64, 0x61, 0x62, 0xE2, 0xA6, 0xA9, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, + 0x61, 0x63, 0xE2, 0xA6, 0xAA, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, 0x61, + 0x64, 0xE2, 0xA6, 0xAB, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, 0x61, 0x65, + 0xE2, 0xA6, 0xAC, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, 0x61, 0x66, 0xE2, + 0xA6, 0xAD, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, 0x61, 0x67, 0xE2, 0xA6, + 0xAE, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, 0x61, 0x68, 0xE2, 0xA6, 0xAF, + 0x61, 0x6E, 0x67, 0x72, 0x74, 0xE2, 0x88, 0x9F, 0x61, 0x6E, 0x67, 0x72, + 0x74, 0x76, 0x62, 0xE2, 0x8A, 0xBE, 0x61, 0x6E, 0x67, 0x72, 0x74, 0x76, + 0x62, 0x64, 0xE2, 0xA6, 0x9D, 0x61, 0x6E, 0x67, 0x73, 0x70, 0x68, 0xE2, + 0x88, 0xA2, 0x61, 0x6E, 0x67, 0x73, 0x74, 0xC3, 0x85, 0x61, 0x6E, 0x67, + 0x7A, 0x61, 0x72, 0x72, 0xE2, 0x8D, 0xBC, 0x61, 0x6F, 0x67, 0x6F, 0x6E, + 0xC4, 0x85, 0x61, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x92, 0x61, 0x70, + 0xE2, 0x89, 0x88, 0x61, 0x70, 0x45, 0xE2, 0xA9, 0xB0, 0x61, 0x70, 0x61, + 0x63, 0x69, 0x72, 0xE2, 0xA9, 0xAF, 0x61, 0x70, 0x65, 0xE2, 0x89, 0x8A, + 0x61, 0x70, 0x69, 0x64, 0xE2, 0x89, 0x8B, 0x61, 0x70, 0x6F, 0x73, 0x27, + 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0xE2, 0x89, 0x88, 0x61, 0x70, 0x70, + 0x72, 0x6F, 0x78, 0x65, 0x71, 0xE2, 0x89, 0x8A, 0x61, 0x72, 0x69, 0x6E, + 0x67, 0xC3, 0xA5, 0x61, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xB6, 0x61, + 0x73, 0x74, 0x2A, 0x61, 0x73, 0x79, 0x6D, 0x70, 0xE2, 0x89, 0x88, 0x61, + 0x73, 0x79, 0x6D, 0x70, 0x65, 0x71, 0xE2, 0x89, 0x8D, 0x61, 0x74, 0x69, + 0x6C, 0x64, 0x65, 0xC3, 0xA3, 0x61, 0x75, 0x6D, 0x6C, 0xC3, 0xA4, 0x61, + 0x77, 0x63, 0x6F, 0x6E, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xB3, 0x61, 0x77, + 0x69, 0x6E, 0x74, 0xE2, 0xA8, 0x91, 0x62, 0x4E, 0x6F, 0x74, 0xE2, 0xAB, + 0xAD, 0x62, 0x61, 0x63, 0x6B, 0x63, 0x6F, 0x6E, 0x67, 0xE2, 0x89, 0x8C, + 0x62, 0x61, 0x63, 0x6B, 0x65, 0x70, 0x73, 0x69, 0x6C, 0x6F, 0x6E, 0xCF, + 0xB6, 0x62, 0x61, 0x63, 0x6B, 0x70, 0x72, 0x69, 0x6D, 0x65, 0xE2, 0x80, + 0xB5, 0x62, 0x61, 0x63, 0x6B, 0x73, 0x69, 0x6D, 0xE2, 0x88, 0xBD, 0x62, + 0x61, 0x63, 0x6B, 0x73, 0x69, 0x6D, 0x65, 0x71, 0xE2, 0x8B, 0x8D, 0x62, + 0x61, 0x72, 0x76, 0x65, 0x65, 0xE2, 0x8A, 0xBD, 0x62, 0x61, 0x72, 0x77, + 0x65, 0x64, 0xE2, 0x8C, 0x85, 0x62, 0x61, 0x72, 0x77, 0x65, 0x64, 0x67, + 0x65, 0xE2, 0x8C, 0x85, 0x62, 0x62, 0x72, 0x6B, 0xE2, 0x8E, 0xB5, 0x62, + 0x62, 0x72, 0x6B, 0x74, 0x62, 0x72, 0x6B, 0xE2, 0x8E, 0xB6, 0x62, 0x63, + 0x6F, 0x6E, 0x67, 0xE2, 0x89, 0x8C, 0x62, 0x63, 0x79, 0xD0, 0xB1, 0x62, + 0x64, 0x71, 0x75, 0x6F, 0xE2, 0x80, 0x9E, 0x62, 0x65, 0x63, 0x61, 0x75, + 0x73, 0xE2, 0x88, 0xB5, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0xE2, + 0x88, 0xB5, 0x62, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x76, 0xE2, 0xA6, 0xB0, + 0x62, 0x65, 0x70, 0x73, 0x69, 0xCF, 0xB6, 0x62, 0x65, 0x72, 0x6E, 0x6F, + 0x75, 0xE2, 0x84, 0xAC, 0x62, 0x65, 0x74, 0x61, 0xCE, 0xB2, 0x62, 0x65, + 0x74, 0x68, 0xE2, 0x84, 0xB6, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6E, + 0xE2, 0x89, 0xAC, 0x62, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x9F, 0x62, 0x69, + 0x67, 0x63, 0x61, 0x70, 0xE2, 0x8B, 0x82, 0x62, 0x69, 0x67, 0x63, 0x69, + 0x72, 0x63, 0xE2, 0x97, 0xAF, 0x62, 0x69, 0x67, 0x63, 0x75, 0x70, 0xE2, + 0x8B, 0x83, 0x62, 0x69, 0x67, 0x6F, 0x64, 0x6F, 0x74, 0xE2, 0xA8, 0x80, + 0x62, 0x69, 0x67, 0x6F, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA8, 0x81, 0x62, + 0x69, 0x67, 0x6F, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0xA8, 0x82, 0x62, + 0x69, 0x67, 0x73, 0x71, 0x63, 0x75, 0x70, 0xE2, 0xA8, 0x86, 0x62, 0x69, + 0x67, 0x73, 0x74, 0x61, 0x72, 0xE2, 0x98, 0x85, 0x62, 0x69, 0x67, 0x74, + 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x64, 0x6F, 0x77, 0x6E, 0xE2, + 0x96, 0xBD, 0x62, 0x69, 0x67, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, + 0x65, 0x75, 0x70, 0xE2, 0x96, 0xB3, 0x62, 0x69, 0x67, 0x75, 0x70, 0x6C, + 0x75, 0x73, 0xE2, 0xA8, 0x84, 0x62, 0x69, 0x67, 0x76, 0x65, 0x65, 0xE2, + 0x8B, 0x81, 0x62, 0x69, 0x67, 0x77, 0x65, 0x64, 0x67, 0x65, 0xE2, 0x8B, + 0x80, 0x62, 0x6B, 0x61, 0x72, 0x6F, 0x77, 0xE2, 0xA4, 0x8D, 0x62, 0x6C, + 0x61, 0x63, 0x6B, 0x6C, 0x6F, 0x7A, 0x65, 0x6E, 0x67, 0x65, 0xE2, 0xA7, + 0xAB, 0x62, 0x6C, 0x61, 0x63, 0x6B, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, + 0xE2, 0x96, 0xAA, 0x62, 0x6C, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x69, 0x61, + 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x96, 0xB4, 0x62, 0x6C, 0x61, 0x63, 0x6B, + 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x64, 0x6F, 0x77, 0x6E, + 0xE2, 0x96, 0xBE, 0x62, 0x6C, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x69, 0x61, + 0x6E, 0x67, 0x6C, 0x65, 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x97, 0x82, 0x62, + 0x6C, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, + 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2, 0x96, 0xB8, 0x62, 0x6C, 0x61, 0x6E, + 0x6B, 0xE2, 0x90, 0xA3, 0x62, 0x6C, 0x6B, 0x31, 0x32, 0xE2, 0x96, 0x92, + 0x62, 0x6C, 0x6B, 0x31, 0x34, 0xE2, 0x96, 0x91, 0x62, 0x6C, 0x6B, 0x33, + 0x34, 0xE2, 0x96, 0x93, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0xE2, 0x96, 0x88, + 0x62, 0x6E, 0x65, 0x3D, 0xE2, 0x83, 0xA5, 0x62, 0x6E, 0x65, 0x71, 0x75, + 0x69, 0x76, 0xE2, 0x89, 0xA1, 0xE2, 0x83, 0xA5, 0x62, 0x6E, 0x6F, 0x74, + 0xE2, 0x8C, 0x90, 0x62, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x93, 0x62, + 0x6F, 0x74, 0xE2, 0x8A, 0xA5, 0x62, 0x6F, 0x74, 0x74, 0x6F, 0x6D, 0xE2, + 0x8A, 0xA5, 0x62, 0x6F, 0x77, 0x74, 0x69, 0x65, 0xE2, 0x8B, 0x88, 0x62, + 0x6F, 0x78, 0x44, 0x4C, 0xE2, 0x95, 0x97, 0x62, 0x6F, 0x78, 0x44, 0x52, + 0xE2, 0x95, 0x94, 0x62, 0x6F, 0x78, 0x44, 0x6C, 0xE2, 0x95, 0x96, 0x62, + 0x6F, 0x78, 0x44, 0x72, 0xE2, 0x95, 0x93, 0x62, 0x6F, 0x78, 0x48, 0xE2, + 0x95, 0x90, 0x62, 0x6F, 0x78, 0x48, 0x44, 0xE2, 0x95, 0xA6, 0x62, 0x6F, + 0x78, 0x48, 0x55, 0xE2, 0x95, 0xA9, 0x62, 0x6F, 0x78, 0x48, 0x64, 0xE2, + 0x95, 0xA4, 0x62, 0x6F, 0x78, 0x48, 0x75, 0xE2, 0x95, 0xA7, 0x62, 0x6F, + 0x78, 0x55, 0x4C, 0xE2, 0x95, 0x9D, 0x62, 0x6F, 0x78, 0x55, 0x52, 0xE2, + 0x95, 0x9A, 0x62, 0x6F, 0x78, 0x55, 0x6C, 0xE2, 0x95, 0x9C, 0x62, 0x6F, + 0x78, 0x55, 0x72, 0xE2, 0x95, 0x99, 0x62, 0x6F, 0x78, 0x56, 0xE2, 0x95, + 0x91, 0x62, 0x6F, 0x78, 0x56, 0x48, 0xE2, 0x95, 0xAC, 0x62, 0x6F, 0x78, + 0x56, 0x4C, 0xE2, 0x95, 0xA3, 0x62, 0x6F, 0x78, 0x56, 0x52, 0xE2, 0x95, + 0xA0, 0x62, 0x6F, 0x78, 0x56, 0x68, 0xE2, 0x95, 0xAB, 0x62, 0x6F, 0x78, + 0x56, 0x6C, 0xE2, 0x95, 0xA2, 0x62, 0x6F, 0x78, 0x56, 0x72, 0xE2, 0x95, + 0x9F, 0x62, 0x6F, 0x78, 0x62, 0x6F, 0x78, 0xE2, 0xA7, 0x89, 0x62, 0x6F, + 0x78, 0x64, 0x4C, 0xE2, 0x95, 0x95, 0x62, 0x6F, 0x78, 0x64, 0x52, 0xE2, + 0x95, 0x92, 0x62, 0x6F, 0x78, 0x64, 0x6C, 0xE2, 0x94, 0x90, 0x62, 0x6F, + 0x78, 0x64, 0x72, 0xE2, 0x94, 0x8C, 0x62, 0x6F, 0x78, 0x68, 0xE2, 0x94, + 0x80, 0x62, 0x6F, 0x78, 0x68, 0x44, 0xE2, 0x95, 0xA5, 0x62, 0x6F, 0x78, + 0x68, 0x55, 0xE2, 0x95, 0xA8, 0x62, 0x6F, 0x78, 0x68, 0x64, 0xE2, 0x94, + 0xAC, 0x62, 0x6F, 0x78, 0x68, 0x75, 0xE2, 0x94, 0xB4, 0x62, 0x6F, 0x78, + 0x6D, 0x69, 0x6E, 0x75, 0x73, 0xE2, 0x8A, 0x9F, 0x62, 0x6F, 0x78, 0x70, + 0x6C, 0x75, 0x73, 0xE2, 0x8A, 0x9E, 0x62, 0x6F, 0x78, 0x74, 0x69, 0x6D, + 0x65, 0x73, 0xE2, 0x8A, 0xA0, 0x62, 0x6F, 0x78, 0x75, 0x4C, 0xE2, 0x95, + 0x9B, 0x62, 0x6F, 0x78, 0x75, 0x52, 0xE2, 0x95, 0x98, 0x62, 0x6F, 0x78, + 0x75, 0x6C, 0xE2, 0x94, 0x98, 0x62, 0x6F, 0x78, 0x75, 0x72, 0xE2, 0x94, + 0x94, 0x62, 0x6F, 0x78, 0x76, 0xE2, 0x94, 0x82, 0x62, 0x6F, 0x78, 0x76, + 0x48, 0xE2, 0x95, 0xAA, 0x62, 0x6F, 0x78, 0x76, 0x4C, 0xE2, 0x95, 0xA1, + 0x62, 0x6F, 0x78, 0x76, 0x52, 0xE2, 0x95, 0x9E, 0x62, 0x6F, 0x78, 0x76, + 0x68, 0xE2, 0x94, 0xBC, 0x62, 0x6F, 0x78, 0x76, 0x6C, 0xE2, 0x94, 0xA4, + 0x62, 0x6F, 0x78, 0x76, 0x72, 0xE2, 0x94, 0x9C, 0x62, 0x70, 0x72, 0x69, + 0x6D, 0x65, 0xE2, 0x80, 0xB5, 0x62, 0x72, 0x65, 0x76, 0x65, 0xCB, 0x98, + 0x62, 0x72, 0x76, 0x62, 0x61, 0x72, 0xC2, 0xA6, 0x62, 0x73, 0x63, 0x72, + 0xF0, 0x9D, 0x92, 0xB7, 0x62, 0x73, 0x65, 0x6D, 0x69, 0xE2, 0x81, 0x8F, + 0x62, 0x73, 0x69, 0x6D, 0xE2, 0x88, 0xBD, 0x62, 0x73, 0x69, 0x6D, 0x65, + 0xE2, 0x8B, 0x8D, 0x62, 0x73, 0x6F, 0x6C, 0x5C, 0x62, 0x73, 0x6F, 0x6C, + 0x62, 0xE2, 0xA7, 0x85, 0x62, 0x73, 0x6F, 0x6C, 0x68, 0x73, 0x75, 0x62, + 0xE2, 0x9F, 0x88, 0x62, 0x75, 0x6C, 0x6C, 0xE2, 0x80, 0xA2, 0x62, 0x75, + 0x6C, 0x6C, 0x65, 0x74, 0xE2, 0x80, 0xA2, 0x62, 0x75, 0x6D, 0x70, 0xE2, + 0x89, 0x8E, 0x62, 0x75, 0x6D, 0x70, 0x45, 0xE2, 0xAA, 0xAE, 0x62, 0x75, + 0x6D, 0x70, 0x65, 0xE2, 0x89, 0x8F, 0x62, 0x75, 0x6D, 0x70, 0x65, 0x71, + 0xE2, 0x89, 0x8F, 0x63, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC4, 0x87, 0x63, + 0x61, 0x70, 0xE2, 0x88, 0xA9, 0x63, 0x61, 0x70, 0x61, 0x6E, 0x64, 0xE2, + 0xA9, 0x84, 0x63, 0x61, 0x70, 0x62, 0x72, 0x63, 0x75, 0x70, 0xE2, 0xA9, + 0x89, 0x63, 0x61, 0x70, 0x63, 0x61, 0x70, 0xE2, 0xA9, 0x8B, 0x63, 0x61, + 0x70, 0x63, 0x75, 0x70, 0xE2, 0xA9, 0x87, 0x63, 0x61, 0x70, 0x64, 0x6F, + 0x74, 0xE2, 0xA9, 0x80, 0x63, 0x61, 0x70, 0x73, 0xE2, 0x88, 0xA9, 0xEF, + 0xB8, 0x80, 0x63, 0x61, 0x72, 0x65, 0x74, 0xE2, 0x81, 0x81, 0x63, 0x61, + 0x72, 0x6F, 0x6E, 0xCB, 0x87, 0x63, 0x63, 0x61, 0x70, 0x73, 0xE2, 0xA9, + 0x8D, 0x63, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC4, 0x8D, 0x63, 0x63, 0x65, + 0x64, 0x69, 0x6C, 0xC3, 0xA7, 0x63, 0x63, 0x69, 0x72, 0x63, 0xC4, 0x89, + 0x63, 0x63, 0x75, 0x70, 0x73, 0xE2, 0xA9, 0x8C, 0x63, 0x63, 0x75, 0x70, + 0x73, 0x73, 0x6D, 0xE2, 0xA9, 0x90, 0x63, 0x64, 0x6F, 0x74, 0xC4, 0x8B, + 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC2, 0xB8, 0x63, 0x65, 0x6D, 0x70, 0x74, + 0x79, 0x76, 0xE2, 0xA6, 0xB2, 0x63, 0x65, 0x6E, 0x74, 0xC2, 0xA2, 0x63, + 0x65, 0x6E, 0x74, 0x65, 0x72, 0x64, 0x6F, 0x74, 0xC2, 0xB7, 0x63, 0x66, + 0x72, 0xF0, 0x9D, 0x94, 0xA0, 0x63, 0x68, 0x63, 0x79, 0xD1, 0x87, 0x63, + 0x68, 0x65, 0x63, 0x6B, 0xE2, 0x9C, 0x93, 0x63, 0x68, 0x65, 0x63, 0x6B, + 0x6D, 0x61, 0x72, 0x6B, 0xE2, 0x9C, 0x93, 0x63, 0x68, 0x69, 0xCF, 0x87, + 0x63, 0x69, 0x72, 0xE2, 0x97, 0x8B, 0x63, 0x69, 0x72, 0x45, 0xE2, 0xA7, + 0x83, 0x63, 0x69, 0x72, 0x63, 0xCB, 0x86, 0x63, 0x69, 0x72, 0x63, 0x65, + 0x71, 0xE2, 0x89, 0x97, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x61, 0x72, + 0x72, 0x6F, 0x77, 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x86, 0xBA, 0x63, 0x69, + 0x72, 0x63, 0x6C, 0x65, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x72, 0x69, 0x67, + 0x68, 0x74, 0xE2, 0x86, 0xBB, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x64, + 0x52, 0xC2, 0xAE, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x64, 0x53, 0xE2, + 0x93, 0x88, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x64, 0x61, 0x73, 0x74, + 0xE2, 0x8A, 0x9B, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x64, 0x63, 0x69, + 0x72, 0x63, 0xE2, 0x8A, 0x9A, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x64, + 0x64, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0x9D, 0x63, 0x69, 0x72, 0x65, 0xE2, + 0x89, 0x97, 0x63, 0x69, 0x72, 0x66, 0x6E, 0x69, 0x6E, 0x74, 0xE2, 0xA8, + 0x90, 0x63, 0x69, 0x72, 0x6D, 0x69, 0x64, 0xE2, 0xAB, 0xAF, 0x63, 0x69, + 0x72, 0x73, 0x63, 0x69, 0x72, 0xE2, 0xA7, 0x82, 0x63, 0x6C, 0x75, 0x62, + 0x73, 0xE2, 0x99, 0xA3, 0x63, 0x6C, 0x75, 0x62, 0x73, 0x75, 0x69, 0x74, + 0xE2, 0x99, 0xA3, 0x63, 0x6F, 0x6C, 0x6F, 0x6E, 0x3A, 0x63, 0x6F, 0x6C, + 0x6F, 0x6E, 0x65, 0xE2, 0x89, 0x94, 0x63, 0x6F, 0x6C, 0x6F, 0x6E, 0x65, + 0x71, 0xE2, 0x89, 0x94, 0x63, 0x6F, 0x6D, 0x6D, 0x61, 0x2C, 0x63, 0x6F, + 0x6D, 0x6D, 0x61, 0x74, 0x40, 0x63, 0x6F, 0x6D, 0x70, 0xE2, 0x88, 0x81, + 0x63, 0x6F, 0x6D, 0x70, 0x66, 0x6E, 0xE2, 0x88, 0x98, 0x63, 0x6F, 0x6D, + 0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0xE2, 0x88, 0x81, 0x63, 0x6F, + 0x6D, 0x70, 0x6C, 0x65, 0x78, 0x65, 0x73, 0xE2, 0x84, 0x82, 0x63, 0x6F, + 0x6E, 0x67, 0xE2, 0x89, 0x85, 0x63, 0x6F, 0x6E, 0x67, 0x64, 0x6F, 0x74, + 0xE2, 0xA9, 0xAD, 0x63, 0x6F, 0x6E, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xAE, + 0x63, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x94, 0x63, 0x6F, 0x70, 0x72, + 0x6F, 0x64, 0xE2, 0x88, 0x90, 0x63, 0x6F, 0x70, 0x79, 0xC2, 0xA9, 0x63, + 0x6F, 0x70, 0x79, 0x73, 0x72, 0xE2, 0x84, 0x97, 0x63, 0x72, 0x61, 0x72, + 0x72, 0xE2, 0x86, 0xB5, 0x63, 0x72, 0x6F, 0x73, 0x73, 0xE2, 0x9C, 0x97, + 0x63, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xB8, 0x63, 0x73, 0x75, 0x62, + 0xE2, 0xAB, 0x8F, 0x63, 0x73, 0x75, 0x62, 0x65, 0xE2, 0xAB, 0x91, 0x63, + 0x73, 0x75, 0x70, 0xE2, 0xAB, 0x90, 0x63, 0x73, 0x75, 0x70, 0x65, 0xE2, + 0xAB, 0x92, 0x63, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0xAF, 0x63, 0x75, + 0x64, 0x61, 0x72, 0x72, 0x6C, 0xE2, 0xA4, 0xB8, 0x63, 0x75, 0x64, 0x61, + 0x72, 0x72, 0x72, 0xE2, 0xA4, 0xB5, 0x63, 0x75, 0x65, 0x70, 0x72, 0xE2, + 0x8B, 0x9E, 0x63, 0x75, 0x65, 0x73, 0x63, 0xE2, 0x8B, 0x9F, 0x63, 0x75, + 0x6C, 0x61, 0x72, 0x72, 0xE2, 0x86, 0xB6, 0x63, 0x75, 0x6C, 0x61, 0x72, + 0x72, 0x70, 0xE2, 0xA4, 0xBD, 0x63, 0x75, 0x70, 0xE2, 0x88, 0xAA, 0x63, + 0x75, 0x70, 0x62, 0x72, 0x63, 0x61, 0x70, 0xE2, 0xA9, 0x88, 0x63, 0x75, + 0x70, 0x63, 0x61, 0x70, 0xE2, 0xA9, 0x86, 0x63, 0x75, 0x70, 0x63, 0x75, + 0x70, 0xE2, 0xA9, 0x8A, 0x63, 0x75, 0x70, 0x64, 0x6F, 0x74, 0xE2, 0x8A, + 0x8D, 0x63, 0x75, 0x70, 0x6F, 0x72, 0xE2, 0xA9, 0x85, 0x63, 0x75, 0x70, + 0x73, 0xE2, 0x88, 0xAA, 0xEF, 0xB8, 0x80, 0x63, 0x75, 0x72, 0x61, 0x72, + 0x72, 0xE2, 0x86, 0xB7, 0x63, 0x75, 0x72, 0x61, 0x72, 0x72, 0x6D, 0xE2, + 0xA4, 0xBC, 0x63, 0x75, 0x72, 0x6C, 0x79, 0x65, 0x71, 0x70, 0x72, 0x65, + 0x63, 0xE2, 0x8B, 0x9E, 0x63, 0x75, 0x72, 0x6C, 0x79, 0x65, 0x71, 0x73, + 0x75, 0x63, 0x63, 0xE2, 0x8B, 0x9F, 0x63, 0x75, 0x72, 0x6C, 0x79, 0x76, + 0x65, 0x65, 0xE2, 0x8B, 0x8E, 0x63, 0x75, 0x72, 0x6C, 0x79, 0x77, 0x65, + 0x64, 0x67, 0x65, 0xE2, 0x8B, 0x8F, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, + 0xC2, 0xA4, 0x63, 0x75, 0x72, 0x76, 0x65, 0x61, 0x72, 0x72, 0x6F, 0x77, + 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x86, 0xB6, 0x63, 0x75, 0x72, 0x76, 0x65, + 0x61, 0x72, 0x72, 0x6F, 0x77, 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2, 0x86, + 0xB7, 0x63, 0x75, 0x76, 0x65, 0x65, 0xE2, 0x8B, 0x8E, 0x63, 0x75, 0x77, + 0x65, 0x64, 0xE2, 0x8B, 0x8F, 0x63, 0x77, 0x63, 0x6F, 0x6E, 0x69, 0x6E, + 0x74, 0xE2, 0x88, 0xB2, 0x63, 0x77, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xB1, + 0x63, 0x79, 0x6C, 0x63, 0x74, 0x79, 0xE2, 0x8C, 0xAD, 0x64, 0x41, 0x72, + 0x72, 0xE2, 0x87, 0x93, 0x64, 0x48, 0x61, 0x72, 0xE2, 0xA5, 0xA5, 0x64, + 0x61, 0x67, 0x67, 0x65, 0x72, 0xE2, 0x80, 0xA0, 0x64, 0x61, 0x6C, 0x65, + 0x74, 0x68, 0xE2, 0x84, 0xB8, 0x64, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x93, + 0x64, 0x61, 0x73, 0x68, 0xE2, 0x80, 0x90, 0x64, 0x61, 0x73, 0x68, 0x76, + 0xE2, 0x8A, 0xA3, 0x64, 0x62, 0x6B, 0x61, 0x72, 0x6F, 0x77, 0xE2, 0xA4, + 0x8F, 0x64, 0x62, 0x6C, 0x61, 0x63, 0xCB, 0x9D, 0x64, 0x63, 0x61, 0x72, + 0x6F, 0x6E, 0xC4, 0x8F, 0x64, 0x63, 0x79, 0xD0, 0xB4, 0x64, 0x64, 0xE2, + 0x85, 0x86, 0x64, 0x64, 0x61, 0x67, 0x67, 0x65, 0x72, 0xE2, 0x80, 0xA1, + 0x64, 0x64, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x8A, 0x64, 0x64, 0x6F, 0x74, + 0x73, 0x65, 0x71, 0xE2, 0xA9, 0xB7, 0x64, 0x65, 0x67, 0xC2, 0xB0, 0x64, + 0x65, 0x6C, 0x74, 0x61, 0xCE, 0xB4, 0x64, 0x65, 0x6D, 0x70, 0x74, 0x79, + 0x76, 0xE2, 0xA6, 0xB1, 0x64, 0x66, 0x69, 0x73, 0x68, 0x74, 0xE2, 0xA5, + 0xBF, 0x64, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA1, 0x64, 0x68, 0x61, 0x72, + 0x6C, 0xE2, 0x87, 0x83, 0x64, 0x68, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x82, + 0x64, 0x69, 0x61, 0x6D, 0xE2, 0x8B, 0x84, 0x64, 0x69, 0x61, 0x6D, 0x6F, + 0x6E, 0x64, 0xE2, 0x8B, 0x84, 0x64, 0x69, 0x61, 0x6D, 0x6F, 0x6E, 0x64, + 0x73, 0x75, 0x69, 0x74, 0xE2, 0x99, 0xA6, 0x64, 0x69, 0x61, 0x6D, 0x73, + 0xE2, 0x99, 0xA6, 0x64, 0x69, 0x65, 0xC2, 0xA8, 0x64, 0x69, 0x67, 0x61, + 0x6D, 0x6D, 0x61, 0xCF, 0x9D, 0x64, 0x69, 0x73, 0x69, 0x6E, 0xE2, 0x8B, + 0xB2, 0x64, 0x69, 0x76, 0xC3, 0xB7, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, + 0xC3, 0xB7, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, 0x6F, 0x6E, 0x74, 0x69, + 0x6D, 0x65, 0x73, 0xE2, 0x8B, 0x87, 0x64, 0x69, 0x76, 0x6F, 0x6E, 0x78, + 0xE2, 0x8B, 0x87, 0x64, 0x6A, 0x63, 0x79, 0xD1, 0x92, 0x64, 0x6C, 0x63, + 0x6F, 0x72, 0x6E, 0xE2, 0x8C, 0x9E, 0x64, 0x6C, 0x63, 0x72, 0x6F, 0x70, + 0xE2, 0x8C, 0x8D, 0x64, 0x6F, 0x6C, 0x6C, 0x61, 0x72, 0x24, 0x64, 0x6F, + 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x95, 0x64, 0x6F, 0x74, 0xCB, 0x99, 0x64, + 0x6F, 0x74, 0x65, 0x71, 0xE2, 0x89, 0x90, 0x64, 0x6F, 0x74, 0x65, 0x71, + 0x64, 0x6F, 0x74, 0xE2, 0x89, 0x91, 0x64, 0x6F, 0x74, 0x6D, 0x69, 0x6E, + 0x75, 0x73, 0xE2, 0x88, 0xB8, 0x64, 0x6F, 0x74, 0x70, 0x6C, 0x75, 0x73, + 0xE2, 0x88, 0x94, 0x64, 0x6F, 0x74, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, + 0xE2, 0x8A, 0xA1, 0x64, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x62, 0x61, 0x72, + 0x77, 0x65, 0x64, 0x67, 0x65, 0xE2, 0x8C, 0x86, 0x64, 0x6F, 0x77, 0x6E, + 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x93, 0x64, 0x6F, 0x77, 0x6E, + 0x64, 0x6F, 0x77, 0x6E, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x73, 0xE2, 0x87, + 0x8A, 0x64, 0x6F, 0x77, 0x6E, 0x68, 0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, + 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x87, 0x83, 0x64, 0x6F, 0x77, 0x6E, 0x68, + 0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2, + 0x87, 0x82, 0x64, 0x72, 0x62, 0x6B, 0x61, 0x72, 0x6F, 0x77, 0xE2, 0xA4, + 0x90, 0x64, 0x72, 0x63, 0x6F, 0x72, 0x6E, 0xE2, 0x8C, 0x9F, 0x64, 0x72, + 0x63, 0x72, 0x6F, 0x70, 0xE2, 0x8C, 0x8C, 0x64, 0x73, 0x63, 0x72, 0xF0, + 0x9D, 0x92, 0xB9, 0x64, 0x73, 0x63, 0x79, 0xD1, 0x95, 0x64, 0x73, 0x6F, + 0x6C, 0xE2, 0xA7, 0xB6, 0x64, 0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC4, 0x91, + 0x64, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0xB1, 0x64, 0x74, 0x72, 0x69, + 0xE2, 0x96, 0xBF, 0x64, 0x74, 0x72, 0x69, 0x66, 0xE2, 0x96, 0xBE, 0x64, + 0x75, 0x61, 0x72, 0x72, 0xE2, 0x87, 0xB5, 0x64, 0x75, 0x68, 0x61, 0x72, + 0xE2, 0xA5, 0xAF, 0x64, 0x77, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0xA6, + 0xA6, 0x64, 0x7A, 0x63, 0x79, 0xD1, 0x9F, 0x64, 0x7A, 0x69, 0x67, 0x72, + 0x61, 0x72, 0x72, 0xE2, 0x9F, 0xBF, 0x65, 0x44, 0x44, 0x6F, 0x74, 0xE2, + 0xA9, 0xB7, 0x65, 0x44, 0x6F, 0x74, 0xE2, 0x89, 0x91, 0x65, 0x61, 0x63, + 0x75, 0x74, 0x65, 0xC3, 0xA9, 0x65, 0x61, 0x73, 0x74, 0x65, 0x72, 0xE2, + 0xA9, 0xAE, 0x65, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC4, 0x9B, 0x65, 0x63, + 0x69, 0x72, 0xE2, 0x89, 0x96, 0x65, 0x63, 0x69, 0x72, 0x63, 0xC3, 0xAA, + 0x65, 0x63, 0x6F, 0x6C, 0x6F, 0x6E, 0xE2, 0x89, 0x95, 0x65, 0x63, 0x79, + 0xD1, 0x8D, 0x65, 0x64, 0x6F, 0x74, 0xC4, 0x97, 0x65, 0x65, 0xE2, 0x85, + 0x87, 0x65, 0x66, 0x44, 0x6F, 0x74, 0xE2, 0x89, 0x92, 0x65, 0x66, 0x72, + 0xF0, 0x9D, 0x94, 0xA2, 0x65, 0x67, 0xE2, 0xAA, 0x9A, 0x65, 0x67, 0x72, + 0x61, 0x76, 0x65, 0xC3, 0xA8, 0x65, 0x67, 0x73, 0xE2, 0xAA, 0x96, 0x65, + 0x67, 0x73, 0x64, 0x6F, 0x74, 0xE2, 0xAA, 0x98, 0x65, 0x6C, 0xE2, 0xAA, + 0x99, 0x65, 0x6C, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x73, 0xE2, 0x8F, 0xA7, + 0x65, 0x6C, 0x6C, 0xE2, 0x84, 0x93, 0x65, 0x6C, 0x73, 0xE2, 0xAA, 0x95, + 0x65, 0x6C, 0x73, 0x64, 0x6F, 0x74, 0xE2, 0xAA, 0x97, 0x65, 0x6D, 0x61, + 0x63, 0x72, 0xC4, 0x93, 0x65, 0x6D, 0x70, 0x74, 0x79, 0xE2, 0x88, 0x85, + 0x65, 0x6D, 0x70, 0x74, 0x79, 0x73, 0x65, 0x74, 0xE2, 0x88, 0x85, 0x65, + 0x6D, 0x70, 0x74, 0x79, 0x76, 0xE2, 0x88, 0x85, 0x65, 0x6D, 0x73, 0x70, + 0xE2, 0x80, 0x83, 0x65, 0x6D, 0x73, 0x70, 0x31, 0x33, 0xE2, 0x80, 0x84, + 0x65, 0x6D, 0x73, 0x70, 0x31, 0x34, 0xE2, 0x80, 0x85, 0x65, 0x6E, 0x67, + 0xC5, 0x8B, 0x65, 0x6E, 0x73, 0x70, 0xE2, 0x80, 0x82, 0x65, 0x6F, 0x67, + 0x6F, 0x6E, 0xC4, 0x99, 0x65, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x96, + 0x65, 0x70, 0x61, 0x72, 0xE2, 0x8B, 0x95, 0x65, 0x70, 0x61, 0x72, 0x73, + 0x6C, 0xE2, 0xA7, 0xA3, 0x65, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA9, 0xB1, + 0x65, 0x70, 0x73, 0x69, 0xCE, 0xB5, 0x65, 0x70, 0x73, 0x69, 0x6C, 0x6F, + 0x6E, 0xCE, 0xB5, 0x65, 0x70, 0x73, 0x69, 0x76, 0xCF, 0xB5, 0x65, 0x71, + 0x63, 0x69, 0x72, 0x63, 0xE2, 0x89, 0x96, 0x65, 0x71, 0x63, 0x6F, 0x6C, + 0x6F, 0x6E, 0xE2, 0x89, 0x95, 0x65, 0x71, 0x73, 0x69, 0x6D, 0xE2, 0x89, + 0x82, 0x65, 0x71, 0x73, 0x6C, 0x61, 0x6E, 0x74, 0x67, 0x74, 0x72, 0xE2, + 0xAA, 0x96, 0x65, 0x71, 0x73, 0x6C, 0x61, 0x6E, 0x74, 0x6C, 0x65, 0x73, + 0x73, 0xE2, 0xAA, 0x95, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x73, 0x3D, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0xE2, 0x89, 0x9F, 0x65, 0x71, 0x75, 0x69, + 0x76, 0xE2, 0x89, 0xA1, 0x65, 0x71, 0x75, 0x69, 0x76, 0x44, 0x44, 0xE2, + 0xA9, 0xB8, 0x65, 0x71, 0x76, 0x70, 0x61, 0x72, 0x73, 0x6C, 0xE2, 0xA7, + 0xA5, 0x65, 0x72, 0x44, 0x6F, 0x74, 0xE2, 0x89, 0x93, 0x65, 0x72, 0x61, + 0x72, 0x72, 0xE2, 0xA5, 0xB1, 0x65, 0x73, 0x63, 0x72, 0xE2, 0x84, 0xAF, + 0x65, 0x73, 0x64, 0x6F, 0x74, 0xE2, 0x89, 0x90, 0x65, 0x73, 0x69, 0x6D, + 0xE2, 0x89, 0x82, 0x65, 0x74, 0x61, 0xCE, 0xB7, 0x65, 0x74, 0x68, 0xC3, + 0xB0, 0x65, 0x75, 0x6D, 0x6C, 0xC3, 0xAB, 0x65, 0x75, 0x72, 0x6F, 0xE2, + 0x82, 0xAC, 0x65, 0x78, 0x63, 0x6C, 0x21, 0x65, 0x78, 0x69, 0x73, 0x74, + 0xE2, 0x88, 0x83, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x61, 0x74, 0x69, + 0x6F, 0x6E, 0xE2, 0x84, 0xB0, 0x65, 0x78, 0x70, 0x6F, 0x6E, 0x65, 0x6E, + 0x74, 0x69, 0x61, 0x6C, 0x65, 0xE2, 0x85, 0x87, 0x66, 0x61, 0x6C, 0x6C, + 0x69, 0x6E, 0x67, 0x64, 0x6F, 0x74, 0x73, 0x65, 0x71, 0xE2, 0x89, 0x92, + 0x66, 0x63, 0x79, 0xD1, 0x84, 0x66, 0x65, 0x6D, 0x61, 0x6C, 0x65, 0xE2, + 0x99, 0x80, 0x66, 0x66, 0x69, 0x6C, 0x69, 0x67, 0xEF, 0xAC, 0x83, 0x66, + 0x66, 0x6C, 0x69, 0x67, 0xEF, 0xAC, 0x80, 0x66, 0x66, 0x6C, 0x6C, 0x69, + 0x67, 0xEF, 0xAC, 0x84, 0x66, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA3, 0x66, + 0x69, 0x6C, 0x69, 0x67, 0xEF, 0xAC, 0x81, 0x66, 0x6A, 0x6C, 0x69, 0x67, + 0x66, 0x6A, 0x66, 0x6C, 0x61, 0x74, 0xE2, 0x99, 0xAD, 0x66, 0x6C, 0x6C, + 0x69, 0x67, 0xEF, 0xAC, 0x82, 0x66, 0x6C, 0x74, 0x6E, 0x73, 0xE2, 0x96, + 0xB1, 0x66, 0x6E, 0x6F, 0x66, 0xC6, 0x92, 0x66, 0x6F, 0x70, 0x66, 0xF0, + 0x9D, 0x95, 0x97, 0x66, 0x6F, 0x72, 0x61, 0x6C, 0x6C, 0xE2, 0x88, 0x80, + 0x66, 0x6F, 0x72, 0x6B, 0xE2, 0x8B, 0x94, 0x66, 0x6F, 0x72, 0x6B, 0x76, + 0xE2, 0xAB, 0x99, 0x66, 0x70, 0x61, 0x72, 0x74, 0x69, 0x6E, 0x74, 0xE2, + 0xA8, 0x8D, 0x66, 0x72, 0x61, 0x63, 0x31, 0x32, 0xC2, 0xBD, 0x66, 0x72, + 0x61, 0x63, 0x31, 0x33, 0xE2, 0x85, 0x93, 0x66, 0x72, 0x61, 0x63, 0x31, + 0x34, 0xC2, 0xBC, 0x66, 0x72, 0x61, 0x63, 0x31, 0x35, 0xE2, 0x85, 0x95, + 0x66, 0x72, 0x61, 0x63, 0x31, 0x36, 0xE2, 0x85, 0x99, 0x66, 0x72, 0x61, + 0x63, 0x31, 0x38, 0xE2, 0x85, 0x9B, 0x66, 0x72, 0x61, 0x63, 0x32, 0x33, + 0xE2, 0x85, 0x94, 0x66, 0x72, 0x61, 0x63, 0x32, 0x35, 0xE2, 0x85, 0x96, + 0x66, 0x72, 0x61, 0x63, 0x33, 0x34, 0xC2, 0xBE, 0x66, 0x72, 0x61, 0x63, + 0x33, 0x35, 0xE2, 0x85, 0x97, 0x66, 0x72, 0x61, 0x63, 0x33, 0x38, 0xE2, + 0x85, 0x9C, 0x66, 0x72, 0x61, 0x63, 0x34, 0x35, 0xE2, 0x85, 0x98, 0x66, + 0x72, 0x61, 0x63, 0x35, 0x36, 0xE2, 0x85, 0x9A, 0x66, 0x72, 0x61, 0x63, + 0x35, 0x38, 0xE2, 0x85, 0x9D, 0x66, 0x72, 0x61, 0x63, 0x37, 0x38, 0xE2, + 0x85, 0x9E, 0x66, 0x72, 0x61, 0x73, 0x6C, 0xE2, 0x81, 0x84, 0x66, 0x72, + 0x6F, 0x77, 0x6E, 0xE2, 0x8C, 0xA2, 0x66, 0x73, 0x63, 0x72, 0xF0, 0x9D, + 0x92, 0xBB, 0x67, 0x45, 0xE2, 0x89, 0xA7, 0x67, 0x45, 0x6C, 0xE2, 0xAA, + 0x8C, 0x67, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC7, 0xB5, 0x67, 0x61, 0x6D, + 0x6D, 0x61, 0xCE, 0xB3, 0x67, 0x61, 0x6D, 0x6D, 0x61, 0x64, 0xCF, 0x9D, + 0x67, 0x61, 0x70, 0xE2, 0xAA, 0x86, 0x67, 0x62, 0x72, 0x65, 0x76, 0x65, + 0xC4, 0x9F, 0x67, 0x63, 0x69, 0x72, 0x63, 0xC4, 0x9D, 0x67, 0x63, 0x79, + 0xD0, 0xB3, 0x67, 0x64, 0x6F, 0x74, 0xC4, 0xA1, 0x67, 0x65, 0xE2, 0x89, + 0xA5, 0x67, 0x65, 0x6C, 0xE2, 0x8B, 0x9B, 0x67, 0x65, 0x71, 0xE2, 0x89, + 0xA5, 0x67, 0x65, 0x71, 0x71, 0xE2, 0x89, 0xA7, 0x67, 0x65, 0x71, 0x73, + 0x6C, 0x61, 0x6E, 0x74, 0xE2, 0xA9, 0xBE, 0x67, 0x65, 0x73, 0xE2, 0xA9, + 0xBE, 0x67, 0x65, 0x73, 0x63, 0x63, 0xE2, 0xAA, 0xA9, 0x67, 0x65, 0x73, + 0x64, 0x6F, 0x74, 0xE2, 0xAA, 0x80, 0x67, 0x65, 0x73, 0x64, 0x6F, 0x74, + 0x6F, 0xE2, 0xAA, 0x82, 0x67, 0x65, 0x73, 0x64, 0x6F, 0x74, 0x6F, 0x6C, + 0xE2, 0xAA, 0x84, 0x67, 0x65, 0x73, 0x6C, 0xE2, 0x8B, 0x9B, 0xEF, 0xB8, + 0x80, 0x67, 0x65, 0x73, 0x6C, 0x65, 0x73, 0xE2, 0xAA, 0x94, 0x67, 0x66, + 0x72, 0xF0, 0x9D, 0x94, 0xA4, 0x67, 0x67, 0xE2, 0x89, 0xAB, 0x67, 0x67, + 0x67, 0xE2, 0x8B, 0x99, 0x67, 0x69, 0x6D, 0x65, 0x6C, 0xE2, 0x84, 0xB7, + 0x67, 0x6A, 0x63, 0x79, 0xD1, 0x93, 0x67, 0x6C, 0xE2, 0x89, 0xB7, 0x67, + 0x6C, 0x45, 0xE2, 0xAA, 0x92, 0x67, 0x6C, 0x61, 0xE2, 0xAA, 0xA5, 0x67, + 0x6C, 0x6A, 0xE2, 0xAA, 0xA4, 0x67, 0x6E, 0x45, 0xE2, 0x89, 0xA9, 0x67, + 0x6E, 0x61, 0x70, 0xE2, 0xAA, 0x8A, 0x67, 0x6E, 0x61, 0x70, 0x70, 0x72, + 0x6F, 0x78, 0xE2, 0xAA, 0x8A, 0x67, 0x6E, 0x65, 0xE2, 0xAA, 0x88, 0x67, + 0x6E, 0x65, 0x71, 0xE2, 0xAA, 0x88, 0x67, 0x6E, 0x65, 0x71, 0x71, 0xE2, + 0x89, 0xA9, 0x67, 0x6E, 0x73, 0x69, 0x6D, 0xE2, 0x8B, 0xA7, 0x67, 0x6F, + 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x98, 0x67, 0x72, 0x61, 0x76, 0x65, 0x60, + 0x67, 0x73, 0x63, 0x72, 0xE2, 0x84, 0x8A, 0x67, 0x73, 0x69, 0x6D, 0xE2, + 0x89, 0xB3, 0x67, 0x73, 0x69, 0x6D, 0x65, 0xE2, 0xAA, 0x8E, 0x67, 0x73, + 0x69, 0x6D, 0x6C, 0xE2, 0xAA, 0x90, 0x67, 0x74, 0x3E, 0x67, 0x74, 0x63, + 0x63, 0xE2, 0xAA, 0xA7, 0x67, 0x74, 0x63, 0x69, 0x72, 0xE2, 0xA9, 0xBA, + 0x67, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0x97, 0x67, 0x74, 0x6C, 0x50, + 0x61, 0x72, 0xE2, 0xA6, 0x95, 0x67, 0x74, 0x71, 0x75, 0x65, 0x73, 0x74, + 0xE2, 0xA9, 0xBC, 0x67, 0x74, 0x72, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, + 0xE2, 0xAA, 0x86, 0x67, 0x74, 0x72, 0x61, 0x72, 0x72, 0xE2, 0xA5, 0xB8, + 0x67, 0x74, 0x72, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0x97, 0x67, 0x74, 0x72, + 0x65, 0x71, 0x6C, 0x65, 0x73, 0x73, 0xE2, 0x8B, 0x9B, 0x67, 0x74, 0x72, + 0x65, 0x71, 0x71, 0x6C, 0x65, 0x73, 0x73, 0xE2, 0xAA, 0x8C, 0x67, 0x74, + 0x72, 0x6C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xB7, 0x67, 0x74, 0x72, 0x73, + 0x69, 0x6D, 0xE2, 0x89, 0xB3, 0x67, 0x76, 0x65, 0x72, 0x74, 0x6E, 0x65, + 0x71, 0x71, 0xE2, 0x89, 0xA9, 0xEF, 0xB8, 0x80, 0x67, 0x76, 0x6E, 0x45, + 0xE2, 0x89, 0xA9, 0xEF, 0xB8, 0x80, 0x68, 0x41, 0x72, 0x72, 0xE2, 0x87, + 0x94, 0x68, 0x61, 0x69, 0x72, 0x73, 0x70, 0xE2, 0x80, 0x8A, 0x68, 0x61, + 0x6C, 0x66, 0xC2, 0xBD, 0x68, 0x61, 0x6D, 0x69, 0x6C, 0x74, 0xE2, 0x84, + 0x8B, 0x68, 0x61, 0x72, 0x64, 0x63, 0x79, 0xD1, 0x8A, 0x68, 0x61, 0x72, + 0x72, 0xE2, 0x86, 0x94, 0x68, 0x61, 0x72, 0x72, 0x63, 0x69, 0x72, 0xE2, + 0xA5, 0x88, 0x68, 0x61, 0x72, 0x72, 0x77, 0xE2, 0x86, 0xAD, 0x68, 0x62, + 0x61, 0x72, 0xE2, 0x84, 0x8F, 0x68, 0x63, 0x69, 0x72, 0x63, 0xC4, 0xA5, + 0x68, 0x65, 0x61, 0x72, 0x74, 0x73, 0xE2, 0x99, 0xA5, 0x68, 0x65, 0x61, + 0x72, 0x74, 0x73, 0x75, 0x69, 0x74, 0xE2, 0x99, 0xA5, 0x68, 0x65, 0x6C, + 0x6C, 0x69, 0x70, 0xE2, 0x80, 0xA6, 0x68, 0x65, 0x72, 0x63, 0x6F, 0x6E, + 0xE2, 0x8A, 0xB9, 0x68, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA5, 0x68, 0x6B, + 0x73, 0x65, 0x61, 0x72, 0x6F, 0x77, 0xE2, 0xA4, 0xA5, 0x68, 0x6B, 0x73, + 0x77, 0x61, 0x72, 0x6F, 0x77, 0xE2, 0xA4, 0xA6, 0x68, 0x6F, 0x61, 0x72, + 0x72, 0xE2, 0x87, 0xBF, 0x68, 0x6F, 0x6D, 0x74, 0x68, 0x74, 0xE2, 0x88, + 0xBB, 0x68, 0x6F, 0x6F, 0x6B, 0x6C, 0x65, 0x66, 0x74, 0x61, 0x72, 0x72, + 0x6F, 0x77, 0xE2, 0x86, 0xA9, 0x68, 0x6F, 0x6F, 0x6B, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0xAA, 0x68, 0x6F, + 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x99, 0x68, 0x6F, 0x72, 0x62, 0x61, 0x72, + 0xE2, 0x80, 0x95, 0x68, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xBD, 0x68, + 0x73, 0x6C, 0x61, 0x73, 0x68, 0xE2, 0x84, 0x8F, 0x68, 0x73, 0x74, 0x72, + 0x6F, 0x6B, 0xC4, 0xA7, 0x68, 0x79, 0x62, 0x75, 0x6C, 0x6C, 0xE2, 0x81, + 0x83, 0x68, 0x79, 0x70, 0x68, 0x65, 0x6E, 0xE2, 0x80, 0x90, 0x69, 0x61, + 0x63, 0x75, 0x74, 0x65, 0xC3, 0xAD, 0x69, 0x63, 0xE2, 0x81, 0xA3, 0x69, + 0x63, 0x69, 0x72, 0x63, 0xC3, 0xAE, 0x69, 0x63, 0x79, 0xD0, 0xB8, 0x69, + 0x65, 0x63, 0x79, 0xD0, 0xB5, 0x69, 0x65, 0x78, 0x63, 0x6C, 0xC2, 0xA1, + 0x69, 0x66, 0x66, 0xE2, 0x87, 0x94, 0x69, 0x66, 0x72, 0xF0, 0x9D, 0x94, + 0xA6, 0x69, 0x67, 0x72, 0x61, 0x76, 0x65, 0xC3, 0xAC, 0x69, 0x69, 0xE2, + 0x85, 0x88, 0x69, 0x69, 0x69, 0x69, 0x6E, 0x74, 0xE2, 0xA8, 0x8C, 0x69, + 0x69, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xAD, 0x69, 0x69, 0x6E, 0x66, 0x69, + 0x6E, 0xE2, 0xA7, 0x9C, 0x69, 0x69, 0x6F, 0x74, 0x61, 0xE2, 0x84, 0xA9, + 0x69, 0x6A, 0x6C, 0x69, 0x67, 0xC4, 0xB3, 0x69, 0x6D, 0x61, 0x63, 0x72, + 0xC4, 0xAB, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xE2, 0x84, 0x91, 0x69, 0x6D, + 0x61, 0x67, 0x6C, 0x69, 0x6E, 0x65, 0xE2, 0x84, 0x90, 0x69, 0x6D, 0x61, + 0x67, 0x70, 0x61, 0x72, 0x74, 0xE2, 0x84, 0x91, 0x69, 0x6D, 0x61, 0x74, + 0x68, 0xC4, 0xB1, 0x69, 0x6D, 0x6F, 0x66, 0xE2, 0x8A, 0xB7, 0x69, 0x6D, + 0x70, 0x65, 0x64, 0xC6, 0xB5, 0x69, 0x6E, 0xE2, 0x88, 0x88, 0x69, 0x6E, + 0x63, 0x61, 0x72, 0x65, 0xE2, 0x84, 0x85, 0x69, 0x6E, 0x66, 0x69, 0x6E, + 0xE2, 0x88, 0x9E, 0x69, 0x6E, 0x66, 0x69, 0x6E, 0x74, 0x69, 0x65, 0xE2, + 0xA7, 0x9D, 0x69, 0x6E, 0x6F, 0x64, 0x6F, 0x74, 0xC4, 0xB1, 0x69, 0x6E, + 0x74, 0xE2, 0x88, 0xAB, 0x69, 0x6E, 0x74, 0x63, 0x61, 0x6C, 0xE2, 0x8A, + 0xBA, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x73, 0xE2, 0x84, 0xA4, + 0x69, 0x6E, 0x74, 0x65, 0x72, 0x63, 0x61, 0x6C, 0xE2, 0x8A, 0xBA, 0x69, + 0x6E, 0x74, 0x6C, 0x61, 0x72, 0x68, 0x6B, 0xE2, 0xA8, 0x97, 0x69, 0x6E, + 0x74, 0x70, 0x72, 0x6F, 0x64, 0xE2, 0xA8, 0xBC, 0x69, 0x6F, 0x63, 0x79, + 0xD1, 0x91, 0x69, 0x6F, 0x67, 0x6F, 0x6E, 0xC4, 0xAF, 0x69, 0x6F, 0x70, + 0x66, 0xF0, 0x9D, 0x95, 0x9A, 0x69, 0x6F, 0x74, 0x61, 0xCE, 0xB9, 0x69, + 0x70, 0x72, 0x6F, 0x64, 0xE2, 0xA8, 0xBC, 0x69, 0x71, 0x75, 0x65, 0x73, + 0x74, 0xC2, 0xBF, 0x69, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xBE, 0x69, + 0x73, 0x69, 0x6E, 0xE2, 0x88, 0x88, 0x69, 0x73, 0x69, 0x6E, 0x45, 0xE2, + 0x8B, 0xB9, 0x69, 0x73, 0x69, 0x6E, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0xB5, + 0x69, 0x73, 0x69, 0x6E, 0x73, 0xE2, 0x8B, 0xB4, 0x69, 0x73, 0x69, 0x6E, + 0x73, 0x76, 0xE2, 0x8B, 0xB3, 0x69, 0x73, 0x69, 0x6E, 0x76, 0xE2, 0x88, + 0x88, 0x69, 0x74, 0xE2, 0x81, 0xA2, 0x69, 0x74, 0x69, 0x6C, 0x64, 0x65, + 0xC4, 0xA9, 0x69, 0x75, 0x6B, 0x63, 0x79, 0xD1, 0x96, 0x69, 0x75, 0x6D, + 0x6C, 0xC3, 0xAF, 0x6A, 0x63, 0x69, 0x72, 0x63, 0xC4, 0xB5, 0x6A, 0x63, + 0x79, 0xD0, 0xB9, 0x6A, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA7, 0x6A, 0x6D, + 0x61, 0x74, 0x68, 0xC8, 0xB7, 0x6A, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, + 0x9B, 0x6A, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xBF, 0x6A, 0x73, 0x65, + 0x72, 0x63, 0x79, 0xD1, 0x98, 0x6A, 0x75, 0x6B, 0x63, 0x79, 0xD1, 0x94, + 0x6B, 0x61, 0x70, 0x70, 0x61, 0xCE, 0xBA, 0x6B, 0x61, 0x70, 0x70, 0x61, + 0x76, 0xCF, 0xB0, 0x6B, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC4, 0xB7, 0x6B, + 0x63, 0x79, 0xD0, 0xBA, 0x6B, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA8, 0x6B, + 0x67, 0x72, 0x65, 0x65, 0x6E, 0xC4, 0xB8, 0x6B, 0x68, 0x63, 0x79, 0xD1, + 0x85, 0x6B, 0x6A, 0x63, 0x79, 0xD1, 0x9C, 0x6B, 0x6F, 0x70, 0x66, 0xF0, + 0x9D, 0x95, 0x9C, 0x6B, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x80, 0x6C, + 0x41, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x9A, 0x6C, 0x41, 0x72, 0x72, 0xE2, + 0x87, 0x90, 0x6C, 0x41, 0x74, 0x61, 0x69, 0x6C, 0xE2, 0xA4, 0x9B, 0x6C, + 0x42, 0x61, 0x72, 0x72, 0xE2, 0xA4, 0x8E, 0x6C, 0x45, 0xE2, 0x89, 0xA6, + 0x6C, 0x45, 0x67, 0xE2, 0xAA, 0x8B, 0x6C, 0x48, 0x61, 0x72, 0xE2, 0xA5, + 0xA2, 0x6C, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC4, 0xBA, 0x6C, 0x61, 0x65, + 0x6D, 0x70, 0x74, 0x79, 0x76, 0xE2, 0xA6, 0xB4, 0x6C, 0x61, 0x67, 0x72, + 0x61, 0x6E, 0xE2, 0x84, 0x92, 0x6C, 0x61, 0x6D, 0x62, 0x64, 0x61, 0xCE, + 0xBB, 0x6C, 0x61, 0x6E, 0x67, 0xE2, 0x9F, 0xA8, 0x6C, 0x61, 0x6E, 0x67, + 0x64, 0xE2, 0xA6, 0x91, 0x6C, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x9F, + 0xA8, 0x6C, 0x61, 0x70, 0xE2, 0xAA, 0x85, 0x6C, 0x61, 0x71, 0x75, 0x6F, + 0xC2, 0xAB, 0x6C, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x90, 0x6C, 0x61, 0x72, + 0x72, 0x62, 0xE2, 0x87, 0xA4, 0x6C, 0x61, 0x72, 0x72, 0x62, 0x66, 0x73, + 0xE2, 0xA4, 0x9F, 0x6C, 0x61, 0x72, 0x72, 0x66, 0x73, 0xE2, 0xA4, 0x9D, + 0x6C, 0x61, 0x72, 0x72, 0x68, 0x6B, 0xE2, 0x86, 0xA9, 0x6C, 0x61, 0x72, + 0x72, 0x6C, 0x70, 0xE2, 0x86, 0xAB, 0x6C, 0x61, 0x72, 0x72, 0x70, 0x6C, + 0xE2, 0xA4, 0xB9, 0x6C, 0x61, 0x72, 0x72, 0x73, 0x69, 0x6D, 0xE2, 0xA5, + 0xB3, 0x6C, 0x61, 0x72, 0x72, 0x74, 0x6C, 0xE2, 0x86, 0xA2, 0x6C, 0x61, + 0x74, 0xE2, 0xAA, 0xAB, 0x6C, 0x61, 0x74, 0x61, 0x69, 0x6C, 0xE2, 0xA4, + 0x99, 0x6C, 0x61, 0x74, 0x65, 0xE2, 0xAA, 0xAD, 0x6C, 0x61, 0x74, 0x65, + 0x73, 0xE2, 0xAA, 0xAD, 0xEF, 0xB8, 0x80, 0x6C, 0x62, 0x61, 0x72, 0x72, + 0xE2, 0xA4, 0x8C, 0x6C, 0x62, 0x62, 0x72, 0x6B, 0xE2, 0x9D, 0xB2, 0x6C, + 0x62, 0x72, 0x61, 0x63, 0x65, 0x7B, 0x6C, 0x62, 0x72, 0x61, 0x63, 0x6B, + 0x5B, 0x6C, 0x62, 0x72, 0x6B, 0x65, 0xE2, 0xA6, 0x8B, 0x6C, 0x62, 0x72, + 0x6B, 0x73, 0x6C, 0x64, 0xE2, 0xA6, 0x8F, 0x6C, 0x62, 0x72, 0x6B, 0x73, + 0x6C, 0x75, 0xE2, 0xA6, 0x8D, 0x6C, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC4, + 0xBE, 0x6C, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC4, 0xBC, 0x6C, 0x63, 0x65, + 0x69, 0x6C, 0xE2, 0x8C, 0x88, 0x6C, 0x63, 0x75, 0x62, 0x7B, 0x6C, 0x63, + 0x79, 0xD0, 0xBB, 0x6C, 0x64, 0x63, 0x61, 0xE2, 0xA4, 0xB6, 0x6C, 0x64, + 0x71, 0x75, 0x6F, 0xE2, 0x80, 0x9C, 0x6C, 0x64, 0x71, 0x75, 0x6F, 0x72, + 0xE2, 0x80, 0x9E, 0x6C, 0x64, 0x72, 0x64, 0x68, 0x61, 0x72, 0xE2, 0xA5, + 0xA7, 0x6C, 0x64, 0x72, 0x75, 0x73, 0x68, 0x61, 0x72, 0xE2, 0xA5, 0x8B, + 0x6C, 0x64, 0x73, 0x68, 0xE2, 0x86, 0xB2, 0x6C, 0x65, 0xE2, 0x89, 0xA4, + 0x6C, 0x65, 0x66, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x90, + 0x6C, 0x65, 0x66, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x74, 0x61, 0x69, + 0x6C, 0xE2, 0x86, 0xA2, 0x6C, 0x65, 0x66, 0x74, 0x68, 0x61, 0x72, 0x70, + 0x6F, 0x6F, 0x6E, 0x64, 0x6F, 0x77, 0x6E, 0xE2, 0x86, 0xBD, 0x6C, 0x65, + 0x66, 0x74, 0x68, 0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, 0x75, 0x70, 0xE2, + 0x86, 0xBC, 0x6C, 0x65, 0x66, 0x74, 0x6C, 0x65, 0x66, 0x74, 0x61, 0x72, + 0x72, 0x6F, 0x77, 0x73, 0xE2, 0x87, 0x87, 0x6C, 0x65, 0x66, 0x74, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x94, + 0x6C, 0x65, 0x66, 0x74, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, + 0x6F, 0x77, 0x73, 0xE2, 0x87, 0x86, 0x6C, 0x65, 0x66, 0x74, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x68, 0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, 0x73, 0xE2, + 0x87, 0x8B, 0x6C, 0x65, 0x66, 0x74, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x71, 0x75, 0x69, 0x67, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0xAD, + 0x6C, 0x65, 0x66, 0x74, 0x74, 0x68, 0x72, 0x65, 0x65, 0x74, 0x69, 0x6D, + 0x65, 0x73, 0xE2, 0x8B, 0x8B, 0x6C, 0x65, 0x67, 0xE2, 0x8B, 0x9A, 0x6C, + 0x65, 0x71, 0xE2, 0x89, 0xA4, 0x6C, 0x65, 0x71, 0x71, 0xE2, 0x89, 0xA6, + 0x6C, 0x65, 0x71, 0x73, 0x6C, 0x61, 0x6E, 0x74, 0xE2, 0xA9, 0xBD, 0x6C, + 0x65, 0x73, 0xE2, 0xA9, 0xBD, 0x6C, 0x65, 0x73, 0x63, 0x63, 0xE2, 0xAA, + 0xA8, 0x6C, 0x65, 0x73, 0x64, 0x6F, 0x74, 0xE2, 0xA9, 0xBF, 0x6C, 0x65, + 0x73, 0x64, 0x6F, 0x74, 0x6F, 0xE2, 0xAA, 0x81, 0x6C, 0x65, 0x73, 0x64, + 0x6F, 0x74, 0x6F, 0x72, 0xE2, 0xAA, 0x83, 0x6C, 0x65, 0x73, 0x67, 0xE2, + 0x8B, 0x9A, 0xEF, 0xB8, 0x80, 0x6C, 0x65, 0x73, 0x67, 0x65, 0x73, 0xE2, + 0xAA, 0x93, 0x6C, 0x65, 0x73, 0x73, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, + 0xE2, 0xAA, 0x85, 0x6C, 0x65, 0x73, 0x73, 0x64, 0x6F, 0x74, 0xE2, 0x8B, + 0x96, 0x6C, 0x65, 0x73, 0x73, 0x65, 0x71, 0x67, 0x74, 0x72, 0xE2, 0x8B, + 0x9A, 0x6C, 0x65, 0x73, 0x73, 0x65, 0x71, 0x71, 0x67, 0x74, 0x72, 0xE2, + 0xAA, 0x8B, 0x6C, 0x65, 0x73, 0x73, 0x67, 0x74, 0x72, 0xE2, 0x89, 0xB6, + 0x6C, 0x65, 0x73, 0x73, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0xB2, 0x6C, 0x66, + 0x69, 0x73, 0x68, 0x74, 0xE2, 0xA5, 0xBC, 0x6C, 0x66, 0x6C, 0x6F, 0x6F, + 0x72, 0xE2, 0x8C, 0x8A, 0x6C, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA9, 0x6C, + 0x67, 0xE2, 0x89, 0xB6, 0x6C, 0x67, 0x45, 0xE2, 0xAA, 0x91, 0x6C, 0x68, + 0x61, 0x72, 0x64, 0xE2, 0x86, 0xBD, 0x6C, 0x68, 0x61, 0x72, 0x75, 0xE2, + 0x86, 0xBC, 0x6C, 0x68, 0x61, 0x72, 0x75, 0x6C, 0xE2, 0xA5, 0xAA, 0x6C, + 0x68, 0x62, 0x6C, 0x6B, 0xE2, 0x96, 0x84, 0x6C, 0x6A, 0x63, 0x79, 0xD1, + 0x99, 0x6C, 0x6C, 0xE2, 0x89, 0xAA, 0x6C, 0x6C, 0x61, 0x72, 0x72, 0xE2, + 0x87, 0x87, 0x6C, 0x6C, 0x63, 0x6F, 0x72, 0x6E, 0x65, 0x72, 0xE2, 0x8C, + 0x9E, 0x6C, 0x6C, 0x68, 0x61, 0x72, 0x64, 0xE2, 0xA5, 0xAB, 0x6C, 0x6C, + 0x74, 0x72, 0x69, 0xE2, 0x97, 0xBA, 0x6C, 0x6D, 0x69, 0x64, 0x6F, 0x74, + 0xC5, 0x80, 0x6C, 0x6D, 0x6F, 0x75, 0x73, 0x74, 0xE2, 0x8E, 0xB0, 0x6C, + 0x6D, 0x6F, 0x75, 0x73, 0x74, 0x61, 0x63, 0x68, 0x65, 0xE2, 0x8E, 0xB0, + 0x6C, 0x6E, 0x45, 0xE2, 0x89, 0xA8, 0x6C, 0x6E, 0x61, 0x70, 0xE2, 0xAA, + 0x89, 0x6C, 0x6E, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0xE2, 0xAA, 0x89, + 0x6C, 0x6E, 0x65, 0xE2, 0xAA, 0x87, 0x6C, 0x6E, 0x65, 0x71, 0xE2, 0xAA, + 0x87, 0x6C, 0x6E, 0x65, 0x71, 0x71, 0xE2, 0x89, 0xA8, 0x6C, 0x6E, 0x73, + 0x69, 0x6D, 0xE2, 0x8B, 0xA6, 0x6C, 0x6F, 0x61, 0x6E, 0x67, 0xE2, 0x9F, + 0xAC, 0x6C, 0x6F, 0x61, 0x72, 0x72, 0xE2, 0x87, 0xBD, 0x6C, 0x6F, 0x62, + 0x72, 0x6B, 0xE2, 0x9F, 0xA6, 0x6C, 0x6F, 0x6E, 0x67, 0x6C, 0x65, 0x66, + 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xB5, 0x6C, 0x6F, 0x6E, + 0x67, 0x6C, 0x65, 0x66, 0x74, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, + 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xB7, 0x6C, 0x6F, 0x6E, 0x67, 0x6D, 0x61, + 0x70, 0x73, 0x74, 0x6F, 0xE2, 0x9F, 0xBC, 0x6C, 0x6F, 0x6E, 0x67, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xB6, + 0x6C, 0x6F, 0x6F, 0x70, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x6C, 0x65, 0x66, + 0x74, 0xE2, 0x86, 0xAB, 0x6C, 0x6F, 0x6F, 0x70, 0x61, 0x72, 0x72, 0x6F, + 0x77, 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2, 0x86, 0xAC, 0x6C, 0x6F, 0x70, + 0x61, 0x72, 0xE2, 0xA6, 0x85, 0x6C, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, + 0x9D, 0x6C, 0x6F, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA8, 0xAD, 0x6C, 0x6F, + 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0xA8, 0xB4, 0x6C, 0x6F, 0x77, 0x61, + 0x73, 0x74, 0xE2, 0x88, 0x97, 0x6C, 0x6F, 0x77, 0x62, 0x61, 0x72, 0x5F, + 0x6C, 0x6F, 0x7A, 0xE2, 0x97, 0x8A, 0x6C, 0x6F, 0x7A, 0x65, 0x6E, 0x67, + 0x65, 0xE2, 0x97, 0x8A, 0x6C, 0x6F, 0x7A, 0x66, 0xE2, 0xA7, 0xAB, 0x6C, + 0x70, 0x61, 0x72, 0x28, 0x6C, 0x70, 0x61, 0x72, 0x6C, 0x74, 0xE2, 0xA6, + 0x93, 0x6C, 0x72, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x86, 0x6C, 0x72, 0x63, + 0x6F, 0x72, 0x6E, 0x65, 0x72, 0xE2, 0x8C, 0x9F, 0x6C, 0x72, 0x68, 0x61, + 0x72, 0xE2, 0x87, 0x8B, 0x6C, 0x72, 0x68, 0x61, 0x72, 0x64, 0xE2, 0xA5, + 0xAD, 0x6C, 0x72, 0x6D, 0xE2, 0x80, 0x8E, 0x6C, 0x72, 0x74, 0x72, 0x69, + 0xE2, 0x8A, 0xBF, 0x6C, 0x73, 0x61, 0x71, 0x75, 0x6F, 0xE2, 0x80, 0xB9, + 0x6C, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x81, 0x6C, 0x73, 0x68, 0xE2, + 0x86, 0xB0, 0x6C, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0xB2, 0x6C, 0x73, 0x69, + 0x6D, 0x65, 0xE2, 0xAA, 0x8D, 0x6C, 0x73, 0x69, 0x6D, 0x67, 0xE2, 0xAA, + 0x8F, 0x6C, 0x73, 0x71, 0x62, 0x5B, 0x6C, 0x73, 0x71, 0x75, 0x6F, 0xE2, + 0x80, 0x98, 0x6C, 0x73, 0x71, 0x75, 0x6F, 0x72, 0xE2, 0x80, 0x9A, 0x6C, + 0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC5, 0x82, 0x6C, 0x74, 0x3C, 0x6C, 0x74, + 0x63, 0x63, 0xE2, 0xAA, 0xA6, 0x6C, 0x74, 0x63, 0x69, 0x72, 0xE2, 0xA9, + 0xB9, 0x6C, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0x96, 0x6C, 0x74, 0x68, + 0x72, 0x65, 0x65, 0xE2, 0x8B, 0x8B, 0x6C, 0x74, 0x69, 0x6D, 0x65, 0x73, + 0xE2, 0x8B, 0x89, 0x6C, 0x74, 0x6C, 0x61, 0x72, 0x72, 0xE2, 0xA5, 0xB6, + 0x6C, 0x74, 0x71, 0x75, 0x65, 0x73, 0x74, 0xE2, 0xA9, 0xBB, 0x6C, 0x74, + 0x72, 0x50, 0x61, 0x72, 0xE2, 0xA6, 0x96, 0x6C, 0x74, 0x72, 0x69, 0xE2, + 0x97, 0x83, 0x6C, 0x74, 0x72, 0x69, 0x65, 0xE2, 0x8A, 0xB4, 0x6C, 0x74, + 0x72, 0x69, 0x66, 0xE2, 0x97, 0x82, 0x6C, 0x75, 0x72, 0x64, 0x73, 0x68, + 0x61, 0x72, 0xE2, 0xA5, 0x8A, 0x6C, 0x75, 0x72, 0x75, 0x68, 0x61, 0x72, + 0xE2, 0xA5, 0xA6, 0x6C, 0x76, 0x65, 0x72, 0x74, 0x6E, 0x65, 0x71, 0x71, + 0xE2, 0x89, 0xA8, 0xEF, 0xB8, 0x80, 0x6C, 0x76, 0x6E, 0x45, 0xE2, 0x89, + 0xA8, 0xEF, 0xB8, 0x80, 0x6D, 0x44, 0x44, 0x6F, 0x74, 0xE2, 0x88, 0xBA, + 0x6D, 0x61, 0x63, 0x72, 0xC2, 0xAF, 0x6D, 0x61, 0x6C, 0x65, 0xE2, 0x99, + 0x82, 0x6D, 0x61, 0x6C, 0x74, 0xE2, 0x9C, 0xA0, 0x6D, 0x61, 0x6C, 0x74, + 0x65, 0x73, 0x65, 0xE2, 0x9C, 0xA0, 0x6D, 0x61, 0x70, 0xE2, 0x86, 0xA6, + 0x6D, 0x61, 0x70, 0x73, 0x74, 0x6F, 0xE2, 0x86, 0xA6, 0x6D, 0x61, 0x70, + 0x73, 0x74, 0x6F, 0x64, 0x6F, 0x77, 0x6E, 0xE2, 0x86, 0xA7, 0x6D, 0x61, + 0x70, 0x73, 0x74, 0x6F, 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x86, 0xA4, 0x6D, + 0x61, 0x70, 0x73, 0x74, 0x6F, 0x75, 0x70, 0xE2, 0x86, 0xA5, 0x6D, 0x61, + 0x72, 0x6B, 0x65, 0x72, 0xE2, 0x96, 0xAE, 0x6D, 0x63, 0x6F, 0x6D, 0x6D, + 0x61, 0xE2, 0xA8, 0xA9, 0x6D, 0x63, 0x79, 0xD0, 0xBC, 0x6D, 0x64, 0x61, + 0x73, 0x68, 0xE2, 0x80, 0x94, 0x6D, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, + 0x64, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x88, 0xA1, 0x6D, 0x66, 0x72, + 0xF0, 0x9D, 0x94, 0xAA, 0x6D, 0x68, 0x6F, 0xE2, 0x84, 0xA7, 0x6D, 0x69, + 0x63, 0x72, 0x6F, 0xC2, 0xB5, 0x6D, 0x69, 0x64, 0xE2, 0x88, 0xA3, 0x6D, + 0x69, 0x64, 0x61, 0x73, 0x74, 0x2A, 0x6D, 0x69, 0x64, 0x63, 0x69, 0x72, + 0xE2, 0xAB, 0xB0, 0x6D, 0x69, 0x64, 0x64, 0x6F, 0x74, 0xC2, 0xB7, 0x6D, + 0x69, 0x6E, 0x75, 0x73, 0xE2, 0x88, 0x92, 0x6D, 0x69, 0x6E, 0x75, 0x73, + 0x62, 0xE2, 0x8A, 0x9F, 0x6D, 0x69, 0x6E, 0x75, 0x73, 0x64, 0xE2, 0x88, + 0xB8, 0x6D, 0x69, 0x6E, 0x75, 0x73, 0x64, 0x75, 0xE2, 0xA8, 0xAA, 0x6D, + 0x6C, 0x63, 0x70, 0xE2, 0xAB, 0x9B, 0x6D, 0x6C, 0x64, 0x72, 0xE2, 0x80, + 0xA6, 0x6D, 0x6E, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0x88, 0x93, 0x6D, 0x6F, + 0x64, 0x65, 0x6C, 0x73, 0xE2, 0x8A, 0xA7, 0x6D, 0x6F, 0x70, 0x66, 0xF0, + 0x9D, 0x95, 0x9E, 0x6D, 0x70, 0xE2, 0x88, 0x93, 0x6D, 0x73, 0x63, 0x72, + 0xF0, 0x9D, 0x93, 0x82, 0x6D, 0x73, 0x74, 0x70, 0x6F, 0x73, 0xE2, 0x88, + 0xBE, 0x6D, 0x75, 0xCE, 0xBC, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x6D, 0x61, + 0x70, 0xE2, 0x8A, 0xB8, 0x6D, 0x75, 0x6D, 0x61, 0x70, 0xE2, 0x8A, 0xB8, + 0x6E, 0x47, 0x67, 0xE2, 0x8B, 0x99, 0xCC, 0xB8, 0x6E, 0x47, 0x74, 0xE2, + 0x89, 0xAB, 0xE2, 0x83, 0x92, 0x6E, 0x47, 0x74, 0x76, 0xE2, 0x89, 0xAB, + 0xCC, 0xB8, 0x6E, 0x4C, 0x65, 0x66, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, + 0xE2, 0x87, 0x8D, 0x6E, 0x4C, 0x65, 0x66, 0x74, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x8E, 0x6E, 0x4C, 0x6C, + 0xE2, 0x8B, 0x98, 0xCC, 0xB8, 0x6E, 0x4C, 0x74, 0xE2, 0x89, 0xAA, 0xE2, + 0x83, 0x92, 0x6E, 0x4C, 0x74, 0x76, 0xE2, 0x89, 0xAA, 0xCC, 0xB8, 0x6E, + 0x52, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, + 0x8F, 0x6E, 0x56, 0x44, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAF, 0x6E, 0x56, + 0x64, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAE, 0x6E, 0x61, 0x62, 0x6C, 0x61, + 0xE2, 0x88, 0x87, 0x6E, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0x84, 0x6E, + 0x61, 0x6E, 0x67, 0xE2, 0x88, 0xA0, 0xE2, 0x83, 0x92, 0x6E, 0x61, 0x70, + 0xE2, 0x89, 0x89, 0x6E, 0x61, 0x70, 0x45, 0xE2, 0xA9, 0xB0, 0xCC, 0xB8, + 0x6E, 0x61, 0x70, 0x69, 0x64, 0xE2, 0x89, 0x8B, 0xCC, 0xB8, 0x6E, 0x61, + 0x70, 0x6F, 0x73, 0xC5, 0x89, 0x6E, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, + 0xE2, 0x89, 0x89, 0x6E, 0x61, 0x74, 0x75, 0x72, 0xE2, 0x99, 0xAE, 0x6E, + 0x61, 0x74, 0x75, 0x72, 0x61, 0x6C, 0xE2, 0x99, 0xAE, 0x6E, 0x61, 0x74, + 0x75, 0x72, 0x61, 0x6C, 0x73, 0xE2, 0x84, 0x95, 0x6E, 0x62, 0x73, 0x70, + 0xC2, 0xA0, 0x6E, 0x62, 0x75, 0x6D, 0x70, 0xE2, 0x89, 0x8E, 0xCC, 0xB8, + 0x6E, 0x62, 0x75, 0x6D, 0x70, 0x65, 0xE2, 0x89, 0x8F, 0xCC, 0xB8, 0x6E, + 0x63, 0x61, 0x70, 0xE2, 0xA9, 0x83, 0x6E, 0x63, 0x61, 0x72, 0x6F, 0x6E, + 0xC5, 0x88, 0x6E, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0x86, 0x6E, 0x63, + 0x6F, 0x6E, 0x67, 0xE2, 0x89, 0x87, 0x6E, 0x63, 0x6F, 0x6E, 0x67, 0x64, + 0x6F, 0x74, 0xE2, 0xA9, 0xAD, 0xCC, 0xB8, 0x6E, 0x63, 0x75, 0x70, 0xE2, + 0xA9, 0x82, 0x6E, 0x63, 0x79, 0xD0, 0xBD, 0x6E, 0x64, 0x61, 0x73, 0x68, + 0xE2, 0x80, 0x93, 0x6E, 0x65, 0xE2, 0x89, 0xA0, 0x6E, 0x65, 0x41, 0x72, + 0x72, 0xE2, 0x87, 0x97, 0x6E, 0x65, 0x61, 0x72, 0x68, 0x6B, 0xE2, 0xA4, + 0xA4, 0x6E, 0x65, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x97, 0x6E, 0x65, 0x61, + 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x97, 0x6E, 0x65, 0x64, 0x6F, 0x74, + 0xE2, 0x89, 0x90, 0xCC, 0xB8, 0x6E, 0x65, 0x71, 0x75, 0x69, 0x76, 0xE2, + 0x89, 0xA2, 0x6E, 0x65, 0x73, 0x65, 0x61, 0x72, 0xE2, 0xA4, 0xA8, 0x6E, + 0x65, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0x82, 0xCC, 0xB8, 0x6E, 0x65, 0x78, + 0x69, 0x73, 0x74, 0xE2, 0x88, 0x84, 0x6E, 0x65, 0x78, 0x69, 0x73, 0x74, + 0x73, 0xE2, 0x88, 0x84, 0x6E, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xAB, 0x6E, + 0x67, 0x45, 0xE2, 0x89, 0xA7, 0xCC, 0xB8, 0x6E, 0x67, 0x65, 0xE2, 0x89, + 0xB1, 0x6E, 0x67, 0x65, 0x71, 0xE2, 0x89, 0xB1, 0x6E, 0x67, 0x65, 0x71, + 0x71, 0xE2, 0x89, 0xA7, 0xCC, 0xB8, 0x6E, 0x67, 0x65, 0x71, 0x73, 0x6C, + 0x61, 0x6E, 0x74, 0xE2, 0xA9, 0xBE, 0xCC, 0xB8, 0x6E, 0x67, 0x65, 0x73, + 0xE2, 0xA9, 0xBE, 0xCC, 0xB8, 0x6E, 0x67, 0x73, 0x69, 0x6D, 0xE2, 0x89, + 0xB5, 0x6E, 0x67, 0x74, 0xE2, 0x89, 0xAF, 0x6E, 0x67, 0x74, 0x72, 0xE2, + 0x89, 0xAF, 0x6E, 0x68, 0x41, 0x72, 0x72, 0xE2, 0x87, 0x8E, 0x6E, 0x68, + 0x61, 0x72, 0x72, 0xE2, 0x86, 0xAE, 0x6E, 0x68, 0x70, 0x61, 0x72, 0xE2, + 0xAB, 0xB2, 0x6E, 0x69, 0xE2, 0x88, 0x8B, 0x6E, 0x69, 0x73, 0xE2, 0x8B, + 0xBC, 0x6E, 0x69, 0x73, 0x64, 0xE2, 0x8B, 0xBA, 0x6E, 0x69, 0x76, 0xE2, + 0x88, 0x8B, 0x6E, 0x6A, 0x63, 0x79, 0xD1, 0x9A, 0x6E, 0x6C, 0x41, 0x72, + 0x72, 0xE2, 0x87, 0x8D, 0x6E, 0x6C, 0x45, 0xE2, 0x89, 0xA6, 0xCC, 0xB8, + 0x6E, 0x6C, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x9A, 0x6E, 0x6C, 0x64, 0x72, + 0xE2, 0x80, 0xA5, 0x6E, 0x6C, 0x65, 0xE2, 0x89, 0xB0, 0x6E, 0x6C, 0x65, + 0x66, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x9A, 0x6E, 0x6C, + 0x65, 0x66, 0x74, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, + 0x77, 0xE2, 0x86, 0xAE, 0x6E, 0x6C, 0x65, 0x71, 0xE2, 0x89, 0xB0, 0x6E, + 0x6C, 0x65, 0x71, 0x71, 0xE2, 0x89, 0xA6, 0xCC, 0xB8, 0x6E, 0x6C, 0x65, + 0x71, 0x73, 0x6C, 0x61, 0x6E, 0x74, 0xE2, 0xA9, 0xBD, 0xCC, 0xB8, 0x6E, + 0x6C, 0x65, 0x73, 0xE2, 0xA9, 0xBD, 0xCC, 0xB8, 0x6E, 0x6C, 0x65, 0x73, + 0x73, 0xE2, 0x89, 0xAE, 0x6E, 0x6C, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0xB4, + 0x6E, 0x6C, 0x74, 0xE2, 0x89, 0xAE, 0x6E, 0x6C, 0x74, 0x72, 0x69, 0xE2, + 0x8B, 0xAA, 0x6E, 0x6C, 0x74, 0x72, 0x69, 0x65, 0xE2, 0x8B, 0xAC, 0x6E, + 0x6D, 0x69, 0x64, 0xE2, 0x88, 0xA4, 0x6E, 0x6F, 0x70, 0x66, 0xF0, 0x9D, + 0x95, 0x9F, 0x6E, 0x6F, 0x74, 0xC2, 0xAC, 0x6E, 0x6F, 0x74, 0x69, 0x6E, + 0xE2, 0x88, 0x89, 0x6E, 0x6F, 0x74, 0x69, 0x6E, 0x45, 0xE2, 0x8B, 0xB9, + 0xCC, 0xB8, 0x6E, 0x6F, 0x74, 0x69, 0x6E, 0x64, 0x6F, 0x74, 0xE2, 0x8B, + 0xB5, 0xCC, 0xB8, 0x6E, 0x6F, 0x74, 0x69, 0x6E, 0x76, 0x61, 0xE2, 0x88, + 0x89, 0x6E, 0x6F, 0x74, 0x69, 0x6E, 0x76, 0x62, 0xE2, 0x8B, 0xB7, 0x6E, + 0x6F, 0x74, 0x69, 0x6E, 0x76, 0x63, 0xE2, 0x8B, 0xB6, 0x6E, 0x6F, 0x74, + 0x6E, 0x69, 0xE2, 0x88, 0x8C, 0x6E, 0x6F, 0x74, 0x6E, 0x69, 0x76, 0x61, + 0xE2, 0x88, 0x8C, 0x6E, 0x6F, 0x74, 0x6E, 0x69, 0x76, 0x62, 0xE2, 0x8B, + 0xBE, 0x6E, 0x6F, 0x74, 0x6E, 0x69, 0x76, 0x63, 0xE2, 0x8B, 0xBD, 0x6E, + 0x70, 0x61, 0x72, 0xE2, 0x88, 0xA6, 0x6E, 0x70, 0x61, 0x72, 0x61, 0x6C, + 0x6C, 0x65, 0x6C, 0xE2, 0x88, 0xA6, 0x6E, 0x70, 0x61, 0x72, 0x73, 0x6C, + 0xE2, 0xAB, 0xBD, 0xE2, 0x83, 0xA5, 0x6E, 0x70, 0x61, 0x72, 0x74, 0xE2, + 0x88, 0x82, 0xCC, 0xB8, 0x6E, 0x70, 0x6F, 0x6C, 0x69, 0x6E, 0x74, 0xE2, + 0xA8, 0x94, 0x6E, 0x70, 0x72, 0xE2, 0x8A, 0x80, 0x6E, 0x70, 0x72, 0x63, + 0x75, 0x65, 0xE2, 0x8B, 0xA0, 0x6E, 0x70, 0x72, 0x65, 0xE2, 0xAA, 0xAF, + 0xCC, 0xB8, 0x6E, 0x70, 0x72, 0x65, 0x63, 0xE2, 0x8A, 0x80, 0x6E, 0x70, + 0x72, 0x65, 0x63, 0x65, 0x71, 0xE2, 0xAA, 0xAF, 0xCC, 0xB8, 0x6E, 0x72, + 0x41, 0x72, 0x72, 0xE2, 0x87, 0x8F, 0x6E, 0x72, 0x61, 0x72, 0x72, 0xE2, + 0x86, 0x9B, 0x6E, 0x72, 0x61, 0x72, 0x72, 0x63, 0xE2, 0xA4, 0xB3, 0xCC, + 0xB8, 0x6E, 0x72, 0x61, 0x72, 0x72, 0x77, 0xE2, 0x86, 0x9D, 0xCC, 0xB8, + 0x6E, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, + 0x86, 0x9B, 0x6E, 0x72, 0x74, 0x72, 0x69, 0xE2, 0x8B, 0xAB, 0x6E, 0x72, + 0x74, 0x72, 0x69, 0x65, 0xE2, 0x8B, 0xAD, 0x6E, 0x73, 0x63, 0xE2, 0x8A, + 0x81, 0x6E, 0x73, 0x63, 0x63, 0x75, 0x65, 0xE2, 0x8B, 0xA1, 0x6E, 0x73, + 0x63, 0x65, 0xE2, 0xAA, 0xB0, 0xCC, 0xB8, 0x6E, 0x73, 0x63, 0x72, 0xF0, + 0x9D, 0x93, 0x83, 0x6E, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x6D, 0x69, 0x64, + 0xE2, 0x88, 0xA4, 0x6E, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x70, 0x61, 0x72, + 0x61, 0x6C, 0x6C, 0x65, 0x6C, 0xE2, 0x88, 0xA6, 0x6E, 0x73, 0x69, 0x6D, + 0xE2, 0x89, 0x81, 0x6E, 0x73, 0x69, 0x6D, 0x65, 0xE2, 0x89, 0x84, 0x6E, + 0x73, 0x69, 0x6D, 0x65, 0x71, 0xE2, 0x89, 0x84, 0x6E, 0x73, 0x6D, 0x69, + 0x64, 0xE2, 0x88, 0xA4, 0x6E, 0x73, 0x70, 0x61, 0x72, 0xE2, 0x88, 0xA6, + 0x6E, 0x73, 0x71, 0x73, 0x75, 0x62, 0x65, 0xE2, 0x8B, 0xA2, 0x6E, 0x73, + 0x71, 0x73, 0x75, 0x70, 0x65, 0xE2, 0x8B, 0xA3, 0x6E, 0x73, 0x75, 0x62, + 0xE2, 0x8A, 0x84, 0x6E, 0x73, 0x75, 0x62, 0x45, 0xE2, 0xAB, 0x85, 0xCC, + 0xB8, 0x6E, 0x73, 0x75, 0x62, 0x65, 0xE2, 0x8A, 0x88, 0x6E, 0x73, 0x75, + 0x62, 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x82, 0xE2, 0x83, 0x92, 0x6E, 0x73, + 0x75, 0x62, 0x73, 0x65, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0x88, 0x6E, 0x73, + 0x75, 0x62, 0x73, 0x65, 0x74, 0x65, 0x71, 0x71, 0xE2, 0xAB, 0x85, 0xCC, + 0xB8, 0x6E, 0x73, 0x75, 0x63, 0x63, 0xE2, 0x8A, 0x81, 0x6E, 0x73, 0x75, + 0x63, 0x63, 0x65, 0x71, 0xE2, 0xAA, 0xB0, 0xCC, 0xB8, 0x6E, 0x73, 0x75, + 0x70, 0xE2, 0x8A, 0x85, 0x6E, 0x73, 0x75, 0x70, 0x45, 0xE2, 0xAB, 0x86, + 0xCC, 0xB8, 0x6E, 0x73, 0x75, 0x70, 0x65, 0xE2, 0x8A, 0x89, 0x6E, 0x73, + 0x75, 0x70, 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x83, 0xE2, 0x83, 0x92, 0x6E, + 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0x89, 0x6E, + 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x65, 0x71, 0x71, 0xE2, 0xAB, 0x86, + 0xCC, 0xB8, 0x6E, 0x74, 0x67, 0x6C, 0xE2, 0x89, 0xB9, 0x6E, 0x74, 0x69, + 0x6C, 0x64, 0x65, 0xC3, 0xB1, 0x6E, 0x74, 0x6C, 0x67, 0xE2, 0x89, 0xB8, + 0x6E, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x6C, 0x65, 0x66, + 0x74, 0xE2, 0x8B, 0xAA, 0x6E, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, + 0x65, 0x6C, 0x65, 0x66, 0x74, 0x65, 0x71, 0xE2, 0x8B, 0xAC, 0x6E, 0x74, + 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x72, 0x69, 0x67, 0x68, 0x74, + 0xE2, 0x8B, 0xAB, 0x6E, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x65, 0x71, 0xE2, 0x8B, 0xAD, 0x6E, 0x75, + 0xCE, 0xBD, 0x6E, 0x75, 0x6D, 0x23, 0x6E, 0x75, 0x6D, 0x65, 0x72, 0x6F, + 0xE2, 0x84, 0x96, 0x6E, 0x75, 0x6D, 0x73, 0x70, 0xE2, 0x80, 0x87, 0x6E, + 0x76, 0x44, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAD, 0x6E, 0x76, 0x48, 0x61, + 0x72, 0x72, 0xE2, 0xA4, 0x84, 0x6E, 0x76, 0x61, 0x70, 0xE2, 0x89, 0x8D, + 0xE2, 0x83, 0x92, 0x6E, 0x76, 0x64, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAC, + 0x6E, 0x76, 0x67, 0x65, 0xE2, 0x89, 0xA5, 0xE2, 0x83, 0x92, 0x6E, 0x76, + 0x67, 0x74, 0x3E, 0xE2, 0x83, 0x92, 0x6E, 0x76, 0x69, 0x6E, 0x66, 0x69, + 0x6E, 0xE2, 0xA7, 0x9E, 0x6E, 0x76, 0x6C, 0x41, 0x72, 0x72, 0xE2, 0xA4, + 0x82, 0x6E, 0x76, 0x6C, 0x65, 0xE2, 0x89, 0xA4, 0xE2, 0x83, 0x92, 0x6E, + 0x76, 0x6C, 0x74, 0x3C, 0xE2, 0x83, 0x92, 0x6E, 0x76, 0x6C, 0x74, 0x72, + 0x69, 0x65, 0xE2, 0x8A, 0xB4, 0xE2, 0x83, 0x92, 0x6E, 0x76, 0x72, 0x41, + 0x72, 0x72, 0xE2, 0xA4, 0x83, 0x6E, 0x76, 0x72, 0x74, 0x72, 0x69, 0x65, + 0xE2, 0x8A, 0xB5, 0xE2, 0x83, 0x92, 0x6E, 0x76, 0x73, 0x69, 0x6D, 0xE2, + 0x88, 0xBC, 0xE2, 0x83, 0x92, 0x6E, 0x77, 0x41, 0x72, 0x72, 0xE2, 0x87, + 0x96, 0x6E, 0x77, 0x61, 0x72, 0x68, 0x6B, 0xE2, 0xA4, 0xA3, 0x6E, 0x77, + 0x61, 0x72, 0x72, 0xE2, 0x86, 0x96, 0x6E, 0x77, 0x61, 0x72, 0x72, 0x6F, + 0x77, 0xE2, 0x86, 0x96, 0x6E, 0x77, 0x6E, 0x65, 0x61, 0x72, 0xE2, 0xA4, + 0xA7, 0x6F, 0x53, 0xE2, 0x93, 0x88, 0x6F, 0x61, 0x63, 0x75, 0x74, 0x65, + 0xC3, 0xB3, 0x6F, 0x61, 0x73, 0x74, 0xE2, 0x8A, 0x9B, 0x6F, 0x63, 0x69, + 0x72, 0xE2, 0x8A, 0x9A, 0x6F, 0x63, 0x69, 0x72, 0x63, 0xC3, 0xB4, 0x6F, + 0x63, 0x79, 0xD0, 0xBE, 0x6F, 0x64, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0x9D, + 0x6F, 0x64, 0x62, 0x6C, 0x61, 0x63, 0xC5, 0x91, 0x6F, 0x64, 0x69, 0x76, + 0xE2, 0xA8, 0xB8, 0x6F, 0x64, 0x6F, 0x74, 0xE2, 0x8A, 0x99, 0x6F, 0x64, + 0x73, 0x6F, 0x6C, 0x64, 0xE2, 0xA6, 0xBC, 0x6F, 0x65, 0x6C, 0x69, 0x67, + 0xC5, 0x93, 0x6F, 0x66, 0x63, 0x69, 0x72, 0xE2, 0xA6, 0xBF, 0x6F, 0x66, + 0x72, 0xF0, 0x9D, 0x94, 0xAC, 0x6F, 0x67, 0x6F, 0x6E, 0xCB, 0x9B, 0x6F, + 0x67, 0x72, 0x61, 0x76, 0x65, 0xC3, 0xB2, 0x6F, 0x67, 0x74, 0xE2, 0xA7, + 0x81, 0x6F, 0x68, 0x62, 0x61, 0x72, 0xE2, 0xA6, 0xB5, 0x6F, 0x68, 0x6D, + 0xCE, 0xA9, 0x6F, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xAE, 0x6F, 0x6C, 0x61, + 0x72, 0x72, 0xE2, 0x86, 0xBA, 0x6F, 0x6C, 0x63, 0x69, 0x72, 0xE2, 0xA6, + 0xBE, 0x6F, 0x6C, 0x63, 0x72, 0x6F, 0x73, 0x73, 0xE2, 0xA6, 0xBB, 0x6F, + 0x6C, 0x69, 0x6E, 0x65, 0xE2, 0x80, 0xBE, 0x6F, 0x6C, 0x74, 0xE2, 0xA7, + 0x80, 0x6F, 0x6D, 0x61, 0x63, 0x72, 0xC5, 0x8D, 0x6F, 0x6D, 0x65, 0x67, + 0x61, 0xCF, 0x89, 0x6F, 0x6D, 0x69, 0x63, 0x72, 0x6F, 0x6E, 0xCE, 0xBF, + 0x6F, 0x6D, 0x69, 0x64, 0xE2, 0xA6, 0xB6, 0x6F, 0x6D, 0x69, 0x6E, 0x75, + 0x73, 0xE2, 0x8A, 0x96, 0x6F, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xA0, + 0x6F, 0x70, 0x61, 0x72, 0xE2, 0xA6, 0xB7, 0x6F, 0x70, 0x65, 0x72, 0x70, + 0xE2, 0xA6, 0xB9, 0x6F, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0x8A, 0x95, 0x6F, + 0x72, 0xE2, 0x88, 0xA8, 0x6F, 0x72, 0x61, 0x72, 0x72, 0xE2, 0x86, 0xBB, + 0x6F, 0x72, 0x64, 0xE2, 0xA9, 0x9D, 0x6F, 0x72, 0x64, 0x65, 0x72, 0xE2, + 0x84, 0xB4, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x6F, 0x66, 0xE2, 0x84, 0xB4, + 0x6F, 0x72, 0x64, 0x66, 0xC2, 0xAA, 0x6F, 0x72, 0x64, 0x6D, 0xC2, 0xBA, + 0x6F, 0x72, 0x69, 0x67, 0x6F, 0x66, 0xE2, 0x8A, 0xB6, 0x6F, 0x72, 0x6F, + 0x72, 0xE2, 0xA9, 0x96, 0x6F, 0x72, 0x73, 0x6C, 0x6F, 0x70, 0x65, 0xE2, + 0xA9, 0x97, 0x6F, 0x72, 0x76, 0xE2, 0xA9, 0x9B, 0x6F, 0x73, 0x63, 0x72, + 0xE2, 0x84, 0xB4, 0x6F, 0x73, 0x6C, 0x61, 0x73, 0x68, 0xC3, 0xB8, 0x6F, + 0x73, 0x6F, 0x6C, 0xE2, 0x8A, 0x98, 0x6F, 0x74, 0x69, 0x6C, 0x64, 0x65, + 0xC3, 0xB5, 0x6F, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0x8A, 0x97, 0x6F, + 0x74, 0x69, 0x6D, 0x65, 0x73, 0x61, 0x73, 0xE2, 0xA8, 0xB6, 0x6F, 0x75, + 0x6D, 0x6C, 0xC3, 0xB6, 0x6F, 0x76, 0x62, 0x61, 0x72, 0xE2, 0x8C, 0xBD, + 0x70, 0x61, 0x72, 0xE2, 0x88, 0xA5, 0x70, 0x61, 0x72, 0x61, 0xC2, 0xB6, + 0x70, 0x61, 0x72, 0x61, 0x6C, 0x6C, 0x65, 0x6C, 0xE2, 0x88, 0xA5, 0x70, + 0x61, 0x72, 0x73, 0x69, 0x6D, 0xE2, 0xAB, 0xB3, 0x70, 0x61, 0x72, 0x73, + 0x6C, 0xE2, 0xAB, 0xBD, 0x70, 0x61, 0x72, 0x74, 0xE2, 0x88, 0x82, 0x70, + 0x63, 0x79, 0xD0, 0xBF, 0x70, 0x65, 0x72, 0x63, 0x6E, 0x74, 0x25, 0x70, + 0x65, 0x72, 0x69, 0x6F, 0x64, 0x2E, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x6C, + 0xE2, 0x80, 0xB0, 0x70, 0x65, 0x72, 0x70, 0xE2, 0x8A, 0xA5, 0x70, 0x65, + 0x72, 0x74, 0x65, 0x6E, 0x6B, 0xE2, 0x80, 0xB1, 0x70, 0x66, 0x72, 0xF0, + 0x9D, 0x94, 0xAD, 0x70, 0x68, 0x69, 0xCF, 0x86, 0x70, 0x68, 0x69, 0x76, + 0xCF, 0x95, 0x70, 0x68, 0x6D, 0x6D, 0x61, 0x74, 0xE2, 0x84, 0xB3, 0x70, + 0x68, 0x6F, 0x6E, 0x65, 0xE2, 0x98, 0x8E, 0x70, 0x69, 0xCF, 0x80, 0x70, + 0x69, 0x74, 0x63, 0x68, 0x66, 0x6F, 0x72, 0x6B, 0xE2, 0x8B, 0x94, 0x70, + 0x69, 0x76, 0xCF, 0x96, 0x70, 0x6C, 0x61, 0x6E, 0x63, 0x6B, 0xE2, 0x84, + 0x8F, 0x70, 0x6C, 0x61, 0x6E, 0x63, 0x6B, 0x68, 0xE2, 0x84, 0x8E, 0x70, + 0x6C, 0x61, 0x6E, 0x6B, 0x76, 0xE2, 0x84, 0x8F, 0x70, 0x6C, 0x75, 0x73, + 0x2B, 0x70, 0x6C, 0x75, 0x73, 0x61, 0x63, 0x69, 0x72, 0xE2, 0xA8, 0xA3, + 0x70, 0x6C, 0x75, 0x73, 0x62, 0xE2, 0x8A, 0x9E, 0x70, 0x6C, 0x75, 0x73, + 0x63, 0x69, 0x72, 0xE2, 0xA8, 0xA2, 0x70, 0x6C, 0x75, 0x73, 0x64, 0x6F, + 0xE2, 0x88, 0x94, 0x70, 0x6C, 0x75, 0x73, 0x64, 0x75, 0xE2, 0xA8, 0xA5, + 0x70, 0x6C, 0x75, 0x73, 0x65, 0xE2, 0xA9, 0xB2, 0x70, 0x6C, 0x75, 0x73, + 0x6D, 0x6E, 0xC2, 0xB1, 0x70, 0x6C, 0x75, 0x73, 0x73, 0x69, 0x6D, 0xE2, + 0xA8, 0xA6, 0x70, 0x6C, 0x75, 0x73, 0x74, 0x77, 0x6F, 0xE2, 0xA8, 0xA7, + 0x70, 0x6D, 0xC2, 0xB1, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x69, 0x6E, 0x74, + 0xE2, 0xA8, 0x95, 0x70, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xA1, 0x70, + 0x6F, 0x75, 0x6E, 0x64, 0xC2, 0xA3, 0x70, 0x72, 0xE2, 0x89, 0xBA, 0x70, + 0x72, 0x45, 0xE2, 0xAA, 0xB3, 0x70, 0x72, 0x61, 0x70, 0xE2, 0xAA, 0xB7, + 0x70, 0x72, 0x63, 0x75, 0x65, 0xE2, 0x89, 0xBC, 0x70, 0x72, 0x65, 0xE2, + 0xAA, 0xAF, 0x70, 0x72, 0x65, 0x63, 0xE2, 0x89, 0xBA, 0x70, 0x72, 0x65, + 0x63, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0xE2, 0xAA, 0xB7, 0x70, 0x72, + 0x65, 0x63, 0x63, 0x75, 0x72, 0x6C, 0x79, 0x65, 0x71, 0xE2, 0x89, 0xBC, + 0x70, 0x72, 0x65, 0x63, 0x65, 0x71, 0xE2, 0xAA, 0xAF, 0x70, 0x72, 0x65, + 0x63, 0x6E, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0xE2, 0xAA, 0xB9, 0x70, + 0x72, 0x65, 0x63, 0x6E, 0x65, 0x71, 0x71, 0xE2, 0xAA, 0xB5, 0x70, 0x72, + 0x65, 0x63, 0x6E, 0x73, 0x69, 0x6D, 0xE2, 0x8B, 0xA8, 0x70, 0x72, 0x65, + 0x63, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0xBE, 0x70, 0x72, 0x69, 0x6D, 0x65, + 0xE2, 0x80, 0xB2, 0x70, 0x72, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0x84, 0x99, + 0x70, 0x72, 0x6E, 0x45, 0xE2, 0xAA, 0xB5, 0x70, 0x72, 0x6E, 0x61, 0x70, + 0xE2, 0xAA, 0xB9, 0x70, 0x72, 0x6E, 0x73, 0x69, 0x6D, 0xE2, 0x8B, 0xA8, + 0x70, 0x72, 0x6F, 0x64, 0xE2, 0x88, 0x8F, 0x70, 0x72, 0x6F, 0x66, 0x61, + 0x6C, 0x61, 0x72, 0xE2, 0x8C, 0xAE, 0x70, 0x72, 0x6F, 0x66, 0x6C, 0x69, + 0x6E, 0x65, 0xE2, 0x8C, 0x92, 0x70, 0x72, 0x6F, 0x66, 0x73, 0x75, 0x72, + 0x66, 0xE2, 0x8C, 0x93, 0x70, 0x72, 0x6F, 0x70, 0xE2, 0x88, 0x9D, 0x70, + 0x72, 0x6F, 0x70, 0x74, 0x6F, 0xE2, 0x88, 0x9D, 0x70, 0x72, 0x73, 0x69, + 0x6D, 0xE2, 0x89, 0xBE, 0x70, 0x72, 0x75, 0x72, 0x65, 0x6C, 0xE2, 0x8A, + 0xB0, 0x70, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x85, 0x70, 0x73, 0x69, + 0xCF, 0x88, 0x70, 0x75, 0x6E, 0x63, 0x73, 0x70, 0xE2, 0x80, 0x88, 0x71, + 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xAE, 0x71, 0x69, 0x6E, 0x74, 0xE2, 0xA8, + 0x8C, 0x71, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xA2, 0x71, 0x70, 0x72, + 0x69, 0x6D, 0x65, 0xE2, 0x81, 0x97, 0x71, 0x73, 0x63, 0x72, 0xF0, 0x9D, + 0x93, 0x86, 0x71, 0x75, 0x61, 0x74, 0x65, 0x72, 0x6E, 0x69, 0x6F, 0x6E, + 0x73, 0xE2, 0x84, 0x8D, 0x71, 0x75, 0x61, 0x74, 0x69, 0x6E, 0x74, 0xE2, + 0xA8, 0x96, 0x71, 0x75, 0x65, 0x73, 0x74, 0x3F, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x65, 0x71, 0xE2, 0x89, 0x9F, 0x71, 0x75, 0x6F, 0x74, 0x22, 0x72, + 0x41, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x9B, 0x72, 0x41, 0x72, 0x72, 0xE2, + 0x87, 0x92, 0x72, 0x41, 0x74, 0x61, 0x69, 0x6C, 0xE2, 0xA4, 0x9C, 0x72, + 0x42, 0x61, 0x72, 0x72, 0xE2, 0xA4, 0x8F, 0x72, 0x48, 0x61, 0x72, 0xE2, + 0xA5, 0xA4, 0x72, 0x61, 0x63, 0x65, 0xE2, 0x88, 0xBD, 0xCC, 0xB1, 0x72, + 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0x95, 0x72, 0x61, 0x64, 0x69, 0x63, + 0xE2, 0x88, 0x9A, 0x72, 0x61, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x76, 0xE2, + 0xA6, 0xB3, 0x72, 0x61, 0x6E, 0x67, 0xE2, 0x9F, 0xA9, 0x72, 0x61, 0x6E, + 0x67, 0x64, 0xE2, 0xA6, 0x92, 0x72, 0x61, 0x6E, 0x67, 0x65, 0xE2, 0xA6, + 0xA5, 0x72, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x9F, 0xA9, 0x72, 0x61, + 0x71, 0x75, 0x6F, 0xC2, 0xBB, 0x72, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x92, + 0x72, 0x61, 0x72, 0x72, 0x61, 0x70, 0xE2, 0xA5, 0xB5, 0x72, 0x61, 0x72, + 0x72, 0x62, 0xE2, 0x87, 0xA5, 0x72, 0x61, 0x72, 0x72, 0x62, 0x66, 0x73, + 0xE2, 0xA4, 0xA0, 0x72, 0x61, 0x72, 0x72, 0x63, 0xE2, 0xA4, 0xB3, 0x72, + 0x61, 0x72, 0x72, 0x66, 0x73, 0xE2, 0xA4, 0x9E, 0x72, 0x61, 0x72, 0x72, + 0x68, 0x6B, 0xE2, 0x86, 0xAA, 0x72, 0x61, 0x72, 0x72, 0x6C, 0x70, 0xE2, + 0x86, 0xAC, 0x72, 0x61, 0x72, 0x72, 0x70, 0x6C, 0xE2, 0xA5, 0x85, 0x72, + 0x61, 0x72, 0x72, 0x73, 0x69, 0x6D, 0xE2, 0xA5, 0xB4, 0x72, 0x61, 0x72, + 0x72, 0x74, 0x6C, 0xE2, 0x86, 0xA3, 0x72, 0x61, 0x72, 0x72, 0x77, 0xE2, + 0x86, 0x9D, 0x72, 0x61, 0x74, 0x61, 0x69, 0x6C, 0xE2, 0xA4, 0x9A, 0x72, + 0x61, 0x74, 0x69, 0x6F, 0xE2, 0x88, 0xB6, 0x72, 0x61, 0x74, 0x69, 0x6F, + 0x6E, 0x61, 0x6C, 0x73, 0xE2, 0x84, 0x9A, 0x72, 0x62, 0x61, 0x72, 0x72, + 0xE2, 0xA4, 0x8D, 0x72, 0x62, 0x62, 0x72, 0x6B, 0xE2, 0x9D, 0xB3, 0x72, + 0x62, 0x72, 0x61, 0x63, 0x65, 0x7D, 0x72, 0x62, 0x72, 0x61, 0x63, 0x6B, + 0x5D, 0x72, 0x62, 0x72, 0x6B, 0x65, 0xE2, 0xA6, 0x8C, 0x72, 0x62, 0x72, + 0x6B, 0x73, 0x6C, 0x64, 0xE2, 0xA6, 0x8E, 0x72, 0x62, 0x72, 0x6B, 0x73, + 0x6C, 0x75, 0xE2, 0xA6, 0x90, 0x72, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5, + 0x99, 0x72, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0x97, 0x72, 0x63, 0x65, + 0x69, 0x6C, 0xE2, 0x8C, 0x89, 0x72, 0x63, 0x75, 0x62, 0x7D, 0x72, 0x63, + 0x79, 0xD1, 0x80, 0x72, 0x64, 0x63, 0x61, 0xE2, 0xA4, 0xB7, 0x72, 0x64, + 0x6C, 0x64, 0x68, 0x61, 0x72, 0xE2, 0xA5, 0xA9, 0x72, 0x64, 0x71, 0x75, + 0x6F, 0xE2, 0x80, 0x9D, 0x72, 0x64, 0x71, 0x75, 0x6F, 0x72, 0xE2, 0x80, + 0x9D, 0x72, 0x64, 0x73, 0x68, 0xE2, 0x86, 0xB3, 0x72, 0x65, 0x61, 0x6C, + 0xE2, 0x84, 0x9C, 0x72, 0x65, 0x61, 0x6C, 0x69, 0x6E, 0x65, 0xE2, 0x84, + 0x9B, 0x72, 0x65, 0x61, 0x6C, 0x70, 0x61, 0x72, 0x74, 0xE2, 0x84, 0x9C, + 0x72, 0x65, 0x61, 0x6C, 0x73, 0xE2, 0x84, 0x9D, 0x72, 0x65, 0x63, 0x74, + 0xE2, 0x96, 0xAD, 0x72, 0x65, 0x67, 0xC2, 0xAE, 0x72, 0x66, 0x69, 0x73, + 0x68, 0x74, 0xE2, 0xA5, 0xBD, 0x72, 0x66, 0x6C, 0x6F, 0x6F, 0x72, 0xE2, + 0x8C, 0x8B, 0x72, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xAF, 0x72, 0x68, 0x61, + 0x72, 0x64, 0xE2, 0x87, 0x81, 0x72, 0x68, 0x61, 0x72, 0x75, 0xE2, 0x87, + 0x80, 0x72, 0x68, 0x61, 0x72, 0x75, 0x6C, 0xE2, 0xA5, 0xAC, 0x72, 0x68, + 0x6F, 0xCF, 0x81, 0x72, 0x68, 0x6F, 0x76, 0xCF, 0xB1, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x92, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x74, 0x61, 0x69, 0x6C, + 0xE2, 0x86, 0xA3, 0x72, 0x69, 0x67, 0x68, 0x74, 0x68, 0x61, 0x72, 0x70, + 0x6F, 0x6F, 0x6E, 0x64, 0x6F, 0x77, 0x6E, 0xE2, 0x87, 0x81, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x68, 0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, 0x75, 0x70, + 0xE2, 0x87, 0x80, 0x72, 0x69, 0x67, 0x68, 0x74, 0x6C, 0x65, 0x66, 0x74, + 0x61, 0x72, 0x72, 0x6F, 0x77, 0x73, 0xE2, 0x87, 0x84, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x6C, 0x65, 0x66, 0x74, 0x68, 0x61, 0x72, 0x70, 0x6F, 0x6F, + 0x6E, 0x73, 0xE2, 0x87, 0x8C, 0x72, 0x69, 0x67, 0x68, 0x74, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x73, 0xE2, 0x87, 0x89, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x71, 0x75, 0x69, 0x67, 0x61, 0x72, + 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x9D, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x68, 0x72, 0x65, 0x65, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0x8B, 0x8C, + 0x72, 0x69, 0x6E, 0x67, 0xCB, 0x9A, 0x72, 0x69, 0x73, 0x69, 0x6E, 0x67, + 0x64, 0x6F, 0x74, 0x73, 0x65, 0x71, 0xE2, 0x89, 0x93, 0x72, 0x6C, 0x61, + 0x72, 0x72, 0xE2, 0x87, 0x84, 0x72, 0x6C, 0x68, 0x61, 0x72, 0xE2, 0x87, + 0x8C, 0x72, 0x6C, 0x6D, 0xE2, 0x80, 0x8F, 0x72, 0x6D, 0x6F, 0x75, 0x73, + 0x74, 0xE2, 0x8E, 0xB1, 0x72, 0x6D, 0x6F, 0x75, 0x73, 0x74, 0x61, 0x63, + 0x68, 0x65, 0xE2, 0x8E, 0xB1, 0x72, 0x6E, 0x6D, 0x69, 0x64, 0xE2, 0xAB, + 0xAE, 0x72, 0x6F, 0x61, 0x6E, 0x67, 0xE2, 0x9F, 0xAD, 0x72, 0x6F, 0x61, + 0x72, 0x72, 0xE2, 0x87, 0xBE, 0x72, 0x6F, 0x62, 0x72, 0x6B, 0xE2, 0x9F, + 0xA7, 0x72, 0x6F, 0x70, 0x61, 0x72, 0xE2, 0xA6, 0x86, 0x72, 0x6F, 0x70, + 0x66, 0xF0, 0x9D, 0x95, 0xA3, 0x72, 0x6F, 0x70, 0x6C, 0x75, 0x73, 0xE2, + 0xA8, 0xAE, 0x72, 0x6F, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0xA8, 0xB5, + 0x72, 0x70, 0x61, 0x72, 0x29, 0x72, 0x70, 0x61, 0x72, 0x67, 0x74, 0xE2, + 0xA6, 0x94, 0x72, 0x70, 0x70, 0x6F, 0x6C, 0x69, 0x6E, 0x74, 0xE2, 0xA8, + 0x92, 0x72, 0x72, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x89, 0x72, 0x73, 0x61, + 0x71, 0x75, 0x6F, 0xE2, 0x80, 0xBA, 0x72, 0x73, 0x63, 0x72, 0xF0, 0x9D, + 0x93, 0x87, 0x72, 0x73, 0x68, 0xE2, 0x86, 0xB1, 0x72, 0x73, 0x71, 0x62, + 0x5D, 0x72, 0x73, 0x71, 0x75, 0x6F, 0xE2, 0x80, 0x99, 0x72, 0x73, 0x71, + 0x75, 0x6F, 0x72, 0xE2, 0x80, 0x99, 0x72, 0x74, 0x68, 0x72, 0x65, 0x65, + 0xE2, 0x8B, 0x8C, 0x72, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0x8B, 0x8A, + 0x72, 0x74, 0x72, 0x69, 0xE2, 0x96, 0xB9, 0x72, 0x74, 0x72, 0x69, 0x65, + 0xE2, 0x8A, 0xB5, 0x72, 0x74, 0x72, 0x69, 0x66, 0xE2, 0x96, 0xB8, 0x72, + 0x74, 0x72, 0x69, 0x6C, 0x74, 0x72, 0x69, 0xE2, 0xA7, 0x8E, 0x72, 0x75, + 0x6C, 0x75, 0x68, 0x61, 0x72, 0xE2, 0xA5, 0xA8, 0x72, 0x78, 0xE2, 0x84, + 0x9E, 0x73, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0x9B, 0x73, 0x62, 0x71, + 0x75, 0x6F, 0xE2, 0x80, 0x9A, 0x73, 0x63, 0xE2, 0x89, 0xBB, 0x73, 0x63, + 0x45, 0xE2, 0xAA, 0xB4, 0x73, 0x63, 0x61, 0x70, 0xE2, 0xAA, 0xB8, 0x73, + 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5, 0xA1, 0x73, 0x63, 0x63, 0x75, 0x65, + 0xE2, 0x89, 0xBD, 0x73, 0x63, 0x65, 0xE2, 0xAA, 0xB0, 0x73, 0x63, 0x65, + 0x64, 0x69, 0x6C, 0xC5, 0x9F, 0x73, 0x63, 0x69, 0x72, 0x63, 0xC5, 0x9D, + 0x73, 0x63, 0x6E, 0x45, 0xE2, 0xAA, 0xB6, 0x73, 0x63, 0x6E, 0x61, 0x70, + 0xE2, 0xAA, 0xBA, 0x73, 0x63, 0x6E, 0x73, 0x69, 0x6D, 0xE2, 0x8B, 0xA9, + 0x73, 0x63, 0x70, 0x6F, 0x6C, 0x69, 0x6E, 0x74, 0xE2, 0xA8, 0x93, 0x73, + 0x63, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0xBF, 0x73, 0x63, 0x79, 0xD1, 0x81, + 0x73, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0x85, 0x73, 0x64, 0x6F, 0x74, 0x62, + 0xE2, 0x8A, 0xA1, 0x73, 0x64, 0x6F, 0x74, 0x65, 0xE2, 0xA9, 0xA6, 0x73, + 0x65, 0x41, 0x72, 0x72, 0xE2, 0x87, 0x98, 0x73, 0x65, 0x61, 0x72, 0x68, + 0x6B, 0xE2, 0xA4, 0xA5, 0x73, 0x65, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x98, + 0x73, 0x65, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x98, 0x73, 0x65, + 0x63, 0x74, 0xC2, 0xA7, 0x73, 0x65, 0x6D, 0x69, 0x3B, 0x73, 0x65, 0x73, + 0x77, 0x61, 0x72, 0xE2, 0xA4, 0xA9, 0x73, 0x65, 0x74, 0x6D, 0x69, 0x6E, + 0x75, 0x73, 0xE2, 0x88, 0x96, 0x73, 0x65, 0x74, 0x6D, 0x6E, 0xE2, 0x88, + 0x96, 0x73, 0x65, 0x78, 0x74, 0xE2, 0x9C, 0xB6, 0x73, 0x66, 0x72, 0xF0, + 0x9D, 0x94, 0xB0, 0x73, 0x66, 0x72, 0x6F, 0x77, 0x6E, 0xE2, 0x8C, 0xA2, + 0x73, 0x68, 0x61, 0x72, 0x70, 0xE2, 0x99, 0xAF, 0x73, 0x68, 0x63, 0x68, + 0x63, 0x79, 0xD1, 0x89, 0x73, 0x68, 0x63, 0x79, 0xD1, 0x88, 0x73, 0x68, + 0x6F, 0x72, 0x74, 0x6D, 0x69, 0x64, 0xE2, 0x88, 0xA3, 0x73, 0x68, 0x6F, + 0x72, 0x74, 0x70, 0x61, 0x72, 0x61, 0x6C, 0x6C, 0x65, 0x6C, 0xE2, 0x88, + 0xA5, 0x73, 0x68, 0x79, 0xC2, 0xAD, 0x73, 0x69, 0x67, 0x6D, 0x61, 0xCF, + 0x83, 0x73, 0x69, 0x67, 0x6D, 0x61, 0x66, 0xCF, 0x82, 0x73, 0x69, 0x67, + 0x6D, 0x61, 0x76, 0xCF, 0x82, 0x73, 0x69, 0x6D, 0xE2, 0x88, 0xBC, 0x73, + 0x69, 0x6D, 0x64, 0x6F, 0x74, 0xE2, 0xA9, 0xAA, 0x73, 0x69, 0x6D, 0x65, + 0xE2, 0x89, 0x83, 0x73, 0x69, 0x6D, 0x65, 0x71, 0xE2, 0x89, 0x83, 0x73, + 0x69, 0x6D, 0x67, 0xE2, 0xAA, 0x9E, 0x73, 0x69, 0x6D, 0x67, 0x45, 0xE2, + 0xAA, 0xA0, 0x73, 0x69, 0x6D, 0x6C, 0xE2, 0xAA, 0x9D, 0x73, 0x69, 0x6D, + 0x6C, 0x45, 0xE2, 0xAA, 0x9F, 0x73, 0x69, 0x6D, 0x6E, 0x65, 0xE2, 0x89, + 0x86, 0x73, 0x69, 0x6D, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA8, 0xA4, 0x73, + 0x69, 0x6D, 0x72, 0x61, 0x72, 0x72, 0xE2, 0xA5, 0xB2, 0x73, 0x6C, 0x61, + 0x72, 0x72, 0xE2, 0x86, 0x90, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x73, 0x65, + 0x74, 0x6D, 0x69, 0x6E, 0x75, 0x73, 0xE2, 0x88, 0x96, 0x73, 0x6D, 0x61, + 0x73, 0x68, 0x70, 0xE2, 0xA8, 0xB3, 0x73, 0x6D, 0x65, 0x70, 0x61, 0x72, + 0x73, 0x6C, 0xE2, 0xA7, 0xA4, 0x73, 0x6D, 0x69, 0x64, 0xE2, 0x88, 0xA3, + 0x73, 0x6D, 0x69, 0x6C, 0x65, 0xE2, 0x8C, 0xA3, 0x73, 0x6D, 0x74, 0xE2, + 0xAA, 0xAA, 0x73, 0x6D, 0x74, 0x65, 0xE2, 0xAA, 0xAC, 0x73, 0x6D, 0x74, + 0x65, 0x73, 0xE2, 0xAA, 0xAC, 0xEF, 0xB8, 0x80, 0x73, 0x6F, 0x66, 0x74, + 0x63, 0x79, 0xD1, 0x8C, 0x73, 0x6F, 0x6C, 0x2F, 0x73, 0x6F, 0x6C, 0x62, + 0xE2, 0xA7, 0x84, 0x73, 0x6F, 0x6C, 0x62, 0x61, 0x72, 0xE2, 0x8C, 0xBF, + 0x73, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xA4, 0x73, 0x70, 0x61, 0x64, + 0x65, 0x73, 0xE2, 0x99, 0xA0, 0x73, 0x70, 0x61, 0x64, 0x65, 0x73, 0x75, + 0x69, 0x74, 0xE2, 0x99, 0xA0, 0x73, 0x70, 0x61, 0x72, 0xE2, 0x88, 0xA5, + 0x73, 0x71, 0x63, 0x61, 0x70, 0xE2, 0x8A, 0x93, 0x73, 0x71, 0x63, 0x61, + 0x70, 0x73, 0xE2, 0x8A, 0x93, 0xEF, 0xB8, 0x80, 0x73, 0x71, 0x63, 0x75, + 0x70, 0xE2, 0x8A, 0x94, 0x73, 0x71, 0x63, 0x75, 0x70, 0x73, 0xE2, 0x8A, + 0x94, 0xEF, 0xB8, 0x80, 0x73, 0x71, 0x73, 0x75, 0x62, 0xE2, 0x8A, 0x8F, + 0x73, 0x71, 0x73, 0x75, 0x62, 0x65, 0xE2, 0x8A, 0x91, 0x73, 0x71, 0x73, + 0x75, 0x62, 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x8F, 0x73, 0x71, 0x73, 0x75, + 0x62, 0x73, 0x65, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0x91, 0x73, 0x71, 0x73, + 0x75, 0x70, 0xE2, 0x8A, 0x90, 0x73, 0x71, 0x73, 0x75, 0x70, 0x65, 0xE2, + 0x8A, 0x92, 0x73, 0x71, 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0xE2, 0x8A, + 0x90, 0x73, 0x71, 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x65, 0x71, 0xE2, + 0x8A, 0x92, 0x73, 0x71, 0x75, 0xE2, 0x96, 0xA1, 0x73, 0x71, 0x75, 0x61, + 0x72, 0x65, 0xE2, 0x96, 0xA1, 0x73, 0x71, 0x75, 0x61, 0x72, 0x66, 0xE2, + 0x96, 0xAA, 0x73, 0x71, 0x75, 0x66, 0xE2, 0x96, 0xAA, 0x73, 0x72, 0x61, + 0x72, 0x72, 0xE2, 0x86, 0x92, 0x73, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, + 0x88, 0x73, 0x73, 0x65, 0x74, 0x6D, 0x6E, 0xE2, 0x88, 0x96, 0x73, 0x73, + 0x6D, 0x69, 0x6C, 0x65, 0xE2, 0x8C, 0xA3, 0x73, 0x73, 0x74, 0x61, 0x72, + 0x66, 0xE2, 0x8B, 0x86, 0x73, 0x74, 0x61, 0x72, 0xE2, 0x98, 0x86, 0x73, + 0x74, 0x61, 0x72, 0x66, 0xE2, 0x98, 0x85, 0x73, 0x74, 0x72, 0x61, 0x69, + 0x67, 0x68, 0x74, 0x65, 0x70, 0x73, 0x69, 0x6C, 0x6F, 0x6E, 0xCF, 0xB5, + 0x73, 0x74, 0x72, 0x61, 0x69, 0x67, 0x68, 0x74, 0x70, 0x68, 0x69, 0xCF, + 0x95, 0x73, 0x74, 0x72, 0x6E, 0x73, 0xC2, 0xAF, 0x73, 0x75, 0x62, 0xE2, + 0x8A, 0x82, 0x73, 0x75, 0x62, 0x45, 0xE2, 0xAB, 0x85, 0x73, 0x75, 0x62, + 0x64, 0x6F, 0x74, 0xE2, 0xAA, 0xBD, 0x73, 0x75, 0x62, 0x65, 0xE2, 0x8A, + 0x86, 0x73, 0x75, 0x62, 0x65, 0x64, 0x6F, 0x74, 0xE2, 0xAB, 0x83, 0x73, + 0x75, 0x62, 0x6D, 0x75, 0x6C, 0x74, 0xE2, 0xAB, 0x81, 0x73, 0x75, 0x62, + 0x6E, 0x45, 0xE2, 0xAB, 0x8B, 0x73, 0x75, 0x62, 0x6E, 0x65, 0xE2, 0x8A, + 0x8A, 0x73, 0x75, 0x62, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xAA, 0xBF, 0x73, + 0x75, 0x62, 0x72, 0x61, 0x72, 0x72, 0xE2, 0xA5, 0xB9, 0x73, 0x75, 0x62, + 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x82, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, + 0x65, 0x71, 0xE2, 0x8A, 0x86, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x65, + 0x71, 0x71, 0xE2, 0xAB, 0x85, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x6E, + 0x65, 0x71, 0xE2, 0x8A, 0x8A, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x6E, + 0x65, 0x71, 0x71, 0xE2, 0xAB, 0x8B, 0x73, 0x75, 0x62, 0x73, 0x69, 0x6D, + 0xE2, 0xAB, 0x87, 0x73, 0x75, 0x62, 0x73, 0x75, 0x62, 0xE2, 0xAB, 0x95, + 0x73, 0x75, 0x62, 0x73, 0x75, 0x70, 0xE2, 0xAB, 0x93, 0x73, 0x75, 0x63, + 0x63, 0xE2, 0x89, 0xBB, 0x73, 0x75, 0x63, 0x63, 0x61, 0x70, 0x70, 0x72, + 0x6F, 0x78, 0xE2, 0xAA, 0xB8, 0x73, 0x75, 0x63, 0x63, 0x63, 0x75, 0x72, + 0x6C, 0x79, 0x65, 0x71, 0xE2, 0x89, 0xBD, 0x73, 0x75, 0x63, 0x63, 0x65, + 0x71, 0xE2, 0xAA, 0xB0, 0x73, 0x75, 0x63, 0x63, 0x6E, 0x61, 0x70, 0x70, + 0x72, 0x6F, 0x78, 0xE2, 0xAA, 0xBA, 0x73, 0x75, 0x63, 0x63, 0x6E, 0x65, + 0x71, 0x71, 0xE2, 0xAA, 0xB6, 0x73, 0x75, 0x63, 0x63, 0x6E, 0x73, 0x69, + 0x6D, 0xE2, 0x8B, 0xA9, 0x73, 0x75, 0x63, 0x63, 0x73, 0x69, 0x6D, 0xE2, + 0x89, 0xBF, 0x73, 0x75, 0x6D, 0xE2, 0x88, 0x91, 0x73, 0x75, 0x6E, 0x67, + 0xE2, 0x99, 0xAA, 0x73, 0x75, 0x70, 0xE2, 0x8A, 0x83, 0x73, 0x75, 0x70, + 0x31, 0xC2, 0xB9, 0x73, 0x75, 0x70, 0x32, 0xC2, 0xB2, 0x73, 0x75, 0x70, + 0x33, 0xC2, 0xB3, 0x73, 0x75, 0x70, 0x45, 0xE2, 0xAB, 0x86, 0x73, 0x75, + 0x70, 0x64, 0x6F, 0x74, 0xE2, 0xAA, 0xBE, 0x73, 0x75, 0x70, 0x64, 0x73, + 0x75, 0x62, 0xE2, 0xAB, 0x98, 0x73, 0x75, 0x70, 0x65, 0xE2, 0x8A, 0x87, + 0x73, 0x75, 0x70, 0x65, 0x64, 0x6F, 0x74, 0xE2, 0xAB, 0x84, 0x73, 0x75, + 0x70, 0x68, 0x73, 0x6F, 0x6C, 0xE2, 0x9F, 0x89, 0x73, 0x75, 0x70, 0x68, + 0x73, 0x75, 0x62, 0xE2, 0xAB, 0x97, 0x73, 0x75, 0x70, 0x6C, 0x61, 0x72, + 0x72, 0xE2, 0xA5, 0xBB, 0x73, 0x75, 0x70, 0x6D, 0x75, 0x6C, 0x74, 0xE2, + 0xAB, 0x82, 0x73, 0x75, 0x70, 0x6E, 0x45, 0xE2, 0xAB, 0x8C, 0x73, 0x75, + 0x70, 0x6E, 0x65, 0xE2, 0x8A, 0x8B, 0x73, 0x75, 0x70, 0x70, 0x6C, 0x75, + 0x73, 0xE2, 0xAB, 0x80, 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0xE2, 0x8A, + 0x83, 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0x87, + 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x65, 0x71, 0x71, 0xE2, 0xAB, 0x86, + 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x6E, 0x65, 0x71, 0xE2, 0x8A, 0x8B, + 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x6E, 0x65, 0x71, 0x71, 0xE2, 0xAB, + 0x8C, 0x73, 0x75, 0x70, 0x73, 0x69, 0x6D, 0xE2, 0xAB, 0x88, 0x73, 0x75, + 0x70, 0x73, 0x75, 0x62, 0xE2, 0xAB, 0x94, 0x73, 0x75, 0x70, 0x73, 0x75, + 0x70, 0xE2, 0xAB, 0x96, 0x73, 0x77, 0x41, 0x72, 0x72, 0xE2, 0x87, 0x99, + 0x73, 0x77, 0x61, 0x72, 0x68, 0x6B, 0xE2, 0xA4, 0xA6, 0x73, 0x77, 0x61, + 0x72, 0x72, 0xE2, 0x86, 0x99, 0x73, 0x77, 0x61, 0x72, 0x72, 0x6F, 0x77, + 0xE2, 0x86, 0x99, 0x73, 0x77, 0x6E, 0x77, 0x61, 0x72, 0xE2, 0xA4, 0xAA, + 0x73, 0x7A, 0x6C, 0x69, 0x67, 0xC3, 0x9F, 0x74, 0x61, 0x72, 0x67, 0x65, + 0x74, 0xE2, 0x8C, 0x96, 0x74, 0x61, 0x75, 0xCF, 0x84, 0x74, 0x62, 0x72, + 0x6B, 0xE2, 0x8E, 0xB4, 0x74, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5, 0xA5, + 0x74, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0xA3, 0x74, 0x63, 0x79, 0xD1, + 0x82, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x83, 0x9B, 0x74, 0x65, 0x6C, 0x72, + 0x65, 0x63, 0xE2, 0x8C, 0x95, 0x74, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xB1, + 0x74, 0x68, 0x65, 0x72, 0x65, 0x34, 0xE2, 0x88, 0xB4, 0x74, 0x68, 0x65, + 0x72, 0x65, 0x66, 0x6F, 0x72, 0x65, 0xE2, 0x88, 0xB4, 0x74, 0x68, 0x65, + 0x74, 0x61, 0xCE, 0xB8, 0x74, 0x68, 0x65, 0x74, 0x61, 0x73, 0x79, 0x6D, + 0xCF, 0x91, 0x74, 0x68, 0x65, 0x74, 0x61, 0x76, 0xCF, 0x91, 0x74, 0x68, + 0x69, 0x63, 0x6B, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0xE2, 0x89, 0x88, + 0x74, 0x68, 0x69, 0x63, 0x6B, 0x73, 0x69, 0x6D, 0xE2, 0x88, 0xBC, 0x74, + 0x68, 0x69, 0x6E, 0x73, 0x70, 0xE2, 0x80, 0x89, 0x74, 0x68, 0x6B, 0x61, + 0x70, 0xE2, 0x89, 0x88, 0x74, 0x68, 0x6B, 0x73, 0x69, 0x6D, 0xE2, 0x88, + 0xBC, 0x74, 0x68, 0x6F, 0x72, 0x6E, 0xC3, 0xBE, 0x74, 0x69, 0x6C, 0x64, + 0x65, 0xCB, 0x9C, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xC3, 0x97, 0x74, 0x69, + 0x6D, 0x65, 0x73, 0x62, 0xE2, 0x8A, 0xA0, 0x74, 0x69, 0x6D, 0x65, 0x73, + 0x62, 0x61, 0x72, 0xE2, 0xA8, 0xB1, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x64, + 0xE2, 0xA8, 0xB0, 0x74, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xAD, 0x74, 0x6F, + 0x65, 0x61, 0xE2, 0xA4, 0xA8, 0x74, 0x6F, 0x70, 0xE2, 0x8A, 0xA4, 0x74, + 0x6F, 0x70, 0x62, 0x6F, 0x74, 0xE2, 0x8C, 0xB6, 0x74, 0x6F, 0x70, 0x63, + 0x69, 0x72, 0xE2, 0xAB, 0xB1, 0x74, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, + 0xA5, 0x74, 0x6F, 0x70, 0x66, 0x6F, 0x72, 0x6B, 0xE2, 0xAB, 0x9A, 0x74, + 0x6F, 0x73, 0x61, 0xE2, 0xA4, 0xA9, 0x74, 0x70, 0x72, 0x69, 0x6D, 0x65, + 0xE2, 0x80, 0xB4, 0x74, 0x72, 0x61, 0x64, 0x65, 0xE2, 0x84, 0xA2, 0x74, + 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x96, 0xB5, 0x74, 0x72, + 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x64, 0x6F, 0x77, 0x6E, 0xE2, 0x96, + 0xBF, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x6C, 0x65, 0x66, + 0x74, 0xE2, 0x97, 0x83, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, + 0x6C, 0x65, 0x66, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0xB4, 0x74, 0x72, 0x69, + 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x71, 0xE2, 0x89, 0x9C, 0x74, 0x72, 0x69, + 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2, 0x96, + 0xB9, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0xB5, 0x74, 0x72, 0x69, 0x64, 0x6F, + 0x74, 0xE2, 0x97, 0xAC, 0x74, 0x72, 0x69, 0x65, 0xE2, 0x89, 0x9C, 0x74, + 0x72, 0x69, 0x6D, 0x69, 0x6E, 0x75, 0x73, 0xE2, 0xA8, 0xBA, 0x74, 0x72, + 0x69, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA8, 0xB9, 0x74, 0x72, 0x69, 0x73, + 0x62, 0xE2, 0xA7, 0x8D, 0x74, 0x72, 0x69, 0x74, 0x69, 0x6D, 0x65, 0xE2, + 0xA8, 0xBB, 0x74, 0x72, 0x70, 0x65, 0x7A, 0x69, 0x75, 0x6D, 0xE2, 0x8F, + 0xA2, 0x74, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x89, 0x74, 0x73, 0x63, + 0x79, 0xD1, 0x86, 0x74, 0x73, 0x68, 0x63, 0x79, 0xD1, 0x9B, 0x74, 0x73, + 0x74, 0x72, 0x6F, 0x6B, 0xC5, 0xA7, 0x74, 0x77, 0x69, 0x78, 0x74, 0xE2, + 0x89, 0xAC, 0x74, 0x77, 0x6F, 0x68, 0x65, 0x61, 0x64, 0x6C, 0x65, 0x66, + 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x9E, 0x74, 0x77, 0x6F, + 0x68, 0x65, 0x61, 0x64, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, + 0x6F, 0x77, 0xE2, 0x86, 0xA0, 0x75, 0x41, 0x72, 0x72, 0xE2, 0x87, 0x91, + 0x75, 0x48, 0x61, 0x72, 0xE2, 0xA5, 0xA3, 0x75, 0x61, 0x63, 0x75, 0x74, + 0x65, 0xC3, 0xBA, 0x75, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x91, 0x75, 0x62, + 0x72, 0x63, 0x79, 0xD1, 0x9E, 0x75, 0x62, 0x72, 0x65, 0x76, 0x65, 0xC5, + 0xAD, 0x75, 0x63, 0x69, 0x72, 0x63, 0xC3, 0xBB, 0x75, 0x63, 0x79, 0xD1, + 0x83, 0x75, 0x64, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x85, 0x75, 0x64, 0x62, + 0x6C, 0x61, 0x63, 0xC5, 0xB1, 0x75, 0x64, 0x68, 0x61, 0x72, 0xE2, 0xA5, + 0xAE, 0x75, 0x66, 0x69, 0x73, 0x68, 0x74, 0xE2, 0xA5, 0xBE, 0x75, 0x66, + 0x72, 0xF0, 0x9D, 0x94, 0xB2, 0x75, 0x67, 0x72, 0x61, 0x76, 0x65, 0xC3, + 0xB9, 0x75, 0x68, 0x61, 0x72, 0x6C, 0xE2, 0x86, 0xBF, 0x75, 0x68, 0x61, + 0x72, 0x72, 0xE2, 0x86, 0xBE, 0x75, 0x68, 0x62, 0x6C, 0x6B, 0xE2, 0x96, + 0x80, 0x75, 0x6C, 0x63, 0x6F, 0x72, 0x6E, 0xE2, 0x8C, 0x9C, 0x75, 0x6C, + 0x63, 0x6F, 0x72, 0x6E, 0x65, 0x72, 0xE2, 0x8C, 0x9C, 0x75, 0x6C, 0x63, + 0x72, 0x6F, 0x70, 0xE2, 0x8C, 0x8F, 0x75, 0x6C, 0x74, 0x72, 0x69, 0xE2, + 0x97, 0xB8, 0x75, 0x6D, 0x61, 0x63, 0x72, 0xC5, 0xAB, 0x75, 0x6D, 0x6C, + 0xC2, 0xA8, 0x75, 0x6F, 0x67, 0x6F, 0x6E, 0xC5, 0xB3, 0x75, 0x6F, 0x70, + 0x66, 0xF0, 0x9D, 0x95, 0xA6, 0x75, 0x70, 0x61, 0x72, 0x72, 0x6F, 0x77, + 0xE2, 0x86, 0x91, 0x75, 0x70, 0x64, 0x6F, 0x77, 0x6E, 0x61, 0x72, 0x72, + 0x6F, 0x77, 0xE2, 0x86, 0x95, 0x75, 0x70, 0x68, 0x61, 0x72, 0x70, 0x6F, + 0x6F, 0x6E, 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x86, 0xBF, 0x75, 0x70, 0x68, + 0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2, + 0x86, 0xBE, 0x75, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0x8A, 0x8E, 0x75, 0x70, + 0x73, 0x69, 0xCF, 0x85, 0x75, 0x70, 0x73, 0x69, 0x68, 0xCF, 0x92, 0x75, + 0x70, 0x73, 0x69, 0x6C, 0x6F, 0x6E, 0xCF, 0x85, 0x75, 0x70, 0x75, 0x70, + 0x61, 0x72, 0x72, 0x6F, 0x77, 0x73, 0xE2, 0x87, 0x88, 0x75, 0x72, 0x63, + 0x6F, 0x72, 0x6E, 0xE2, 0x8C, 0x9D, 0x75, 0x72, 0x63, 0x6F, 0x72, 0x6E, + 0x65, 0x72, 0xE2, 0x8C, 0x9D, 0x75, 0x72, 0x63, 0x72, 0x6F, 0x70, 0xE2, + 0x8C, 0x8E, 0x75, 0x72, 0x69, 0x6E, 0x67, 0xC5, 0xAF, 0x75, 0x72, 0x74, + 0x72, 0x69, 0xE2, 0x97, 0xB9, 0x75, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, + 0x8A, 0x75, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0xB0, 0x75, 0x74, 0x69, + 0x6C, 0x64, 0x65, 0xC5, 0xA9, 0x75, 0x74, 0x72, 0x69, 0xE2, 0x96, 0xB5, + 0x75, 0x74, 0x72, 0x69, 0x66, 0xE2, 0x96, 0xB4, 0x75, 0x75, 0x61, 0x72, + 0x72, 0xE2, 0x87, 0x88, 0x75, 0x75, 0x6D, 0x6C, 0xC3, 0xBC, 0x75, 0x77, + 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0xA6, 0xA7, 0x76, 0x41, 0x72, 0x72, + 0xE2, 0x87, 0x95, 0x76, 0x42, 0x61, 0x72, 0xE2, 0xAB, 0xA8, 0x76, 0x42, + 0x61, 0x72, 0x76, 0xE2, 0xAB, 0xA9, 0x76, 0x44, 0x61, 0x73, 0x68, 0xE2, + 0x8A, 0xA8, 0x76, 0x61, 0x6E, 0x67, 0x72, 0x74, 0xE2, 0xA6, 0x9C, 0x76, + 0x61, 0x72, 0x65, 0x70, 0x73, 0x69, 0x6C, 0x6F, 0x6E, 0xCF, 0xB5, 0x76, + 0x61, 0x72, 0x6B, 0x61, 0x70, 0x70, 0x61, 0xCF, 0xB0, 0x76, 0x61, 0x72, + 0x6E, 0x6F, 0x74, 0x68, 0x69, 0x6E, 0x67, 0xE2, 0x88, 0x85, 0x76, 0x61, + 0x72, 0x70, 0x68, 0x69, 0xCF, 0x95, 0x76, 0x61, 0x72, 0x70, 0x69, 0xCF, + 0x96, 0x76, 0x61, 0x72, 0x70, 0x72, 0x6F, 0x70, 0x74, 0x6F, 0xE2, 0x88, + 0x9D, 0x76, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x95, 0x76, 0x61, 0x72, 0x72, + 0x68, 0x6F, 0xCF, 0xB1, 0x76, 0x61, 0x72, 0x73, 0x69, 0x67, 0x6D, 0x61, + 0xCF, 0x82, 0x76, 0x61, 0x72, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x6E, + 0x65, 0x71, 0xE2, 0x8A, 0x8A, 0xEF, 0xB8, 0x80, 0x76, 0x61, 0x72, 0x73, + 0x75, 0x62, 0x73, 0x65, 0x74, 0x6E, 0x65, 0x71, 0x71, 0xE2, 0xAB, 0x8B, + 0xEF, 0xB8, 0x80, 0x76, 0x61, 0x72, 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, + 0x6E, 0x65, 0x71, 0xE2, 0x8A, 0x8B, 0xEF, 0xB8, 0x80, 0x76, 0x61, 0x72, + 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x6E, 0x65, 0x71, 0x71, 0xE2, 0xAB, + 0x8C, 0xEF, 0xB8, 0x80, 0x76, 0x61, 0x72, 0x74, 0x68, 0x65, 0x74, 0x61, + 0xCF, 0x91, 0x76, 0x61, 0x72, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, + 0x65, 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x8A, 0xB2, 0x76, 0x61, 0x72, 0x74, + 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x72, 0x69, 0x67, 0x68, 0x74, + 0xE2, 0x8A, 0xB3, 0x76, 0x63, 0x79, 0xD0, 0xB2, 0x76, 0x64, 0x61, 0x73, + 0x68, 0xE2, 0x8A, 0xA2, 0x76, 0x65, 0x65, 0xE2, 0x88, 0xA8, 0x76, 0x65, + 0x65, 0x62, 0x61, 0x72, 0xE2, 0x8A, 0xBB, 0x76, 0x65, 0x65, 0x65, 0x71, + 0xE2, 0x89, 0x9A, 0x76, 0x65, 0x6C, 0x6C, 0x69, 0x70, 0xE2, 0x8B, 0xAE, + 0x76, 0x65, 0x72, 0x62, 0x61, 0x72, 0x7C, 0x76, 0x65, 0x72, 0x74, 0x7C, + 0x76, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xB3, 0x76, 0x6C, 0x74, 0x72, 0x69, + 0xE2, 0x8A, 0xB2, 0x76, 0x6E, 0x73, 0x75, 0x62, 0xE2, 0x8A, 0x82, 0xE2, + 0x83, 0x92, 0x76, 0x6E, 0x73, 0x75, 0x70, 0xE2, 0x8A, 0x83, 0xE2, 0x83, + 0x92, 0x76, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xA7, 0x76, 0x70, 0x72, + 0x6F, 0x70, 0xE2, 0x88, 0x9D, 0x76, 0x72, 0x74, 0x72, 0x69, 0xE2, 0x8A, + 0xB3, 0x76, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x8B, 0x76, 0x73, 0x75, + 0x62, 0x6E, 0x45, 0xE2, 0xAB, 0x8B, 0xEF, 0xB8, 0x80, 0x76, 0x73, 0x75, + 0x62, 0x6E, 0x65, 0xE2, 0x8A, 0x8A, 0xEF, 0xB8, 0x80, 0x76, 0x73, 0x75, + 0x70, 0x6E, 0x45, 0xE2, 0xAB, 0x8C, 0xEF, 0xB8, 0x80, 0x76, 0x73, 0x75, + 0x70, 0x6E, 0x65, 0xE2, 0x8A, 0x8B, 0xEF, 0xB8, 0x80, 0x76, 0x7A, 0x69, + 0x67, 0x7A, 0x61, 0x67, 0xE2, 0xA6, 0x9A, 0x77, 0x63, 0x69, 0x72, 0x63, + 0xC5, 0xB5, 0x77, 0x65, 0x64, 0x62, 0x61, 0x72, 0xE2, 0xA9, 0x9F, 0x77, + 0x65, 0x64, 0x67, 0x65, 0xE2, 0x88, 0xA7, 0x77, 0x65, 0x64, 0x67, 0x65, + 0x71, 0xE2, 0x89, 0x99, 0x77, 0x65, 0x69, 0x65, 0x72, 0x70, 0xE2, 0x84, + 0x98, 0x77, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xB4, 0x77, 0x6F, 0x70, 0x66, + 0xF0, 0x9D, 0x95, 0xA8, 0x77, 0x70, 0xE2, 0x84, 0x98, 0x77, 0x72, 0xE2, + 0x89, 0x80, 0x77, 0x72, 0x65, 0x61, 0x74, 0x68, 0xE2, 0x89, 0x80, 0x77, + 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x8C, 0x78, 0x63, 0x61, 0x70, 0xE2, + 0x8B, 0x82, 0x78, 0x63, 0x69, 0x72, 0x63, 0xE2, 0x97, 0xAF, 0x78, 0x63, + 0x75, 0x70, 0xE2, 0x8B, 0x83, 0x78, 0x64, 0x74, 0x72, 0x69, 0xE2, 0x96, + 0xBD, 0x78, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xB5, 0x78, 0x68, 0x41, 0x72, + 0x72, 0xE2, 0x9F, 0xBA, 0x78, 0x68, 0x61, 0x72, 0x72, 0xE2, 0x9F, 0xB7, + 0x78, 0x69, 0xCE, 0xBE, 0x78, 0x6C, 0x41, 0x72, 0x72, 0xE2, 0x9F, 0xB8, + 0x78, 0x6C, 0x61, 0x72, 0x72, 0xE2, 0x9F, 0xB5, 0x78, 0x6D, 0x61, 0x70, + 0xE2, 0x9F, 0xBC, 0x78, 0x6E, 0x69, 0x73, 0xE2, 0x8B, 0xBB, 0x78, 0x6F, + 0x64, 0x6F, 0x74, 0xE2, 0xA8, 0x80, 0x78, 0x6F, 0x70, 0x66, 0xF0, 0x9D, + 0x95, 0xA9, 0x78, 0x6F, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA8, 0x81, 0x78, + 0x6F, 0x74, 0x69, 0x6D, 0x65, 0xE2, 0xA8, 0x82, 0x78, 0x72, 0x41, 0x72, + 0x72, 0xE2, 0x9F, 0xB9, 0x78, 0x72, 0x61, 0x72, 0x72, 0xE2, 0x9F, 0xB6, + 0x78, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x8D, 0x78, 0x73, 0x71, 0x63, + 0x75, 0x70, 0xE2, 0xA8, 0x86, 0x78, 0x75, 0x70, 0x6C, 0x75, 0x73, 0xE2, + 0xA8, 0x84, 0x78, 0x75, 0x74, 0x72, 0x69, 0xE2, 0x96, 0xB3, 0x78, 0x76, + 0x65, 0x65, 0xE2, 0x8B, 0x81, 0x78, 0x77, 0x65, 0x64, 0x67, 0x65, 0xE2, + 0x8B, 0x80, 0x79, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, 0xBD, 0x79, 0x61, + 0x63, 0x79, 0xD1, 0x8F, 0x79, 0x63, 0x69, 0x72, 0x63, 0xC5, 0xB7, 0x79, + 0x63, 0x79, 0xD1, 0x8B, 0x79, 0x65, 0x6E, 0xC2, 0xA5, 0x79, 0x66, 0x72, + 0xF0, 0x9D, 0x94, 0xB6, 0x79, 0x69, 0x63, 0x79, 0xD1, 0x97, 0x79, 0x6F, + 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xAA, 0x79, 0x73, 0x63, 0x72, 0xF0, 0x9D, + 0x93, 0x8E, 0x79, 0x75, 0x63, 0x79, 0xD1, 0x8E, 0x79, 0x75, 0x6D, 0x6C, + 0xC3, 0xBF, 0x7A, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0xBA, 0x7A, 0x63, + 0x61, 0x72, 0x6F, 0x6E, 0xC5, 0xBE, 0x7A, 0x63, 0x79, 0xD0, 0xB7, 0x7A, + 0x64, 0x6F, 0x74, 0xC5, 0xBC, 0x7A, 0x65, 0x65, 0x74, 0x72, 0x66, 0xE2, + 0x84, 0xA8, 0x7A, 0x65, 0x74, 0x61, 0xCE, 0xB6, 0x7A, 0x66, 0x72, 0xF0, + 0x9D, 0x94, 0xB7, 0x7A, 0x68, 0x63, 0x79, 0xD0, 0xB6, 0x7A, 0x69, 0x67, + 0x72, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x9D, 0x7A, 0x6F, 0x70, 0x66, 0xF0, + 0x9D, 0x95, 0xAB, 0x7A, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x8F, 0x7A, + 0x77, 0x6A, 0xE2, 0x80, 0x8D, 0x7A, 0x77, 0x6E, 0x6A, 0xE2, 0x80, 0x8C +}; diff --git a/cmark/src/houdini.h b/cmark/src/houdini.h new file mode 100644 index 0000000000..69d4fec95c --- /dev/null +++ b/cmark/src/houdini.h @@ -0,0 +1,41 @@ +#ifndef CMARK_HOUDINI_H +#define CMARK_HOUDINI_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdint.h> + +#include "buffer.h" + +#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) + +bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size, int secure); +int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/src/houdini_href_e.c b/cmark/src/houdini_href_e.c new file mode 100644 index 0000000000..38f2a58264 --- /dev/null +++ b/cmark/src/houdini_href_e.c @@ -0,0 +1,111 @@ +#include <assert.h> +#include <stdio.h> +#include <string.h> + +#include "houdini.h" + +#if !defined(__has_builtin) +# define __has_builtin(b) 0 +#endif + +#if !__has_builtin(__builtin_expect) +# define __builtin_expect(e, v) (e) +#endif + +#define likely(e) __builtin_expect((e), 1) +#define unlikely(e) __builtin_expect((e), 0) + +/* + * 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 assume (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 characters & (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, 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, +}; + +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] = '%'; + + while (i < size) { + org = i; + while (i < size && HREF_SAFE[src[i]] != 0) + i++; + + if (likely(i > org)) + cmark_strbuf_put(ob, src + org, i - org); + + /* escaping */ + if (i >= size) + break; + + switch (src[i]) { + /* amp appears all the time in URLs, but needs + * HTML-entity escaping to be inside an href */ + case '&': + cmark_strbuf_puts(ob, "&"); + break; + + /* the single quote is a valid URL character + * according to the standard; it needs HTML + * entity escaping too */ + case '\'': + cmark_strbuf_puts(ob, "'"); + break; + +/* the space can be escaped to %20 or a plus + * sign. we're going with the generic escape + * for now. the plus thing is more commonly seen + * when building GET strings */ +#if 0 + case ' ': + cmark_strbuf_putc(ob, '+'); + break; +#endif + + /* every other character goes with a %XX escaping */ + default: + hex_str[1] = hex_chars[(src[i] >> 4) & 0xF]; + hex_str[2] = hex_chars[src[i] & 0xF]; + cmark_strbuf_put(ob, hex_str, 3); + } + + i++; + } + + return 1; +} diff --git a/cmark/src/houdini_html_e.c b/cmark/src/houdini_html_e.c new file mode 100644 index 0000000000..111bc1374f --- /dev/null +++ b/cmark/src/houdini_html_e.c @@ -0,0 +1,73 @@ +#include <assert.h> +#include <stdio.h> +#include <string.h> + +#include "houdini.h" + +#if !defined(__has_builtin) +# define __has_builtin(b) 0 +#endif + +#if !__has_builtin(__builtin_expect) +# define __builtin_expect(e, v) (e) +#endif + +#define likely(e) __builtin_expect((e), 1) +#define unlikely(e) __builtin_expect((e), 0) + +/** + * 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_html(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++; + + 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; +} diff --git a/cmark/src/houdini_html_u.c b/cmark/src/houdini_html_u.c new file mode 100644 index 0000000000..07ac34a412 --- /dev/null +++ b/cmark/src/houdini_html_u.c @@ -0,0 +1,174 @@ +#include <assert.h> +#include <stdio.h> +#include <string.h> + +#include "buffer.h" +#include "houdini.h" +#include "utf8.h" +#include "entities.inc" + +#if !defined(__has_builtin) +# define __has_builtin(b) 0 +#endif + +#if !__has_builtin(__builtin_expect) +# define __builtin_expect(e, v) (e) +#endif + +#define likely(e) __builtin_expect((e), 1) +#define unlikely(e) __builtin_expect((e), 0) + +/* Binary tree lookup code for entities added by JGM */ + +static const unsigned char *S_lookup(int i, int low, int hi, + const unsigned char *s, int len, + bufsize_t *size_out) { + int j; + uint32_t value = cmark_entities[i]; + const unsigned char *ent_name = cmark_entity_text + ENT_TEXT_IDX(value); + int ent_len = ENT_NAME_SIZE(value); + int min_len = len < ent_len ? len : ent_len; + int cmp = + strncmp((const char *)s, (const char *)ent_name, min_len); + if (cmp == 0) + cmp = len - ent_len; + if (cmp == 0) { + *size_out = ENT_REPL_SIZE(value); + return ent_name + ent_len; + } 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, size_out); + } 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, size_out); + } else { + return NULL; + } +} + +static const unsigned char *S_lookup_entity(const unsigned char *s, int len, + bufsize_t *size_out) { + return S_lookup(ENT_TABLE_SIZE / 2, 0, ENT_TABLE_SIZE - 1, s, len, size_out); +} + +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; + int max_digits = 7; + + 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; + max_digits = 7; + } + + 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; + max_digits = 6; + } + + if (num_digits >= 1 && num_digits <= max_digits && + 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 > ENT_MAX_LENGTH) + size = ENT_MAX_LENGTH; + + for (i = ENT_MIN_LENGTH; i < size; ++i) { + if (src[i] == ' ') + break; + + if (src[i] == ';') { + bufsize_t size; + const unsigned char *entity = S_lookup_entity(src, i, &size); + + if (entity != NULL) { + cmark_strbuf_put(ob, entity, size); + 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; + + 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, + bufsize_t size) { + if (!houdini_unescape_html(ob, src, size)) + cmark_strbuf_put(ob, src, size); +} diff --git a/cmark/src/html.c b/cmark/src/html.c new file mode 100644 index 0000000000..5c14fa6f89 --- /dev/null +++ b/cmark/src/html.c @@ -0,0 +1,345 @@ +#include <assert.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "cmark_ctype.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#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, + bufsize_t length) { + houdini_escape_html(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'); +} + +struct render_state { + cmark_strbuf *html; + cmark_node *plain; +}; + +static void S_render_sourcepos(cmark_node *node, cmark_strbuf *html, + int options) { + char buffer[BUFFER_SIZE]; + if (CMARK_OPT_SOURCEPOS & options) { + 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); + } +} + +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_heading[] = "<h0"; + char end_heading[] = "</h0"; + bool tight; + char buffer[BUFFER_SIZE]; + + 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: + case CMARK_NODE_HTML_INLINE: + escape_html(html, node->data, node->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, "<blockquote"); + S_render_sourcepos(node, html, options); + cmark_strbuf_puts(html, ">\n"); + } else { + cr(html); + cmark_strbuf_puts(html, "</blockquote>\n"); + } + break; + + case CMARK_NODE_LIST: { + cmark_list_type list_type = (cmark_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, "<ul"); + S_render_sourcepos(node, html, options); + cmark_strbuf_puts(html, ">\n"); + } else if (start == 1) { + cmark_strbuf_puts(html, "<ol"); + S_render_sourcepos(node, html, options); + cmark_strbuf_puts(html, ">\n"); + } else { + snprintf(buffer, BUFFER_SIZE, "<ol start=\"%d\"", start); + cmark_strbuf_puts(html, buffer); + S_render_sourcepos(node, html, options); + cmark_strbuf_puts(html, ">\n"); + } + } else { + cmark_strbuf_puts(html, + list_type == CMARK_BULLET_LIST ? "</ul>\n" : "</ol>\n"); + } + break; + } + + case CMARK_NODE_ITEM: + if (entering) { + cr(html); + cmark_strbuf_puts(html, "<li"); + S_render_sourcepos(node, html, options); + cmark_strbuf_putc(html, '>'); + } else { + cmark_strbuf_puts(html, "</li>\n"); + } + break; + + case CMARK_NODE_HEADING: + if (entering) { + cr(html); + 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_heading[3] = (char)('0' + node->as.heading.level); + cmark_strbuf_puts(html, end_heading); + cmark_strbuf_puts(html, ">\n"); + } + break; + + case CMARK_NODE_CODE_BLOCK: + cr(html); + + if (node->as.code.info == NULL || node->as.code.info[0] == 0) { + cmark_strbuf_puts(html, "<pre"); + S_render_sourcepos(node, html, options); + cmark_strbuf_puts(html, "><code>"); + } else { + bufsize_t first_tag = 0; + while (node->as.code.info[first_tag] && + !cmark_isspace(node->as.code.info[first_tag])) { + first_tag += 1; + } + + cmark_strbuf_puts(html, "<pre"); + S_render_sourcepos(node, html, options); + cmark_strbuf_puts(html, "><code class=\""); + if (strncmp((char *)node->as.code.info, "language-", 9) != 0) { + cmark_strbuf_puts(html, "language-"); + } + escape_html(html, node->as.code.info, first_tag); + cmark_strbuf_puts(html, "\">"); + } + + escape_html(html, node->data, node->len); + cmark_strbuf_puts(html, "</code></pre>\n"); + break; + + case CMARK_NODE_HTML_BLOCK: + cr(html); + if (!(options & CMARK_OPT_UNSAFE)) { + cmark_strbuf_puts(html, "<!-- raw HTML omitted -->"); + } else { + cmark_strbuf_put(html, node->data, node->len); + } + cr(html); + break; + + case CMARK_NODE_CUSTOM_BLOCK: { + unsigned char *block = entering ? node->as.custom.on_enter : + node->as.custom.on_exit; + cr(html); + if (block) { + cmark_strbuf_puts(html, (char *)block); + } + cr(html); + break; + } + + case CMARK_NODE_THEMATIC_BREAK: + cr(html); + cmark_strbuf_puts(html, "<hr"); + S_render_sourcepos(node, html, options); + 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, "<p"); + S_render_sourcepos(node, html, options); + cmark_strbuf_putc(html, '>'); + } else { + cmark_strbuf_puts(html, "</p>\n"); + } + } + break; + + case CMARK_NODE_TEXT: + escape_html(html, node->data, node->len); + break; + + case CMARK_NODE_LINEBREAK: + cmark_strbuf_puts(html, "<br />\n"); + break; + + case CMARK_NODE_SOFTBREAK: + if (options & CMARK_OPT_HARDBREAKS) { + cmark_strbuf_puts(html, "<br />\n"); + } else if (options & CMARK_OPT_NOBREAKS) { + cmark_strbuf_putc(html, ' '); + } else { + cmark_strbuf_putc(html, '\n'); + } + break; + + case CMARK_NODE_CODE: + cmark_strbuf_puts(html, "<code>"); + escape_html(html, node->data, node->len); + cmark_strbuf_puts(html, "</code>"); + break; + + case CMARK_NODE_HTML_INLINE: + if (!(options & CMARK_OPT_UNSAFE)) { + cmark_strbuf_puts(html, "<!-- raw HTML omitted -->"); + } else { + cmark_strbuf_put(html, node->data, node->len); + } + break; + + case CMARK_NODE_CUSTOM_INLINE: { + unsigned char *block = entering ? node->as.custom.on_enter : + node->as.custom.on_exit; + if (block) { + cmark_strbuf_puts(html, (char *)block); + } + break; + } + + case CMARK_NODE_STRONG: + if (entering) { + cmark_strbuf_puts(html, "<strong>"); + } else { + cmark_strbuf_puts(html, "</strong>"); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + cmark_strbuf_puts(html, "<em>"); + } else { + cmark_strbuf_puts(html, "</em>"); + } + break; + + case CMARK_NODE_LINK: + if (entering) { + cmark_strbuf_puts(html, "<a href=\""); + if (node->as.link.url && ((options & CMARK_OPT_UNSAFE) || + !(_scan_dangerous_url(node->as.link.url)))) { + houdini_escape_href(html, node->as.link.url, + (bufsize_t)strlen((char *)node->as.link.url)); + } + if (node->as.link.title) { + cmark_strbuf_puts(html, "\" title=\""); + escape_html(html, node->as.link.title, + (bufsize_t)strlen((char *)node->as.link.title)); + } + cmark_strbuf_puts(html, "\">"); + } else { + cmark_strbuf_puts(html, "</a>"); + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + cmark_strbuf_puts(html, "<img src=\""); + if (node->as.link.url && ((options & CMARK_OPT_UNSAFE) || + !(_scan_dangerous_url(node->as.link.url)))) { + houdini_escape_href(html, node->as.link.url, + (bufsize_t)strlen((char *)node->as.link.url)); + } + 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, + (bufsize_t)strlen((char *)node->as.link.title)); + } + + 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 = CMARK_BUF_INIT(root->mem); + cmark_event_type ev_type; + cmark_node *cur; + struct render_state state = {&html, NULL}; + cmark_iter *iter = cmark_iter_new(root); + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + S_render_node(cur, ev_type, &state, options); + } + result = (char *)cmark_strbuf_detach(&html); + + cmark_iter_free(iter); + return result; +} diff --git a/cmark/src/inlines.c b/cmark/src/inlines.c new file mode 100644 index 0000000000..ab82ca74e2 --- /dev/null +++ b/cmark/src/inlines.c @@ -0,0 +1,1503 @@ +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "cmark_ctype.h" +#include "node.h" +#include "parser.h" +#include "references.h" +#include "cmark.h" +#include "houdini.h" +#include "utf8.h" +#include "scanners.h" +#include "inlines.h" + +static const char *EMDASH = "\xE2\x80\x94"; +static const char *ENDASH = "\xE2\x80\x93"; +static const char *ELLIPSES = "\xE2\x80\xA6"; +static const char *LEFTDOUBLEQUOTE = "\xE2\x80\x9C"; +static const char *RIGHTDOUBLEQUOTE = "\xE2\x80\x9D"; +static const char *LEFTSINGLEQUOTE = "\xE2\x80\x98"; +static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99"; + +// Macros for creating various kinds of simple. +#define make_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) + +#define MAXBACKTICKS 1000 + +typedef struct delimiter { + struct delimiter *previous; + struct delimiter *next; + cmark_node *inl_text; + bufsize_t position; + bufsize_t length; + unsigned char delim_char; + bool can_open; + bool can_close; +} delimiter; + +typedef struct bracket { + struct bracket *previous; + cmark_node *inl_text; + bufsize_t position; + bool image; + bool active; + bool bracket_after; +} bracket; + +#define FLAG_SKIP_HTML_CDATA (1u << 0) +#define FLAG_SKIP_HTML_DECLARATION (1u << 1) +#define FLAG_SKIP_HTML_PI (1u << 2) +#define FLAG_SKIP_HTML_COMMENT (1u << 3) + +typedef struct { + cmark_mem *mem; + cmark_chunk input; + unsigned flags; + int line; + bufsize_t pos; + int block_offset; + int column_offset; + cmark_reference_map *refmap; + delimiter *last_delim; + bracket *last_bracket; + bufsize_t backticks[MAXBACKTICKS + 1]; + bool scanned_for_backticks; + bool no_link_openers; +} 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); + +static int parse_inline(subject *subj, cmark_node *parent, int options); + +static void subject_from_buf(cmark_mem *mem, int line_number, int block_offset, subject *e, + cmark_chunk *chunk, cmark_reference_map *refmap); +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(subject *subj, cmark_node_type t, + int start_column, int end_column) { + cmark_node *e = (cmark_node *)subj->mem->calloc(1, sizeof(*e)); + e->mem = subj->mem; + e->type = (uint16_t)t; + e->start_line = e->end_line = subj->line; + // columns are 1 based. + e->start_column = start_column + 1 + subj->column_offset + subj->block_offset; + e->end_column = end_column + 1 + subj->column_offset + subj->block_offset; + return e; +} + +// Create an inline with no value. +static inline cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) { + cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e)); + e->mem = mem; + e->type = t; + return e; +} + +static cmark_node *make_str(subject *subj, int sc, int ec, cmark_chunk s) { + cmark_node *e = make_literal(subj, CMARK_NODE_TEXT, sc, ec); + e->data = (unsigned char *)subj->mem->realloc(NULL, s.len + 1); + if (s.data != NULL) { + memcpy(e->data, s.data, s.len); + } + e->data[s.len] = 0; + e->len = s.len; + return e; +} + +static cmark_node *make_str_from_buf(subject *subj, int sc, int ec, + cmark_strbuf *buf) { + cmark_node *e = make_literal(subj, CMARK_NODE_TEXT, sc, ec); + e->len = buf->size; + e->data = cmark_strbuf_detach(buf); + return e; +} + +// Like make_str, but parses entities. +static cmark_node *make_str_with_entities(subject *subj, + int start_column, int end_column, + cmark_chunk *content) { + cmark_strbuf unescaped = CMARK_BUF_INIT(subj->mem); + + if (houdini_unescape_html(&unescaped, content->data, content->len)) { + return make_str_from_buf(subj, start_column, end_column, &unescaped); + } else { + return make_str(subj, start_column, end_column, *content); + } +} + +// Like cmark_node_append_child but without costly sanity checks. +// Assumes that child was newly created. +static void append_child(cmark_node *node, cmark_node *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; + } +} + +// Duplicate a chunk by creating a copy of the buffer not by reusing the +// buffer like cmark_chunk_dup does. +static unsigned char *cmark_strdup(cmark_mem *mem, unsigned char *src) { + if (src == NULL) { + return NULL; + } + size_t len = strlen((char *)src); + unsigned char *data = (unsigned char *)mem->realloc(NULL, len + 1); + memcpy(data, src, len + 1); + return data; +} + +static unsigned char *cmark_clean_autolink(cmark_mem *mem, cmark_chunk *url, + int is_email) { + cmark_strbuf buf = CMARK_BUF_INIT(mem); + + cmark_chunk_trim(url); + + 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_autolink(subject *subj, int start_column, + int end_column, cmark_chunk url, + int is_email) { + cmark_node *link = make_simple(subj->mem, CMARK_NODE_LINK); + link->as.link.url = cmark_clean_autolink(subj->mem, &url, is_email); + link->as.link.title = NULL; + link->start_line = link->end_line = subj->line; + link->start_column = start_column + 1; + link->end_column = end_column + 1; + append_child(link, make_str_with_entities(subj, start_column + 1, end_column - 1, &url)); + return link; +} + +static void subject_from_buf(cmark_mem *mem, int line_number, int block_offset, subject *e, + cmark_chunk *chunk, cmark_reference_map *refmap) { + int i; + e->mem = mem; + e->input = *chunk; + e->flags = 0; + e->line = line_number; + e->pos = 0; + e->block_offset = block_offset; + e->column_offset = 0; + 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; + e->no_link_openers = true; +} + +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_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); +} + +// 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)) { + unsigned char c; + bufsize_t startpos = subj->pos; + bufsize_t len = 0; + + while ((c = peek_char(subj)) && (*f)(c)) { + advance(subj); + len++; + } + + return cmark_chunk_dup(&subj->input, startpos, len); +} + +// Return the number of newlines in a given span of text in a subject. If +// the number is greater than zero, also return the number of characters +// between the last newline and the end of the span in `since_newline`. +static int count_newlines(subject *subj, bufsize_t from, bufsize_t len, int *since_newline) { + int nls = 0; + int since_nl = 0; + + while (len--) { + if (subj->input.data[from++] == '\n') { + ++nls; + since_nl = 0; + } else { + ++since_nl; + } + } + + if (!nls) + return 0; + + *since_newline = since_nl; + return nls; +} + +// Adjust `node`'s `end_line`, `end_column`, and `subj`'s `line` and +// `column_offset` according to the number of newlines in a just-matched span +// of text in `subj`. +static void adjust_subj_node_newlines(subject *subj, cmark_node *node, int matchlen, int extra, int options) { + if (!(options & CMARK_OPT_SOURCEPOS)) { + return; + } + + int since_newline; + int newlines = count_newlines(subj, subj->pos - matchlen - extra, matchlen, &since_newline); + if (newlines) { + subj->line += newlines; + node->end_line += newlines; + node->end_column = since_newline; + subj->column_offset = -subj->pos + since_newline + extra; + } +} + +// 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 bufsize_t scan_to_closing_backticks(subject *subj, + bufsize_t openticklength) { + + bool found = false; + if (openticklength > MAXBACKTICKS) { + // we limit backtick string length because of the array subj->backticks: + return 0; + } + if (subj->scanned_for_backticks && + subj->backticks[openticklength] <= subj->pos) { + // return if we already know there's no closer + return 0; + } + 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); + } + } + // got through whole input without finding closer + subj->scanned_for_backticks = true; + return 0; +} + +// Destructively modify string, converting newlines to +// spaces, then removing a single leading + trailing space, +// unless the code span consists entirely of space characters. +static void S_normalize_code(cmark_strbuf *s) { + bufsize_t r, w; + bool contains_nonspace = false; + + for (r = 0, w = 0; r < s->size; ++r) { + switch (s->ptr[r]) { + case '\r': + if (s->ptr[r + 1] != '\n') { + s->ptr[w++] = ' '; + } + break; + case '\n': + s->ptr[w++] = ' '; + break; + default: + s->ptr[w++] = s->ptr[r]; + } + if (s->ptr[r] != ' ') { + contains_nonspace = true; + } + } + + // begins and ends with space? + if (contains_nonspace && + s->ptr[0] == ' ' && s->ptr[w - 1] == ' ') { + cmark_strbuf_drop(s, 1); + cmark_strbuf_truncate(s, w - 2); + } else { + cmark_strbuf_truncate(s, w); + } + +} + + +// 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, int options) { + bufsize_t initpos = subj->pos; + 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(subj, initpos, initpos + openticks.len - 1, openticks); + } else { + cmark_strbuf buf = CMARK_BUF_INIT(subj->mem); + + cmark_strbuf_set(&buf, subj->input.data + startpos, + endpos - startpos - openticks.len); + S_normalize_code(&buf); + + cmark_node *node = make_literal(subj, CMARK_NODE_CODE, startpos, + endpos - openticks.len - 1); + node->len = buf.size; + node->data = cmark_strbuf_detach(&buf); + adjust_subj_node_newlines(subj, node, endpos - startpos, openticks.len, options); + return node; + } +} + + +// 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 = 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_or_symbol(after_char) || + cmark_utf8proc_is_space(before_char) || + cmark_utf8proc_is_punctuation_or_symbol(before_char)); + right_flanking = numdelims > 0 && !cmark_utf8proc_is_space(before_char) && + (!cmark_utf8proc_is_punctuation_or_symbol(before_char) || + cmark_utf8proc_is_space(after_char) || + cmark_utf8proc_is_punctuation_or_symbol(after_char)); + if (c == '_') { + *can_open = left_flanking && + (!right_flanking || + cmark_utf8proc_is_punctuation_or_symbol(before_char)); + *can_close = right_flanking && + (!left_flanking || + cmark_utf8proc_is_punctuation_or_symbol(after_char)); + } else if (c == '\'' || c == '"') { + *can_open = left_flanking && + (!right_flanking || before_char == '(' || before_char == '[') && + before_char != ']' && before_char != ')'; + *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: %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; + } +} +*/ + +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; + } + subj->mem->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; + subj->mem->free(b); +} + +static void push_delimiter(subject *subj, unsigned char c, bool can_open, + bool can_close, cmark_node *inl_text) { + delimiter *delim = (delimiter *)subj->mem->calloc(1, sizeof(delimiter)); + delim->delim_char = c; + delim->can_open = can_open; + delim->can_close = can_close; + delim->inl_text = inl_text; + delim->position = subj->pos; + delim->length = inl_text->len; + delim->previous = subj->last_delim; + delim->next = NULL; + if (delim->previous != NULL) { + delim->previous->next = delim; + } + 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->position = subj->pos; + b->bracket_after = false; + subj->last_bracket = b; + if (!image) { + subj->no_link_openers = false; + } +} + +// 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(subj, subj->pos - numdelims, subj->pos - 1, 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(subj, subj->pos - 1, subj->pos - 1, 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 = CMARK_BUF_INIT(subj->mem); + + 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_from_buf(subj, startpos, subj->pos - 1, &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(subj, subj->pos - 3, subj->pos - 1, cmark_chunk_literal(ELLIPSES)); + } else { + return make_str(subj, subj->pos - 2, subj->pos - 1, cmark_chunk_literal("..")); + } + } else { + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal(".")); + } +} + +static void process_emphasis(subject *subj, bufsize_t stack_bottom) { + delimiter *candidate; + delimiter *closer = NULL; + delimiter *opener; + delimiter *old_closer; + bool opener_found; + int openers_bottom_index = 0; + bufsize_t openers_bottom[15] = {stack_bottom, stack_bottom, stack_bottom, + stack_bottom, stack_bottom, stack_bottom, + stack_bottom, stack_bottom, stack_bottom, + stack_bottom, stack_bottom, stack_bottom, + stack_bottom, stack_bottom, stack_bottom}; + + // move back to first relevant delim. + candidate = subj->last_delim; + while (candidate != NULL && candidate->position >= stack_bottom) { + closer = candidate; + candidate = candidate->previous; + } + + // 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 + + (closer->can_open ? 3 : 0) + (closer->length % 3); + break; + case '*': + openers_bottom_index = 8 + + (closer->can_open ? 3 : 0) + (closer->length % 3); + break; + default: + assert(false); + } + + // Now look backwards for first matching opener: + opener = closer->previous; + opener_found = false; + while (opener != NULL && + opener->position >= 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) || + closer->length % 3 == 0 || + (opener->length + closer->length) % 3 != 0) { + 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 == '\'' || closer->delim_char == '"') { + if (closer->delim_char == '\'') { + cmark_node_set_literal(closer->inl_text, RIGHTSINGLEQUOTE); + } else { + cmark_node_set_literal(closer->inl_text, RIGHTDOUBLEQUOTE); + } + closer = closer->next; + if (opener_found) { + if (old_closer->delim_char == '\'') { + cmark_node_set_literal(opener->inl_text, LEFTSINGLEQUOTE); + } else { + cmark_node_set_literal(opener->inl_text, LEFTDOUBLEQUOTE); + } + remove_delimiter(subj, opener); + remove_delimiter(subj, old_closer); + } + } + if (!opener_found) { + // set lower bound for future searches for openers + openers_bottom[openers_bottom_index] = old_closer->position; + 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 != NULL && + subj->last_delim->position >= 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->len; + bufsize_t closer_num_chars = closer_inl->len; + 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; + + // remove used characters from associated inlines. + opener_num_chars -= use_delims; + closer_num_chars -= use_delims; + opener_inl->len = opener_num_chars; + opener_inl->data[opener_num_chars] = 0; + opener_inl->end_column -= use_delims; + closer_inl->len = closer_num_chars; + closer_inl->data[closer_num_chars] = 0; + closer_inl->start_column += use_delims; + + // 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; + } + + // 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; + if (tmp && tmp != closer_inl) { + emph->first_child = tmp; + tmp->prev = NULL; + + while (tmp && tmp != closer_inl) { + tmpnext = tmp->next; + tmp->parent = emph; + if (tmpnext == closer_inl) { + emph->last_child = tmp; + tmp->next = NULL; + } + tmp = tmpnext; + } + } + + opener_inl->next = emph; + closer_inl->prev = emph; + emph->prev = opener_inl; + emph->next = closer_inl; + emph->parent = opener_inl->parent; + + emph->start_line = opener_inl->start_line; + emph->end_line = closer_inl->end_line; + emph->start_column = opener_inl->start_column + opener_inl->len; + emph->end_column = closer_inl->end_column - closer_inl->len; + + // if opener has 0 characters, remove it and its associated inline + if (opener_num_chars == 0) { + cmark_node_free(opener_inl); + remove_delimiter(subj, opener); + } + + // 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(subj, subj->pos - 2, subj->pos - 1, cmark_chunk_dup(&subj->input, subj->pos - 1, 1)); + } else if (!is_eof(subj) && skip_line_end(subj)) { + return make_linebreak(subj->mem); + } else { + return make_str(subj, subj->pos - 1, subj->pos - 1, 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 = CMARK_BUF_INIT(subj->mem); + bufsize_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(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("&")); + + subj->pos += len; + return make_str_from_buf(subj, subj->pos - 1 - len, subj->pos - 1, &ent); +} + +// Clean a URL: remove surrounding whitespace, and remove \ that escape +// punctuation. +unsigned char *cmark_clean_url(cmark_mem *mem, cmark_chunk *url) { + cmark_strbuf buf = CMARK_BUF_INIT(mem); + + cmark_chunk_trim(url); + + houdini_unescape_html_f(&buf, url->data, url->len); + + cmark_strbuf_unescape(&buf); + return cmark_strbuf_detach(&buf); +} + +unsigned char *cmark_clean_title(cmark_mem *mem, cmark_chunk *title) { + cmark_strbuf buf = CMARK_BUF_INIT(mem); + 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 options) { + 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(subj, subj->pos - 1 - matchlen, subj->pos - 1, 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(subj, subj->pos - 1 - matchlen, subj->pos - 1, contents, 1); + } + + // finally, try to match an html tag + if (subj->pos + 2 <= subj->input.len) { + int c = subj->input.data[subj->pos]; + if (c == '!' && (subj->flags & FLAG_SKIP_HTML_COMMENT) == 0) { + c = subj->input.data[subj->pos+1]; + if (c == '-' && subj->input.data[subj->pos+2] == '-') { + if (subj->input.data[subj->pos+3] == '>') { + matchlen = 4; + } else if (subj->input.data[subj->pos+3] == '-' && + subj->input.data[subj->pos+4] == '>') { + matchlen = 5; + } else { + matchlen = scan_html_comment(&subj->input, subj->pos + 1); + if (matchlen > 0) { + matchlen += 1; // prefix "<" + } else { // no match through end of input: set a flag so + // we don't reparse looking for -->: + subj->flags |= FLAG_SKIP_HTML_COMMENT; + } + } + } else if (c == '[') { + if ((subj->flags & FLAG_SKIP_HTML_CDATA) == 0) { + matchlen = scan_html_cdata(&subj->input, subj->pos + 2); + if (matchlen > 0) { + // The regex doesn't require the final "]]>". But if we're not at + // the end of input, it must come after the match. Otherwise, + // disable subsequent scans to avoid quadratic behavior. + matchlen += 5; // prefix "![", suffix "]]>" + if (subj->pos + matchlen > subj->input.len) { + subj->flags |= FLAG_SKIP_HTML_CDATA; + matchlen = 0; + } + } + } + } else if ((subj->flags & FLAG_SKIP_HTML_DECLARATION) == 0) { + matchlen = scan_html_declaration(&subj->input, subj->pos + 1); + if (matchlen > 0) { + matchlen += 2; // prefix "!", suffix ">" + if (subj->pos + matchlen > subj->input.len) { + subj->flags |= FLAG_SKIP_HTML_DECLARATION; + matchlen = 0; + } + } + } + } else if (c == '?') { + if ((subj->flags & FLAG_SKIP_HTML_PI) == 0) { + // Note that we allow an empty match. + matchlen = scan_html_pi(&subj->input, subj->pos + 1); + matchlen += 3; // prefix "?", suffix "?>" + if (subj->pos + matchlen > subj->input.len) { + subj->flags |= FLAG_SKIP_HTML_PI; + matchlen = 0; + } + } + } else { + matchlen = scan_html_tag(&subj->input, subj->pos); + } + } + if (matchlen > 0) { + const unsigned char *src = subj->input.data + subj->pos - 1; + bufsize_t len = matchlen + 1; + subj->pos += matchlen; + cmark_node *node = make_literal(subj, CMARK_NODE_HTML_INLINE, + subj->pos - matchlen - 1, subj->pos - 1); + node->data = (unsigned char *)subj->mem->realloc(NULL, len + 1); + memcpy(node->data, src, len); + node->data[len] = 0; + node->len = len; + adjust_subj_node_newlines(subj, node, matchlen, 1, options); + return node; + } + + // if nothing matches, just return the opening <: + return make_str(subj, subj->pos - 1, subj->pos - 1, 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; + } + +noMatch: + subj->pos = startpos; // rewind + 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; + if (nb_p > 32) + return -1; + } else if (input->data[i] == ')') { + if (nb_p == 0) + break; + --nb_p; + ++i; + } else if (cmark_isspace(input->data[i])) { + if (i == offset) { + return -1; + } + break; + } else { + ++i; + } + } + + if (i >= input->len || nb_p != 0) + return -1; + + { + cmark_chunk result = {input->data + offset, i - offset}; + *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 (input->data[i] == '\n' || input->data[i] == '<') + return -1; + 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}; + *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, after_link_text_pos; + bufsize_t endurl, starttitle, endtitle, endall; + bufsize_t sps, n; + cmark_reference *ref = NULL; + cmark_chunk url_chunk, title_chunk; + unsigned char *url, *title; + 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; + + // get last [ or ![ + opener = subj->last_bracket; + + if (opener == NULL) { + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("]")); + } + + // If we got here, we matched a potential link/image text. + // Now we check to see if it's a link/image. + is_image = opener->image; + + if (!is_image && subj->no_link_openers) { + // take delimiter off stack + pop_bracket(subj); + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("]")); + } + + 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 = 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; + 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; + + title_chunk = + cmark_chunk_dup(&subj->input, starttitle, endtitle - starttitle); + url = cmark_clean_url(subj->mem, &url_chunk); + title = cmark_clean_title(subj->mem, &title_chunk); + cmark_chunk_free(&url_chunk); + cmark_chunk_free(&title_chunk); + goto match; + + } else { + // it could still be a shortcut reference link + subj->pos = after_link_text_pos; + } + } + + // Next, look for a following [link label] that matches in refmap. + // skip spaces + raw_label = cmark_chunk_literal(""); + found_label = link_label(subj, &raw_label); + if (!found_label) { + // If we have a shortcut reference link, back up + // to before the spaces we skipped. + subj->pos = initial_pos; + } + + if ((!found_label || raw_label.len == 0) && !opener->bracket_after) { + cmark_chunk_free(&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(&raw_label); + } + + if (ref != NULL) { // found + url = cmark_strdup(subj->mem, ref->url); + title = cmark_strdup(subj->mem, ref->title); + goto match; + } else { + goto noMatch; + } + +noMatch: + // If we fall through to here, it means we didn't match a link: + pop_bracket(subj); // remove this opener from delimiter list + subj->pos = initial_pos; + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("]")); + +match: + inl = make_simple(subj->mem, is_image ? CMARK_NODE_IMAGE : CMARK_NODE_LINK); + inl->as.link.url = url; + inl->as.link.title = title; + inl->start_line = inl->end_line = subj->line; + inl->start_column = opener->inl_text->start_column; + inl->end_column = subj->pos + subj->column_offset + subj->block_offset; + cmark_node_insert_before(opener->inl_text, inl); + // Add link text: + tmp = opener->inl_text->next; + while (tmp) { + tmpnext = tmp->next; + cmark_node_unlink(tmp); + append_child(inl, tmp); + tmp = tmpnext; + } + + // Free the bracket [: + cmark_node_free(opener->inl_text); + + process_emphasis(subj, opener->position); + pop_bracket(subj); + + // Now, if we have a link, we also want to deactivate links until + // we get a new opener. (This code can be removed if we decide to allow links + // inside links.) + if (!is_image) { + subj->no_link_openers = true; + } + + return NULL; +} + +// Parse a hard or soft linebreak, returning an inline. +// 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); + } + ++subj->line; + subj->column_offset = -subj->pos; + // 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(subj->mem); + } else { + return make_softbreak(subj->mem); + } +} + +static bufsize_t subject_find_special_char(subject *subj, int options) { + // "\r\n\\`&_*[]<!" + static const int8_t SPECIAL_CHARS[256] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 0, 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}; + + // " ' . - + static const char SMART_PUNCT_CHARS[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 1, 0, 0, 0, 0, 0, 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, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }; + + bufsize_t n = subj->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 startpos, 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, options); + break; + case '\\': + new_inl = handle_backslash(subj); + break; + case '&': + new_inl = handle_entity(subj); + break; + case '<': + new_inl = handle_pointy_brace(subj, options); + 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(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("[")); + push_bracket(subj, false, new_inl); + break; + case ']': + new_inl = handle_close_bracket(subj); + break; + case '!': + advance(subj); + if (peek_char(subj) == '[') { + advance(subj); + new_inl = make_str(subj, subj->pos - 2, subj->pos - 1, cmark_chunk_literal("![")); + push_bracket(subj, true, new_inl); + } else { + new_inl = make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("!")); + } + break; + default: + endpos = subject_find_special_char(subj, options); + contents = cmark_chunk_dup(&subj->input, subj->pos, endpos - subj->pos); + startpos = 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(subj, startpos, endpos - 1, contents); + } + if (new_inl != NULL) { + append_child(parent, new_inl); + } + + return 1; +} + +// Parse inlines from parent's string_content, adding as children of parent. +void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent, + cmark_reference_map *refmap, int options) { + int internal_offset = parent->type == CMARK_NODE_HEADING ? + parent->as.heading.internal_offset : 0; + subject subj; + cmark_chunk content = {parent->data, parent->len}; + subject_from_buf(mem, parent->start_line, parent->start_column - 1 + internal_offset, &subj, &content, refmap); + cmark_chunk_rtrim(&subj.input); + + while (!is_eof(&subj) && parse_inline(&subj, parent, options)) + ; + + process_emphasis(&subj, 0); + // free bracket and delim stack + while (subj.last_delim) { + remove_delimiter(&subj, subj.last_delim); + } + while (subj.last_bracket) { + pop_bracket(&subj); + } +} + +// 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); + } +} + +// 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_mem *mem, cmark_chunk *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(mem, -1, 0, &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); + if ((matchlen = manual_scan_link_url(&subj.input, subj.pos, &url)) > -1) { + subj.pos += matchlen; + } else { + return 0; + } + + // parse optional link_title + beforetitle = subj.pos; + spnl(&subj); + matchlen = subj.pos == beforetitle ? 0 : 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/cmark/src/inlines.h b/cmark/src/inlines.h new file mode 100644 index 0000000000..800ed0c68f --- /dev/null +++ b/cmark/src/inlines.h @@ -0,0 +1,24 @@ +#ifndef CMARK_INLINES_H +#define CMARK_INLINES_H + +#include "chunk.h" +#include "references.h" + +#ifdef __cplusplus +extern "C" { +#endif + +unsigned char *cmark_clean_url(cmark_mem *mem, cmark_chunk *url); +unsigned char *cmark_clean_title(cmark_mem *mem, cmark_chunk *title); + +void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent, + cmark_reference_map *refmap, int options); + +bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input, + cmark_reference_map *refmap); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/src/iterator.c b/cmark/src/iterator.c new file mode 100644 index 0000000000..cc428285ea --- /dev/null +++ b/cmark/src/iterator.c @@ -0,0 +1,122 @@ +#include <assert.h> +#include <stdbool.h> +#include <stdlib.h> + +#include "node.h" +#include "cmark.h" +#include "iterator.h" + +static const int S_leaf_mask = + (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_HTML_INLINE); + +cmark_iter *cmark_iter_new(cmark_node *root) { + if (root == NULL) { + return NULL; + } + cmark_mem *mem = root->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; + iter->next.ev_type = CMARK_EVENT_ENTER; + iter->next.node = root; + return 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; +} + +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) { + if (root == NULL) { + return; + } + cmark_iter *iter = cmark_iter_new(root); + cmark_strbuf buf = CMARK_BUF_INIT(iter->mem); + 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->data, cur->len); + tmp = cur->next; + while (tmp && tmp->type == CMARK_NODE_TEXT) { + cmark_iter_next(iter); // advance pointer + cmark_strbuf_put(&buf, tmp->data, tmp->len); + cur->end_column = tmp->end_column; + next = tmp->next; + cmark_node_free(tmp); + tmp = next; + } + iter->mem->free(cur->data); + cur->len = buf.size; + cur->data = cmark_strbuf_detach(&buf); + } + } + + cmark_strbuf_free(&buf); + cmark_iter_free(iter); +} diff --git a/cmark/src/iterator.h b/cmark/src/iterator.h new file mode 100644 index 0000000000..30ce76f519 --- /dev/null +++ b/cmark/src/iterator.h @@ -0,0 +1,26 @@ +#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_mem *mem; + cmark_node *root; + cmark_iter_state cur; + cmark_iter_state next; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/src/latex.c b/cmark/src/latex.c new file mode 100644 index 0000000000..386c14ff58 --- /dev/null +++ b/cmark/src/latex.c @@ -0,0 +1,456 @@ +#include <assert.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "utf8.h" +#include "scanners.h" +#include "render.h" + +#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) +#define LIST_NUMBER_STRING_SIZE 20 + +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, + INTERNAL_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); + + if (url && *url == '#') { + return INTERNAL_LINK; + } + + 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 = strlen(title); + // if it has a title, we can't treat it as an autolink: + if (title_len == 0) { + + link_text = node->first_child; + cmark_consolidate_text_nodes(link_text); + + if (!link_text) + return NO_LINK; + + realurl = (char *)url; + realurllen = (int)url_len; + if (strncmp(realurl, "mailto:", 7) == 0) { + realurl += 7; + realurllen -= 7; + isemail = true; + } + if (realurllen == link_text->len && + strncmp(realurl, (char *)link_text->data, + link_text->len) == 0) { + if (isemail) { + return EMAIL_AUTOLINK; + } else { + return URL_AUTOLINK; + } + } + } + + 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; + int enumlevel; + char list_number_string[LIST_NUMBER_STRING_SIZE]; + bool entering = (ev_type == CMARK_EVENT_ENTER); + cmark_list_type list_type; + bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options); + + // 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) { + 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 - 1); // the next item will increment this + 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 { + 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_HEADING: + if (entering) { + switch (cmark_node_get_heading_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_BLOCK: + break; + + 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(); + break; + + case CMARK_NODE_PARAGRAPH: + if (!entering) { + BLANKLINE(); + } + break; + + case CMARK_NODE_TEXT: + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + LIT("\\\\"); + CR(); + break; + + case CMARK_NODE_SOFTBREAK: + if (options & CMARK_OPT_HARDBREAKS) { + LIT("\\\\"); + CR(); + } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) { + CR(); + } else { + OUT(" ", allow_wrap, NORMAL); + } + break; + + case CMARK_NODE_CODE: + LIT("\\texttt{"); + OUT(cmark_node_get_literal(node), false, NORMAL); + LIT("}"); + break; + + 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: + 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); + LIT("}"); + return 0; // Don't process further nodes to avoid double-rendering artefacts + case EMAIL_AUTOLINK: + LIT("\\href{"); + OUT(url, false, URL); + LIT("}{\\nolinkurl{"); + break; + case NORMAL_LINK: + LIT("\\href{"); + OUT(url, false, URL); + LIT("}{"); + break; + case INTERNAL_LINK: + LIT("\\protect\\hyperlink{"); + OUT(url + 1, false, URL); + LIT("}{"); + break; + case NO_LINK: + LIT("{"); // error? + } + } else { + if (get_link_type(node) == EMAIL_AUTOLINK) { + LIT("}"); // Close up \nolinkurl argument + } + 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/cmark/src/libcmark.pc.in b/cmark/src/libcmark.pc.in new file mode 100644 index 0000000000..e259898a91 --- /dev/null +++ b/cmark/src/libcmark.pc.in @@ -0,0 +1,10 @@ +prefix=@CMAKE_INSTALL_PREFIX@ +exec_prefix=@CMAKE_INSTALL_PREFIX@ +libdir=@CMAKE_INSTALL_FULL_LIBDIR@ +includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ + +Name: libcmark +Description: CommonMark parsing, rendering, and manipulation +Version: @PROJECT_VERSION@ +Libs: -L${libdir} -lcmark +Cflags: -I${includedir} diff --git a/cmark/src/main.c b/cmark/src/main.c new file mode 100644 index 0000000000..9a43cceda7 --- /dev/null +++ b/cmark/src/main.c @@ -0,0 +1,213 @@ +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "cmark.h" +#include "node.h" + +#if defined(__OpenBSD__) +# include <sys/param.h> +# if OpenBSD >= 201605 +# define USE_PLEDGE +# include <unistd.h> +# endif +#endif + +#if defined(_WIN32) && !defined(__CYGWIN__) +#include <io.h> +#include <fcntl.h> +#endif + +typedef enum { + FORMAT_NONE, + FORMAT_HTML, + FORMAT_XML, + FORMAT_MAN, + FORMAT_COMMONMARK, + FORMAT_LATEX +} writer_format; + +void print_usage(void) { + printf("Usage: cmark [FILE*]\n"); + printf("Options:\n"); + printf(" --to, -t FORMAT Specify output format (html, xml, man, " + "commonmark, latex)\n"); + printf(" --width WIDTH Specify wrap width (default 0 = nowrap)\n"); + printf(" --sourcepos Include source position attribute\n"); + printf(" --hardbreaks Treat newlines as hard line breaks\n"); + printf(" --nobreaks Render soft line breaks as spaces\n"); + printf(" --safe Omit raw HTML and dangerous URLs\n"); + printf(" --unsafe Render raw HTML and dangerous URLs\n"); + printf(" --smart Use smart punctuation\n"); + printf(" --validate-utf8 Replace invalid UTF-8 sequences with U+FFFD\n"); + printf(" --help, -h Print usage information\n"); + printf(" --version Print version\n"); +} + +static void print_document(cmark_node *document, writer_format writer, + int options, int width) { + char *result; + + switch (writer) { + case FORMAT_HTML: + result = cmark_render_html(document, options); + break; + case FORMAT_XML: + result = cmark_render_xml(document, options); + break; + case FORMAT_MAN: + result = cmark_render_man(document, options, width); + break; + case FORMAT_COMMONMARK: + result = cmark_render_commonmark(document, options, width); + break; + case FORMAT_LATEX: + result = cmark_render_latex(document, options, width); + break; + default: + fprintf(stderr, "Unknown format %d\n", writer); + exit(1); + } + fwrite(result, strlen(result), 1, stdout); + document->mem->free(result); +} + +int main(int argc, char *argv[]) { + int i, numfps = 0; + int *files; + char buffer[4096]; + cmark_parser *parser; + size_t bytes; + cmark_node *document; + int width = 0; + char *unparsed; + writer_format writer = FORMAT_HTML; + int options = CMARK_OPT_DEFAULT; + +#ifdef USE_PLEDGE + if (pledge("stdio rpath", NULL) != 0) { + perror("pledge"); + return 1; + } +#endif + +#if defined(_WIN32) && !defined(__CYGWIN__) + _setmode(_fileno(stdin), _O_BINARY); + _setmode(_fileno(stdout), _O_BINARY); +#endif + + files = (int *)calloc(argc, sizeof(*files)); + + for (i = 1; i < argc; i++) { + if (strcmp(argv[i], "--version") == 0) { + printf("cmark %s", CMARK_VERSION_STRING); + printf(" - CommonMark converter\n(C) 2014-2016 John MacFarlane\n"); + exit(0); + } else if (strcmp(argv[i], "--sourcepos") == 0) { + options |= CMARK_OPT_SOURCEPOS; + } else if (strcmp(argv[i], "--hardbreaks") == 0) { + options |= CMARK_OPT_HARDBREAKS; + } else if (strcmp(argv[i], "--nobreaks") == 0) { + options |= CMARK_OPT_NOBREAKS; + } else if (strcmp(argv[i], "--smart") == 0) { + options |= CMARK_OPT_SMART; + } else if (strcmp(argv[i], "--safe") == 0) { + options |= CMARK_OPT_SAFE; + } else if (strcmp(argv[i], "--unsafe") == 0) { + options |= CMARK_OPT_UNSAFE; + } else if (strcmp(argv[i], "--validate-utf8") == 0) { + options |= CMARK_OPT_VALIDATE_UTF8; + } else if ((strcmp(argv[i], "--help") == 0) || + (strcmp(argv[i], "-h") == 0)) { + print_usage(); + exit(0); + } else if (strcmp(argv[i], "--width") == 0) { + i += 1; + if (i < argc) { + width = (int)strtol(argv[i], &unparsed, 10); + if (unparsed && strlen(unparsed) > 0) { + fprintf(stderr, "failed parsing width '%s' at '%s'\n", argv[i], + unparsed); + exit(1); + } + } else { + fprintf(stderr, "--width requires an argument\n"); + exit(1); + } + } else if ((strcmp(argv[i], "-t") == 0) || (strcmp(argv[i], "--to") == 0)) { + i += 1; + if (i < argc) { + if (strcmp(argv[i], "man") == 0) { + writer = FORMAT_MAN; + } else if (strcmp(argv[i], "html") == 0) { + writer = FORMAT_HTML; + } else if (strcmp(argv[i], "xml") == 0) { + writer = FORMAT_XML; + } else if (strcmp(argv[i], "commonmark") == 0) { + writer = FORMAT_COMMONMARK; + } else if (strcmp(argv[i], "latex") == 0) { + writer = FORMAT_LATEX; + } else { + fprintf(stderr, "Unknown format %s\n", argv[i]); + exit(1); + } + } else { + fprintf(stderr, "No argument provided for %s\n", argv[i - 1]); + exit(1); + } + } else if (*argv[i] == '-') { + print_usage(); + exit(1); + } else { // treat as file argument + files[numfps++] = i; + } + } + + parser = cmark_parser_new(options); + for (i = 0; i < numfps; i++) { + FILE *fp = fopen(argv[files[i]], "rb"); + if (fp == NULL) { + fprintf(stderr, "Error opening file %s: %s\n", argv[files[i]], + strerror(errno)); + exit(1); + } + + while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { + cmark_parser_feed(parser, buffer, bytes); + if (bytes < sizeof(buffer)) { + break; + } + } + + fclose(fp); + } + + if (numfps == 0) { + + while ((bytes = fread(buffer, 1, sizeof(buffer), stdin)) > 0) { + cmark_parser_feed(parser, buffer, bytes); + if (bytes < sizeof(buffer)) { + break; + } + } + } + +#ifdef USE_PLEDGE + if (pledge("stdio", NULL) != 0) { + perror("pledge"); + return 1; + } +#endif + + document = cmark_parser_finish(parser); + cmark_parser_free(parser); + + print_document(document, writer, options, width); + + cmark_node_free(document); + + free(files); + + return 0; +} diff --git a/cmark/src/man.c b/cmark/src/man.c new file mode 100644 index 0000000000..02dfb7cb39 --- /dev/null +++ b/cmark/src/man.c @@ -0,0 +1,281 @@ +#include <assert.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "utf8.h" +#include "render.h" + +#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) +#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, + 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); + bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options); + struct block_number *new_block_number; + cmark_mem *allocator = cmark_get_default_mem_allocator(); + + // avoid unused parameter error: + (void)(options); + + // indent inside nested lists + if (renderer->block_number_in_list_item && + node->type < CMARK_NODE_FIRST_INLINE) { + if (entering) { + renderer->block_number_in_list_item->number += 1; + if (renderer->block_number_in_list_item->number == 2) { + CR(); + LIT(".RS"); // indent + CR(); + } + } + } + + 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) { + new_block_number = allocator->calloc(1, sizeof(struct block_number)); + new_block_number->number = 0; + new_block_number->parent = renderer->block_number_in_list_item; + renderer->block_number_in_list_item = new_block_number; + 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[LIST_NUMBER_SIZE]; + snprintf(list_number_s, LIST_NUMBER_SIZE, "\"%d.\" 4", list_number); + LIT(list_number_s); + } + CR(); + } else { + if (renderer->block_number_in_list_item) { + if (renderer->block_number_in_list_item->number >= 2) { + CR(); + LIT(".RE"); // de-indent + } + new_block_number = renderer->block_number_in_list_item; + renderer->block_number_in_list_item = + renderer->block_number_in_list_item->parent; + allocator->free(new_block_number); + } + CR(); + } + break; + + case CMARK_NODE_HEADING: + if (entering) { + CR(); + LIT(cmark_node_get_heading_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_BLOCK: + break; + + 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(); + 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), allow_wrap, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + LIT(".PD 0\n.P\n.PD"); + CR(); + break; + + case CMARK_NODE_SOFTBREAK: + 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(" ", allow_wrap, LITERAL); + } + break; + + case CMARK_NODE_CODE: + LIT("\\f[C]"); + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); + LIT("\\f[]"); + break; + + 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: + 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), allow_wrap, 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); +} diff --git a/cmark/src/node.c b/cmark/src/node.c new file mode 100644 index 0000000000..c1492545e4 --- /dev/null +++ b/cmark/src/node.c @@ -0,0 +1,888 @@ +#include <stdbool.h> +#include <stdlib.h> +#include <string.h> + +#include "node.h" + +static void S_node_unlink(cmark_node *node); + +bool cmark_node_is_block(cmark_node *node) { + if (node == NULL) { + return false; + } + return node->type >= CMARK_NODE_FIRST_BLOCK && + node->type <= CMARK_NODE_LAST_BLOCK; +} + +bool cmark_node_is_inline(cmark_node *node) { + if (node == NULL) { + return false; + } + return node->type >= CMARK_NODE_FIRST_INLINE && + node->type <= CMARK_NODE_LAST_INLINE; +} + +bool cmark_node_is_leaf(cmark_node *node) { + if (node == NULL) { + return false; + } + switch (node->type) { + case CMARK_NODE_THEMATIC_BREAK: return true; + case CMARK_NODE_CODE_BLOCK : return true; + case CMARK_NODE_TEXT : return true; + case CMARK_NODE_SOFTBREAK : return true; + case CMARK_NODE_LINEBREAK : return true; + case CMARK_NODE_CODE : return true; + case CMARK_NODE_HTML_INLINE: return true; + } + return false; +} + +static bool S_can_contain(cmark_node *node, cmark_node *child) { + if (node == NULL || child == NULL || node == child) { + return false; + } + + // Verify that child is not an ancestor of node. + if (child->first_child != NULL) { + cmark_node *cur = node->parent; + + while (cur != NULL) { + if (cur == child) { + return false; + } + cur = cur->parent; + } + } + + 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 cmark_node_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: + case CMARK_NODE_STRONG: + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + case CMARK_NODE_CUSTOM_INLINE: + return cmark_node_is_inline(child); + + default: + break; + } + + return false; +} + +cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) { + cmark_node *node = (cmark_node *)mem->calloc(1, sizeof(*node)); + node->mem = mem; + node->type = (uint16_t)type; + + switch (node->type) { + case CMARK_NODE_HEADING: + node->as.heading.level = 1; + break; + + case CMARK_NODE_LIST: { + cmark_list *list = &node->as.list; + list->list_type = CMARK_BULLET_LIST; + list->start = 0; + list->tight = false; + break; + } + + default: + break; + } + + 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_mem *mem = e->mem; + cmark_node *next; + while (e != NULL) { + switch (e->type) { + case CMARK_NODE_CODE_BLOCK: + mem->free(e->data); + mem->free(e->as.code.info); + break; + case CMARK_NODE_TEXT: + case CMARK_NODE_HTML_INLINE: + case CMARK_NODE_CODE: + case CMARK_NODE_HTML_BLOCK: + mem->free(e->data); + break; + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + mem->free(e->as.link.url); + mem->free(e->as.link.title); + break; + case CMARK_NODE_CUSTOM_BLOCK: + case CMARK_NODE_CUSTOM_INLINE: + mem->free(e->as.custom.on_enter); + mem->free(e->as.custom.on_exit); + 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; + mem->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 (cmark_node_type)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_BLOCK: + return "html_block"; + case CMARK_NODE_CUSTOM_BLOCK: + return "custom_block"; + case CMARK_NODE_PARAGRAPH: + return "paragraph"; + case CMARK_NODE_HEADING: + return "heading"; + case CMARK_NODE_THEMATIC_BREAK: + return "thematic_break"; + 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_HTML_INLINE: + return "html_inline"; + case CMARK_NODE_CUSTOM_INLINE: + return "custom_inline"; + 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 "<unknown>"; +} + +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; + } +} + +static bufsize_t cmark_set_cstr(cmark_mem *mem, unsigned char **dst, + const char *src) { + unsigned char *old = *dst; + bufsize_t len; + + if (src && src[0]) { + len = (bufsize_t)strlen(src); + *dst = (unsigned char *)mem->realloc(NULL, len + 1); + memcpy(*dst, src, len + 1); + } else { + len = 0; + *dst = NULL; + } + if (old) { + mem->free(old); + } + + return len; +} + +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 CMARK_NODE_HTML_BLOCK: + case CMARK_NODE_TEXT: + case CMARK_NODE_HTML_INLINE: + case CMARK_NODE_CODE: + case CMARK_NODE_CODE_BLOCK: + return node->data ? (char *)node->data : ""; + + default: + break; + } + + return NULL; +} + +int cmark_node_set_literal(cmark_node *node, const char *content) { + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_HTML_BLOCK: + case CMARK_NODE_TEXT: + case CMARK_NODE_HTML_INLINE: + case CMARK_NODE_CODE: + case CMARK_NODE_CODE_BLOCK: + node->len = cmark_set_cstr(node->mem, &node->data, content); + return 1; + + default: + break; + } + + return 0; +} + +int cmark_node_get_heading_level(cmark_node *node) { + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_HEADING: + return node->as.heading.level; + + default: + break; + } + + return 0; +} + +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_HEADING: + node->as.heading.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 (cmark_list_type)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 = (unsigned char)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 (cmark_delim_type)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 = (unsigned char)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 == CMARK_NODE_CODE_BLOCK) { + return node->as.code.info ? (char *)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 == CMARK_NODE_CODE_BLOCK) { + cmark_set_cstr(node->mem, &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 CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + return node->as.link.url ? (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 CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + cmark_set_cstr(node->mem, &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 CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + return node->as.link.title ? (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 CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + cmark_set_cstr(node->mem, &node->as.link.title, title); + return 1; + default: + break; + } + + 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 node->as.custom.on_enter ? (char *)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_set_cstr(node->mem, &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 node->as.custom.on_exit ? (char *)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_set_cstr(node->mem, &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; + } + 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_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; + } + + 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/cmark/src/node.h b/cmark/src/node.h new file mode 100644 index 0000000000..3d9ddcf54b --- /dev/null +++ b/cmark/src/node.h @@ -0,0 +1,93 @@ +#ifndef CMARK_NODE_H +#define CMARK_NODE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> + +#include "cmark.h" +#include "buffer.h" + +typedef struct { + int marker_offset; + int padding; + int start; + unsigned char list_type; + unsigned char delimiter; + unsigned char bullet_char; + bool tight; +} cmark_list; + +typedef struct { + unsigned char *info; + uint8_t fence_length; + uint8_t fence_offset; + unsigned char fence_char; + int8_t fenced; +} cmark_code; + +typedef struct { + int internal_offset; + int8_t level; + bool setext; +} cmark_heading; + +typedef struct { + unsigned char *url; + unsigned char *title; +} cmark_link; + +typedef struct { + unsigned char *on_enter; + unsigned char *on_exit; +} cmark_custom; + +enum cmark_node__internal_flags { + CMARK_NODE__OPEN = (1 << 0), + CMARK_NODE__LAST_LINE_BLANK = (1 << 1), + CMARK_NODE__LAST_LINE_CHECKED = (1 << 2), + CMARK_NODE__LIST_LAST_LINE_BLANK = (1 << 3), +}; + +struct cmark_node { + cmark_mem *mem; + + 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; + + unsigned char *data; + bufsize_t len; + + int start_line; + int start_column; + int end_line; + int end_column; + uint16_t type; + uint16_t flags; + + union { + cmark_list list; + cmark_code code; + cmark_heading heading; + cmark_link link; + cmark_custom custom; + int html_block_type; + } as; +}; + +CMARK_EXPORT int cmark_node_check(cmark_node *node, FILE *out); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/src/parser.h b/cmark/src/parser.h new file mode 100644 index 0000000000..f546ace11b --- /dev/null +++ b/cmark/src/parser.h @@ -0,0 +1,42 @@ +#ifndef CMARK_AST_H +#define CMARK_AST_H + +#include <stdio.h> +#include "references.h" +#include "node.h" +#include "buffer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#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; + int line_number; + bufsize_t offset; + bufsize_t column; + bufsize_t first_nonspace; + bufsize_t first_nonspace_column; + bufsize_t thematic_break_kill_pos; + int indent; + bool blank; + bool partially_consumed_tab; + cmark_strbuf curline; + bufsize_t last_line_length; + cmark_strbuf linebuf; + cmark_strbuf content; + int options; + bool last_buffer_ended_with_cr; + unsigned int total_size; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/src/references.c b/cmark/src/references.c new file mode 100644 index 0000000000..96d793b708 --- /dev/null +++ b/cmark/src/references.c @@ -0,0 +1,171 @@ +#include "cmark.h" +#include "utf8.h" +#include "parser.h" +#include "references.h" +#include "inlines.h" +#include "chunk.h" + +static void reference_free(cmark_reference_map *map, cmark_reference *ref) { + cmark_mem *mem = map->mem; + if (ref != NULL) { + mem->free(ref->label); + mem->free(ref->url); + mem->free(ref->title); + mem->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_mem *mem, cmark_chunk *ref) { + cmark_strbuf normalized = CMARK_BUF_INIT(mem); + unsigned char *result; + + if (ref == NULL) + return NULL; + + if (ref->len == 0) + return NULL; + + 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); + + if (result[0] == '\0') { + mem->free(result); + return NULL; + } + + return result; +} + +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(map->mem, label); + + /* empty reference name, or composed from only whitespace */ + if (reflabel == NULL) + return; + + assert(map->sorted == NULL); + + ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref)); + ref->label = reflabel; + ref->url = cmark_clean_url(map->mem, url); + ref->title = cmark_clean_title(map->mem, title); + ref->age = map->size; + ref->next = map->refs; + + if (ref->url != NULL) + ref->size += (int)strlen((char*)ref->url); + if (ref->title != NULL) + ref->size += (int)strlen((char*)ref->title); + + map->refs = ref; + map->size++; +} + +static int +labelcmp(const unsigned char *a, const unsigned char *b) { + return strcmp((const char *)a, (const char *)b); +} + +static int +refcmp(const void *p1, const void *p2) { + cmark_reference *r1 = *(cmark_reference **)p1; + cmark_reference *r2 = *(cmark_reference **)p2; + int res = labelcmp(r1->label, r2->label); + return res ? res : ((int)r1->age - (int)r2->age); +} + +static int +refsearch(const void *label, const void *p2) { + cmark_reference *ref = *(cmark_reference **)p2; + return labelcmp((const unsigned char *)label, ref->label); +} + +static void sort_references(cmark_reference_map *map) { + unsigned int i = 0, last = 0, size = map->size; + cmark_reference *r = map->refs, **sorted = NULL; + + sorted = (cmark_reference **)map->mem->calloc(size, sizeof(cmark_reference *)); + while (r) { + sorted[i++] = r; + r = r->next; + } + + qsort(sorted, size, sizeof(cmark_reference *), refcmp); + + for (i = 1; i < size; i++) { + if (labelcmp(sorted[i]->label, sorted[last]->label) != 0) + sorted[++last] = sorted[i]; + } + map->sorted = sorted; + map->size = last + 1; +} + +// 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; + cmark_reference *r = NULL; + unsigned char *norm; + + if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH) + return NULL; + + if (map == NULL || !map->size) + return NULL; + + norm = normalize_reference(map->mem, label); + if (norm == NULL) + return NULL; + + if (!map->sorted) + sort_references(map); + + ref = (cmark_reference **)bsearch(norm, map->sorted, map->size, sizeof(cmark_reference *), + refsearch); + map->mem->free(norm); + + if (ref != NULL) { + r = ref[0]; + /* Check for expansion limit */ + if (map->max_ref_size && r->size > map->max_ref_size - map->ref_size) + return NULL; + map->ref_size += r->size; + } + + return r; +} + +void cmark_reference_map_free(cmark_reference_map *map) { + cmark_reference *ref; + + if (map == NULL) + return; + + ref = map->refs; + while (ref) { + cmark_reference *next = ref->next; + reference_free(map, ref); + ref = next; + } + + map->mem->free(map->sorted); + map->mem->free(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/cmark/src/references.h b/cmark/src/references.h new file mode 100644 index 0000000000..27f15de2a4 --- /dev/null +++ b/cmark/src/references.h @@ -0,0 +1,43 @@ +#ifndef CMARK_REFERENCES_H +#define CMARK_REFERENCES_H + +#include "chunk.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct cmark_reference { + struct cmark_reference *next; + unsigned char *label; + unsigned char *url; + unsigned char *title; + unsigned int age; + unsigned int size; +}; + +typedef struct cmark_reference cmark_reference; + +struct cmark_reference_map { + cmark_mem *mem; + cmark_reference *refs; + cmark_reference **sorted; + unsigned int size; + unsigned int ref_size; + unsigned int max_ref_size; +}; + +typedef struct cmark_reference_map cmark_reference_map; + +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); +void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, + cmark_chunk *url, cmark_chunk *title); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/src/render.c b/cmark/src/render.c new file mode 100644 index 0000000000..0404deba15 --- /dev/null +++ b/cmark/src/render.c @@ -0,0 +1,195 @@ +#include <stdlib.h> +#include "buffer.h" +#include "cmark.h" +#include "utf8.h" +#include "render.h" +#include "node.h" +#include "cmark_ctype.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 = (int)strlen(source); + unsigned char nextc; + int32_t c; + int i = 0; + int last_nonspace; + int len; + int k = renderer->buffer->size - 1; + + wrap = wrap && !renderer->no_linebreaks; + + 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->last_breakable = 0; + renderer->begin_line = true; + renderer->begin_content = 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) { + last_nonspace = renderer->buffer->size; + cmark_strbuf_putc(renderer->buffer, ' '); + renderer->column += 1; + renderer->begin_line = false; + renderer->begin_content = false; + // 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 (escape == LITERAL) { + if (c == 10) { + cmark_strbuf_putc(renderer->buffer, '\n'); + renderer->column = 0; + renderer->begin_line = true; + renderer->begin_content = true; + renderer->last_breakable = 0; + } else { + cmark_render_code_point(renderer, c); + renderer->begin_line = 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 = + renderer->begin_content && cmark_isdigit(c) == 1; + } + + // 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 + unsigned char *src = renderer->buffer->ptr + + renderer->last_breakable + 1; + bufsize_t remainder_len = renderer->buffer->size - + renderer->last_breakable - 1; + unsigned char *remainder = + (unsigned char *)renderer->mem->realloc(NULL, remainder_len); + memcpy(remainder, src, remainder_len); + // 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, remainder_len); + renderer->column = renderer->prefix->size + remainder_len; + renderer->mem->free(remainder); + renderer->last_breakable = 0; + renderer->begin_line = false; + renderer->begin_content = 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) { + 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_mem *mem = root->mem; + 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 = {options, + mem, &buf, &pref, 0, width, + 0, 0, true, true, false, + false, NULL, + 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); + } + } + + // If the root node is a block type (i.e. not inline), ensure there's a final newline: + if (cmark_node_is_block(root)) { + if (renderer.buffer->size == 0 || 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/cmark/src/render.h b/cmark/src/render.h new file mode 100644 index 0000000000..6f71acbd4e --- /dev/null +++ b/cmark/src/render.h @@ -0,0 +1,57 @@ +#ifndef CMARK_RENDER_H +#define CMARK_RENDER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdbool.h> +#include <stdlib.h> + +#include "buffer.h" + +typedef enum { LITERAL, NORMAL, TITLE, URL } cmark_escaping; + +struct block_number { + int number; + struct block_number *parent; +}; + +struct cmark_renderer { + int options; + cmark_mem *mem; + cmark_strbuf *buffer; + cmark_strbuf *prefix; + int column; + int width; + int need_cr; + bufsize_t last_breakable; + bool begin_line; + bool begin_content; + bool no_linebreaks; + bool in_tight_list_item; + struct block_number *block_number_in_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/cmark/src/scanners.c b/cmark/src/scanners.c new file mode 100644 index 0000000000..7338c75b76 --- /dev/null +++ b/cmark/src/scanners.c @@ -0,0 +1,9415 @@ +/* Generated by re2c 3.0 */ +#include <stdlib.h> +#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; + + 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; +} + +// Try to match a scheme including colon. +bufsize_t _scan_scheme(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + yych = *p; + if (yych <= '@') + goto yy1; + if (yych <= 'Z') + goto yy3; + if (yych <= '`') + goto yy1; + if (yych <= 'z') + goto yy3; + yy1: + ++p; + yy2 : { return 0; } + yy3: + yych = *(marker = ++p); + if (yych <= '/') { + if (yych <= '+') { + if (yych <= '*') + goto yy2; + } else { + if (yych <= ',') + goto yy2; + if (yych >= '/') + goto yy2; + } + } else { + if (yych <= 'Z') { + if (yych <= '9') + goto yy4; + if (yych <= '@') + goto yy2; + } else { + if (yych <= '`') + goto yy2; + if (yych >= '{') + goto yy2; + } + } + yy4: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych == '+') + goto yy6; + } else { + if (yych != '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych >= 'A') + goto yy6; + } else { + if (yych <= '`') + goto yy5; + if (yych <= 'z') + goto yy6; + } + } + yy5: + p = marker; + goto yy2; + yy6: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych == '+') + goto yy8; + goto yy5; + } else { + if (yych == '/') + goto yy5; + goto yy8; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + goto yy8; + } else { + if (yych <= '`') + goto yy5; + if (yych <= 'z') + goto yy8; + goto yy5; + } + } + yy7: + ++p; + { return (bufsize_t)(p - start); } + yy8: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy5; + } else { + if (yych == '/') + goto yy5; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy7; + if (yych <= '@') + goto yy5; + } else { + if (yych <= '`') + goto yy5; + if (yych >= '{') + goto yy5; + } + } + yych = *++p; + if (yych == ':') + goto yy7; + goto yy5; + } +} + +// 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, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 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; + if (yych <= '@') + goto yy10; + if (yych <= 'Z') + goto yy12; + if (yych <= '`') + goto yy10; + if (yych <= 'z') + goto yy12; + yy10: + ++p; + yy11 : { return 0; } + yy12: + yych = *(marker = ++p); + if (yych <= '/') { + if (yych <= '+') { + if (yych <= '*') + goto yy11; + } else { + if (yych <= ',') + goto yy11; + if (yych >= '/') + goto yy11; + } + } else { + if (yych <= 'Z') { + if (yych <= '9') + goto yy13; + if (yych <= '@') + goto yy11; + } else { + if (yych <= '`') + goto yy11; + if (yych >= '{') + goto yy11; + } + } + yy13: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych == '+') + goto yy15; + } else { + if (yych != '/') + goto yy15; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych >= 'A') + goto yy15; + } else { + if (yych <= '`') + goto yy14; + if (yych <= 'z') + goto yy15; + } + } + yy14: + p = marker; + goto yy11; + yy15: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych == '+') + goto yy17; + goto yy14; + } else { + if (yych == '/') + goto yy14; + goto yy17; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + goto yy17; + } else { + if (yych <= '`') + goto yy14; + if (yych <= 'z') + goto yy17; + goto yy14; + } + } + yy16: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy16; + } + if (yych <= '<') + goto yy14; + goto yy18; + yy17: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych == '+') + goto yy19; + goto yy14; + } else { + if (yych == '/') + goto yy14; + goto yy19; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + goto yy19; + } else { + if (yych <= '`') + goto yy14; + if (yych <= 'z') + goto yy19; + goto yy14; + } + } + yy18: + ++p; + { return (bufsize_t)(p - start); } + yy19: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy14; + } else { + if (yych == '/') + goto yy14; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy16; + if (yych <= '@') + goto yy14; + } else { + if (yych <= '`') + goto yy14; + if (yych >= '{') + goto yy14; + } + } + yych = *++p; + if (yych == ':') + goto yy16; + goto yy14; + } +} + +// 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, 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 <= '9') { + if (yych <= '\'') { + if (yych == '!') + goto yy23; + if (yych >= '#') + goto yy23; + } else { + if (yych <= ')') + goto yy21; + if (yych != ',') + goto yy23; + } + } else { + if (yych <= '?') { + if (yych == '=') + goto yy23; + if (yych >= '?') + goto yy23; + } else { + if (yych <= 'Z') { + if (yych >= 'A') + goto yy23; + } else { + if (yych <= ']') + goto yy21; + if (yych <= '~') + goto yy23; + } + } + } + yy21: + ++p; + yy22 : { return 0; } + yy23: + yych = *(marker = ++p); + if (yych <= ',') { + if (yych <= '"') { + if (yych == '!') + goto yy25; + goto yy22; + } else { + if (yych <= '\'') + goto yy25; + if (yych <= ')') + goto yy22; + if (yych <= '+') + goto yy25; + goto yy22; + } + } else { + if (yych <= '>') { + if (yych <= '9') + goto yy25; + if (yych == '=') + goto yy25; + goto yy22; + } else { + if (yych <= 'Z') + goto yy25; + if (yych <= ']') + goto yy22; + if (yych <= '~') + goto yy25; + goto yy22; + } + } + yy24: + yych = *++p; + yy25: + if (yybm[0 + yych] & 128) { + goto yy24; + } + if (yych <= '>') + goto yy26; + if (yych <= '@') + goto yy27; + yy26: + p = marker; + goto yy22; + yy27: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') + goto yy26; + if (yych >= ':') + goto yy26; + } else { + if (yych <= 'Z') + goto yy28; + if (yych <= '`') + goto yy26; + if (yych >= '{') + goto yy26; + } + yy28: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy29; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy29; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy29; + goto yy26; + } + } + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy31; + if (yych <= '/') + goto yy26; + goto yy32; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy32; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy32; + goto yy26; + } + } + yy29: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych <= '-') + goto yy31; + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy32; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy32; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy32; + goto yy26; + } + } + yy30: + ++p; + { return (bufsize_t)(p - start); } + yy31: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy33; + if (yych <= '/') + goto yy26; + goto yy34; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy34; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy34; + goto yy26; + } + } + yy32: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy34; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy34; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy34; + goto yy26; + } + } + yy33: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy35; + if (yych <= '/') + goto yy26; + goto yy36; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy36; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy36; + goto yy26; + } + } + yy34: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy36; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy36; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy36; + goto yy26; + } + } + yy35: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy37; + if (yych <= '/') + goto yy26; + goto yy38; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy38; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy38; + goto yy26; + } + } + yy36: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy38; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy38; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy38; + goto yy26; + } + } + yy37: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy39; + if (yych <= '/') + goto yy26; + goto yy40; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy40; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy40; + goto yy26; + } + } + yy38: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy40; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy40; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy40; + goto yy26; + } + } + yy39: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy41; + if (yych <= '/') + goto yy26; + goto yy42; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy42; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy42; + goto yy26; + } + } + yy40: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy42; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy42; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy42; + goto yy26; + } + } + yy41: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy43; + if (yych <= '/') + goto yy26; + goto yy44; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy44; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy44; + goto yy26; + } + } + yy42: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy44; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy44; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy44; + goto yy26; + } + } + yy43: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy45; + if (yych <= '/') + goto yy26; + goto yy46; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy46; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy46; + goto yy26; + } + } + yy44: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy46; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy46; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy46; + goto yy26; + } + } + yy45: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy47; + if (yych <= '/') + goto yy26; + goto yy48; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy48; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy48; + goto yy26; + } + } + yy46: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy48; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy48; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy48; + goto yy26; + } + } + yy47: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy49; + if (yych <= '/') + goto yy26; + goto yy50; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy50; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy50; + goto yy26; + } + } + yy48: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy50; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy50; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy50; + goto yy26; + } + } + yy49: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy51; + if (yych <= '/') + goto yy26; + goto yy52; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy52; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy52; + goto yy26; + } + } + yy50: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy52; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy52; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy52; + goto yy26; + } + } + yy51: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy53; + if (yych <= '/') + goto yy26; + goto yy54; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy54; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy54; + goto yy26; + } + } + yy52: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy54; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy54; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy54; + goto yy26; + } + } + yy53: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy55; + if (yych <= '/') + goto yy26; + goto yy56; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy56; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy56; + goto yy26; + } + } + yy54: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy56; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy56; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy56; + goto yy26; + } + } + yy55: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy57; + if (yych <= '/') + goto yy26; + goto yy58; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy58; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy58; + goto yy26; + } + } + yy56: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy58; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy58; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy58; + goto yy26; + } + } + yy57: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy59; + if (yych <= '/') + goto yy26; + goto yy60; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy60; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy60; + goto yy26; + } + } + yy58: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy60; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy60; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy60; + goto yy26; + } + } + yy59: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy61; + if (yych <= '/') + goto yy26; + goto yy62; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy62; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy62; + goto yy26; + } + } + yy60: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy62; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy62; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy62; + goto yy26; + } + } + yy61: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy63; + if (yych <= '/') + goto yy26; + goto yy64; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy64; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy64; + goto yy26; + } + } + yy62: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy64; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy64; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy64; + goto yy26; + } + } + yy63: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy65; + if (yych <= '/') + goto yy26; + goto yy66; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy66; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy66; + goto yy26; + } + } + yy64: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy66; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy66; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy66; + goto yy26; + } + } + yy65: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy67; + if (yych <= '/') + goto yy26; + goto yy68; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy68; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy68; + goto yy26; + } + } + yy66: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy68; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy68; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy68; + goto yy26; + } + } + yy67: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy69; + if (yych <= '/') + goto yy26; + goto yy70; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy70; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy70; + goto yy26; + } + } + yy68: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy70; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy70; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy70; + goto yy26; + } + } + yy69: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy71; + if (yych <= '/') + goto yy26; + goto yy72; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy72; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy72; + goto yy26; + } + } + yy70: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy72; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy72; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy72; + goto yy26; + } + } + yy71: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy73; + if (yych <= '/') + goto yy26; + goto yy74; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy74; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy74; + goto yy26; + } + } + yy72: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy74; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy74; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy74; + goto yy26; + } + } + yy73: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy75; + if (yych <= '/') + goto yy26; + goto yy76; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy76; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy76; + goto yy26; + } + } + yy74: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy76; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy76; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy76; + goto yy26; + } + } + yy75: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy77; + if (yych <= '/') + goto yy26; + goto yy78; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy78; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy78; + goto yy26; + } + } + yy76: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy78; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy78; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy78; + goto yy26; + } + } + yy77: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy79; + if (yych <= '/') + goto yy26; + goto yy80; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy80; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy80; + goto yy26; + } + } + yy78: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy80; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy80; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy80; + goto yy26; + } + } + yy79: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy81; + if (yych <= '/') + goto yy26; + goto yy82; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy82; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy82; + goto yy26; + } + } + yy80: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy82; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy82; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy82; + goto yy26; + } + } + yy81: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy83; + if (yych <= '/') + goto yy26; + goto yy84; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy84; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy84; + goto yy26; + } + } + yy82: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy84; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy84; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy84; + goto yy26; + } + } + yy83: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy85; + if (yych <= '/') + goto yy26; + goto yy86; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy86; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy86; + goto yy26; + } + } + yy84: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy86; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy86; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy86; + goto yy26; + } + } + yy85: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy87; + if (yych <= '/') + goto yy26; + goto yy88; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy88; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy88; + goto yy26; + } + } + yy86: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy88; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy88; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy88; + goto yy26; + } + } + yy87: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy89; + if (yych <= '/') + goto yy26; + goto yy90; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy90; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy90; + goto yy26; + } + } + yy88: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy90; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy90; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy90; + goto yy26; + } + } + yy89: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy91; + if (yych <= '/') + goto yy26; + goto yy92; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy92; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy92; + goto yy26; + } + } + yy90: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy92; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy92; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy92; + goto yy26; + } + } + yy91: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy93; + if (yych <= '/') + goto yy26; + goto yy94; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy94; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy94; + goto yy26; + } + } + yy92: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy94; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy94; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy94; + goto yy26; + } + } + yy93: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy95; + if (yych <= '/') + goto yy26; + goto yy96; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy96; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy96; + goto yy26; + } + } + yy94: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy96; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy96; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy96; + goto yy26; + } + } + yy95: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy97; + if (yych <= '/') + goto yy26; + goto yy98; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy98; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy98; + goto yy26; + } + } + yy96: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy98; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy98; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy98; + goto yy26; + } + } + yy97: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy99; + if (yych <= '/') + goto yy26; + goto yy100; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy100; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy100; + goto yy26; + } + } + yy98: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy100; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy100; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy100; + goto yy26; + } + } + yy99: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy101; + if (yych <= '/') + goto yy26; + goto yy102; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy102; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy102; + goto yy26; + } + } + yy100: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy102; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy102; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy102; + goto yy26; + } + } + yy101: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy103; + if (yych <= '/') + goto yy26; + goto yy104; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy104; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy104; + goto yy26; + } + } + yy102: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy104; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy104; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy104; + goto yy26; + } + } + yy103: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy105; + if (yych <= '/') + goto yy26; + goto yy106; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy106; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy106; + goto yy26; + } + } + yy104: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy106; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy106; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy106; + goto yy26; + } + } + yy105: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy107; + if (yych <= '/') + goto yy26; + goto yy108; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy108; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy108; + goto yy26; + } + } + yy106: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy108; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy108; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy108; + goto yy26; + } + } + yy107: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy109; + if (yych <= '/') + goto yy26; + goto yy110; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy110; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy110; + goto yy26; + } + } + yy108: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy110; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy110; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy110; + goto yy26; + } + } + yy109: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy111; + if (yych <= '/') + goto yy26; + goto yy112; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy112; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy112; + goto yy26; + } + } + yy110: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy112; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy112; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy112; + goto yy26; + } + } + yy111: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy113; + if (yych <= '/') + goto yy26; + goto yy114; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy114; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy114; + goto yy26; + } + } + yy112: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy114; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy114; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy114; + goto yy26; + } + } + yy113: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy115; + if (yych <= '/') + goto yy26; + goto yy116; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy116; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy116; + goto yy26; + } + } + yy114: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy116; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy116; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy116; + goto yy26; + } + } + yy115: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy117; + if (yych <= '/') + goto yy26; + goto yy118; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy118; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy118; + goto yy26; + } + } + yy116: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy118; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy118; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy118; + goto yy26; + } + } + yy117: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy119; + if (yych <= '/') + goto yy26; + goto yy120; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy120; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy120; + goto yy26; + } + } + yy118: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy120; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy120; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy120; + goto yy26; + } + } + yy119: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy121; + if (yych <= '/') + goto yy26; + goto yy122; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy122; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy122; + goto yy26; + } + } + yy120: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy122; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy122; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy122; + goto yy26; + } + } + yy121: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy123; + if (yych <= '/') + goto yy26; + goto yy124; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy124; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy124; + goto yy26; + } + } + yy122: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy124; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy124; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy124; + goto yy26; + } + } + yy123: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy125; + if (yych <= '/') + goto yy26; + goto yy126; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy126; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy126; + goto yy26; + } + } + yy124: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy126; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy126; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy126; + goto yy26; + } + } + yy125: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy127; + if (yych <= '/') + goto yy26; + goto yy128; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy128; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy128; + goto yy26; + } + } + yy126: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy128; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy128; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy128; + goto yy26; + } + } + yy127: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy129; + if (yych <= '/') + goto yy26; + goto yy130; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy130; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy130; + goto yy26; + } + } + yy128: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy130; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy130; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy130; + goto yy26; + } + } + yy129: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy131; + if (yych <= '/') + goto yy26; + goto yy132; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy132; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy132; + goto yy26; + } + } + yy130: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy132; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy132; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy132; + goto yy26; + } + } + yy131: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy133; + if (yych <= '/') + goto yy26; + goto yy134; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy134; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy134; + goto yy26; + } + } + yy132: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy134; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy134; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy134; + goto yy26; + } + } + yy133: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy135; + if (yych <= '/') + goto yy26; + goto yy136; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy136; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy136; + goto yy26; + } + } + yy134: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy136; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy136; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy136; + goto yy26; + } + } + yy135: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy137; + if (yych <= '/') + goto yy26; + goto yy138; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy138; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy138; + goto yy26; + } + } + yy136: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy138; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy138; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy138; + goto yy26; + } + } + yy137: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy139; + if (yych <= '/') + goto yy26; + goto yy140; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy140; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy140; + goto yy26; + } + } + yy138: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy140; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy140; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy140; + goto yy26; + } + } + yy139: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy141; + if (yych <= '/') + goto yy26; + goto yy142; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy142; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy142; + goto yy26; + } + } + yy140: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy142; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy142; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy142; + goto yy26; + } + } + yy141: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy143; + if (yych <= '/') + goto yy26; + goto yy144; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy144; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy144; + goto yy26; + } + } + yy142: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy144; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy144; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy144; + goto yy26; + } + } + yy143: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy145; + if (yych <= '/') + goto yy26; + goto yy146; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy146; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy146; + goto yy26; + } + } + yy144: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy146; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy146; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy146; + goto yy26; + } + } + yy145: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy147; + if (yych <= '/') + goto yy26; + goto yy148; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy148; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy148; + goto yy26; + } + } + yy146: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy148; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy148; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy148; + goto yy26; + } + } + yy147: + yych = *++p; + if (yych <= '9') { + if (yych == '-') + goto yy149; + if (yych <= '/') + goto yy26; + goto yy150; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy26; + goto yy150; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy150; + goto yy26; + } + } + yy148: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy26; + if (yych >= '.') + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy150; + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + goto yy150; + } else { + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy150; + goto yy26; + } + } + yy149: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') + goto yy26; + if (yych <= '9') + goto yy151; + goto yy26; + } else { + if (yych <= 'Z') + goto yy151; + if (yych <= '`') + goto yy26; + if (yych <= 'z') + goto yy151; + goto yy26; + } + yy150: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= '-') + goto yy26; + goto yy27; + } else { + if (yych <= '/') + goto yy26; + if (yych >= ':') + goto yy26; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy30; + if (yych <= '@') + goto yy26; + } else { + if (yych <= '`') + goto yy26; + if (yych >= '{') + goto yy26; + } + } + yy151: + yych = *++p; + if (yych == '.') + goto yy27; + if (yych == '>') + goto yy30; + goto yy26; + } +} + +// Try to match an HTML tag after first <, returning num of chars matched. +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[] = { + 0, 224, 224, 224, 224, 224, 224, 224, 224, 200, 200, 200, 200, 200, + 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 200, 224, 128, 224, 224, 224, 224, 64, 224, 224, + 224, 224, 224, 244, 240, 224, 244, 244, 244, 244, 244, 244, 244, 244, + 244, 244, 240, 224, 192, 192, 192, 224, 224, 244, 244, 244, 244, 244, + 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, + 244, 244, 244, 244, 244, 244, 244, 224, 224, 224, 224, 240, 192, 244, + 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, + 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 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, 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, 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, + }; + yych = *p; + if (yych <= '@') { + if (yych == '/') + goto yy155; + } else { + if (yych <= 'Z') + goto yy156; + if (yych <= '`') + goto yy153; + if (yych <= 'z') + goto yy156; + } + yy153: + ++p; + yy154 : { return 0; } + yy155: + yych = *(marker = ++p); + if (yych <= '@') + goto yy154; + if (yych <= 'Z') + goto yy157; + if (yych <= '`') + goto yy154; + if (yych <= 'z') + goto yy157; + goto yy154; + yy156: + yych = *(marker = ++p); + if (yych <= '.') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy154; + if (yych <= '\r') + goto yy161; + goto yy154; + } else { + if (yych <= ' ') + goto yy161; + if (yych == '-') + goto yy161; + goto yy154; + } + } else { + if (yych <= '@') { + if (yych <= '9') + goto yy161; + if (yych == '>') + goto yy161; + goto yy154; + } else { + if (yych <= 'Z') + goto yy161; + if (yych <= '`') + goto yy154; + if (yych <= 'z') + goto yy161; + goto yy154; + } + } + yy157: + yych = *++p; + if (yybm[0 + yych] & 4) { + goto yy157; + } + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy158; + if (yych <= '\r') + goto yy164; + } else { + if (yych <= ' ') + goto yy164; + if (yych == '>') + goto yy163; + } + yy158: + p = marker; + goto yy154; + yy159: + yych = *++p; + if (yybm[0 + yych] & 8) { + goto yy159; + } + if (yych <= '>') { + if (yych <= '9') { + if (yych == '/') + goto yy162; + goto yy158; + } else { + if (yych <= ':') + goto yy165; + if (yych <= '=') + goto yy158; + goto yy163; + } + } else { + if (yych <= '^') { + if (yych <= '@') + goto yy158; + if (yych <= 'Z') + goto yy165; + goto yy158; + } else { + if (yych == '`') + goto yy158; + if (yych <= 'z') + goto yy165; + goto yy158; + } + } + yy160: + yych = *++p; + yy161: + if (yybm[0 + yych] & 8) { + goto yy159; + } + if (yych <= '=') { + if (yych <= '.') { + if (yych == '-') + goto yy160; + goto yy158; + } else { + if (yych <= '/') + goto yy162; + if (yych <= '9') + goto yy160; + goto yy158; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy163; + if (yych <= '@') + goto yy158; + goto yy160; + } else { + if (yych <= '`') + goto yy158; + if (yych <= 'z') + goto yy160; + goto yy158; + } + } + yy162: + yych = *++p; + if (yych != '>') + goto yy158; + yy163: + ++p; + { return (bufsize_t)(p - start); } + yy164: + yych = *++p; + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy158; + if (yych <= '\r') + goto yy164; + goto yy158; + } else { + if (yych <= ' ') + goto yy164; + if (yych == '>') + goto yy163; + goto yy158; + } + yy165: + yych = *++p; + if (yybm[0 + yych] & 16) { + goto yy165; + } + if (yych <= ',') { + if (yych <= '\r') { + if (yych <= 0x08) + goto yy158; + } else { + if (yych != ' ') + goto yy158; + } + } else { + if (yych <= '<') { + if (yych <= '/') + goto yy162; + goto yy158; + } else { + if (yych <= '=') + goto yy167; + if (yych <= '>') + goto yy163; + goto yy158; + } + } + yy166: + yych = *++p; + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy158; + if (yych <= '\r') + goto yy166; + if (yych <= 0x1F) + goto yy158; + goto yy166; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy158; + goto yy162; + } else { + if (yych == ':') + goto yy165; + goto yy158; + } + } + } else { + if (yych <= 'Z') { + if (yych <= '=') + goto yy167; + if (yych <= '>') + goto yy163; + if (yych <= '@') + goto yy158; + goto yy165; + } else { + if (yych <= '_') { + if (yych <= '^') + goto yy158; + goto yy165; + } else { + if (yych <= '`') + goto yy158; + if (yych <= 'z') + goto yy165; + goto yy158; + } + } + } + yy167: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy168; + } + if (yych <= 0x00) + goto yy158; + if (yych <= ' ') + goto yy167; + if (yych <= '"') + goto yy169; + if (yych <= '\'') + goto yy170; + goto yy158; + yy168: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy168; + } + if (yych <= 0x00) + goto yy158; + if (yych <= ' ') + goto yy159; + if (yych == '>') + goto yy163; + goto yy158; + yy169: + yych = *++p; + if (yybm[0 + yych] & 64) { + goto yy169; + } + if (yych <= 0x00) + goto yy158; + goto yy171; + yy170: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy170; + } + if (yych <= 0x00) + goto yy158; + yy171: + yych = *++p; + if (yybm[0 + yych] & 8) { + goto yy159; + } + if (yych == '/') + goto yy162; + if (yych == '>') + goto yy163; + goto yy158; + } +} + +bufsize_t _scan_html_comment(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 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, 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, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, + }; + yych = *p; + if (yych == '-') + goto yy174; + ++p; + yy173 : { return 0; } + yy174: + yych = *(marker = ++p); + if (yych != '-') + goto yy173; + yy175: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy175; + } + if (yych >= 0x01) + goto yy177; + yy176: + p = marker; + goto yy173; + yy177: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy175; + } + if (yych <= 0x00) + goto yy176; + yych = *++p; + if (yych <= 0x00) + goto yy176; + if (yych != '>') + goto yy175; + ++p; + { return (bufsize_t)(p - start); } + } +} + +bufsize_t _scan_html_pi(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 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, 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, + }; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy180; + } + if (yych >= 0x01) + goto yy182; + ++p; + yy179 : { return 0; } + yy180: + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy180; + } + if (yych >= 0x01) + goto yy183; + yy181 : { return (bufsize_t)(p - start); } + yy182: + yych = *++p; + if (yych <= 0x00) + goto yy179; + if (yych == '>') + goto yy179; + goto yy180; + yy183: + yych = *++p; + if (yych <= 0x00) + goto yy184; + if (yych != '>') + goto yy180; + yy184: + p = marker; + goto yy181; + } +} + +bufsize_t _scan_html_declaration(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + (void)marker; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 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, 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; + if (yych <= '@') + goto yy186; + if (yych <= 'Z') + goto yy187; + if (yych <= '`') + goto yy186; + if (yych <= 'z') + goto yy187; + yy186: + ++p; + { return 0; } + yy187: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy187; + } + { return (bufsize_t)(p - start); } + } +} + +bufsize_t _scan_html_cdata(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, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 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; + if (yych == 'C') + goto yy190; + if (yych == 'c') + goto yy190; + ++p; + yy189 : { return 0; } + yy190: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'D') + goto yy191; + if (yych != 'd') + goto yy189; + yy191: + yych = *++p; + if (yych == 'A') + goto yy193; + if (yych == 'a') + goto yy193; + yy192: + p = marker; + if (yyaccept == 0) { + goto yy189; + } else { + goto yy197; + } + yy193: + yych = *++p; + if (yych == 'T') + goto yy194; + if (yych != 't') + goto yy192; + yy194: + yych = *++p; + if (yych == 'A') + goto yy195; + if (yych != 'a') + goto yy192; + yy195: + yych = *++p; + if (yych != '[') + goto yy192; + yy196: + yyaccept = 1; + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy196; + } + if (yych >= 0x01) + goto yy198; + yy197 : { return (bufsize_t)(p - start); } + yy198: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy196; + } + if (yych <= 0x00) + goto yy192; + yych = *++p; + if (yych <= 0x00) + goto yy192; + if (yych == '>') + goto yy192; + goto yy196; + } +} + +// 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 = *p; + if (yych == '<') + goto yy201; + ++p; + yy200 : { return 0; } + yy201: + yych = *(marker = ++p); + switch (yych) { + case '!': + goto yy202; + case '/': + goto yy204; + case '?': + goto yy205; + case 'A': + case 'a': + goto yy206; + case 'B': + case 'b': + goto yy207; + case 'C': + case 'c': + goto yy208; + case 'D': + case 'd': + goto yy209; + case 'F': + case 'f': + goto yy210; + case 'H': + case 'h': + goto yy211; + case 'I': + case 'i': + goto yy212; + case 'L': + case 'l': + goto yy213; + case 'M': + case 'm': + goto yy214; + case 'N': + case 'n': + goto yy215; + case 'O': + case 'o': + goto yy216; + case 'P': + case 'p': + goto yy217; + case 'S': + case 's': + goto yy218; + case 'T': + case 't': + goto yy219; + case 'U': + case 'u': + goto yy220; + default: + goto yy200; + } + yy202: + yych = *++p; + if (yych <= 'Z') { + if (yych == '-') + goto yy221; + if (yych >= 'A') + goto yy222; + } else { + if (yych <= '[') + goto yy223; + if (yych <= '`') + goto yy203; + if (yych <= 'z') + goto yy222; + } + yy203: + p = marker; + goto yy200; + yy204: + yych = *++p; + switch (yych) { + case 'A': + case 'a': + goto yy206; + case 'B': + case 'b': + goto yy207; + case 'C': + case 'c': + goto yy208; + case 'D': + case 'd': + goto yy209; + case 'F': + case 'f': + goto yy210; + case 'H': + case 'h': + goto yy211; + case 'I': + case 'i': + goto yy212; + case 'L': + case 'l': + goto yy213; + case 'M': + case 'm': + goto yy214; + case 'N': + case 'n': + goto yy215; + case 'O': + case 'o': + goto yy216; + case 'P': + case 'p': + goto yy224; + case 'S': + case 's': + goto yy225; + case 'T': + case 't': + goto yy226; + case 'U': + case 'u': + goto yy220; + default: + goto yy203; + } + yy205: + ++p; + { return 3; } + yy206: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'D') { + if (yych <= 'C') + goto yy203; + goto yy227; + } else { + if (yych <= 'Q') + goto yy203; + if (yych <= 'R') + goto yy228; + goto yy229; + } + } else { + if (yych <= 'q') { + if (yych == 'd') + goto yy227; + goto yy203; + } else { + if (yych <= 'r') + goto yy228; + if (yych <= 's') + goto yy229; + goto yy203; + } + } + yy207: + yych = *++p; + if (yych <= 'O') { + if (yych <= 'K') { + if (yych == 'A') + goto yy230; + goto yy203; + } else { + if (yych <= 'L') + goto yy231; + if (yych <= 'N') + goto yy203; + goto yy232; + } + } else { + if (yych <= 'k') { + if (yych == 'a') + goto yy230; + goto yy203; + } else { + if (yych <= 'l') + goto yy231; + if (yych == 'o') + goto yy232; + goto yy203; + } + } + yy208: + yych = *++p; + if (yych <= 'O') { + if (yych <= 'D') { + if (yych == 'A') + goto yy233; + goto yy203; + } else { + if (yych <= 'E') + goto yy234; + if (yych <= 'N') + goto yy203; + goto yy235; + } + } else { + if (yych <= 'd') { + if (yych == 'a') + goto yy233; + goto yy203; + } else { + if (yych <= 'e') + goto yy234; + if (yych == 'o') + goto yy235; + goto yy203; + } + } + yy209: + yych = *++p; + switch (yych) { + case 'D': + case 'L': + case 'T': + case 'd': + case 'l': + case 't': + goto yy236; + case 'E': + case 'e': + goto yy237; + case 'I': + case 'i': + goto yy238; + default: + goto yy203; + } + yy210: + yych = *++p; + if (yych <= 'R') { + if (yych <= 'N') { + if (yych == 'I') + goto yy239; + goto yy203; + } else { + if (yych <= 'O') + goto yy240; + if (yych <= 'Q') + goto yy203; + goto yy241; + } + } else { + if (yych <= 'n') { + if (yych == 'i') + goto yy239; + goto yy203; + } else { + if (yych <= 'o') + goto yy240; + if (yych == 'r') + goto yy241; + goto yy203; + } + } + yy211: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'D') { + if (yych <= '0') + goto yy203; + if (yych <= '6') + goto yy236; + goto yy203; + } else { + if (yych <= 'E') + goto yy242; + if (yych == 'R') + goto yy236; + goto yy203; + } + } else { + if (yych <= 'q') { + if (yych <= 'T') + goto yy243; + if (yych == 'e') + goto yy242; + goto yy203; + } else { + if (yych <= 'r') + goto yy236; + if (yych == 't') + goto yy243; + goto yy203; + } + } + yy212: + yych = *++p; + if (yych == 'F') + goto yy244; + if (yych == 'f') + goto yy244; + goto yy203; + yy213: + yych = *++p; + if (yych <= 'I') { + if (yych == 'E') + goto yy245; + if (yych <= 'H') + goto yy203; + goto yy246; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy203; + goto yy245; + } else { + if (yych == 'i') + goto yy246; + goto yy203; + } + } + yy214: + yych = *++p; + if (yych <= 'E') { + if (yych == 'A') + goto yy247; + if (yych <= 'D') + goto yy203; + goto yy248; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy203; + goto yy247; + } else { + if (yych == 'e') + goto yy248; + goto yy203; + } + } + yy215: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') + goto yy249; + if (yych <= 'N') + goto yy203; + goto yy250; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy203; + goto yy249; + } else { + if (yych == 'o') + goto yy250; + goto yy203; + } + } + yy216: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') + goto yy236; + if (yych <= 'O') + goto yy203; + goto yy251; + } else { + if (yych <= 'l') { + if (yych <= 'k') + goto yy203; + goto yy236; + } else { + if (yych == 'p') + goto yy251; + goto yy203; + } + } + yy217: + yych = *++p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + if (yych <= 0x1F) + goto yy203; + goto yy252; + } else { + if (yych == '/') + goto yy253; + if (yych <= '=') + goto yy203; + goto yy252; + } + } else { + if (yych <= 'R') { + if (yych == 'A') + goto yy254; + if (yych <= 'Q') + goto yy203; + goto yy255; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy203; + goto yy254; + } else { + if (yych == 'r') + goto yy255; + goto yy203; + } + } + } + yy218: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'D') { + if (yych == 'C') + goto yy256; + goto yy203; + } else { + if (yych <= 'E') + goto yy257; + if (yych <= 'S') + goto yy203; + if (yych <= 'T') + goto yy258; + goto yy259; + } + } else { + if (yych <= 'e') { + if (yych == 'c') + goto yy256; + if (yych <= 'd') + goto yy203; + goto yy257; + } else { + if (yych <= 's') + goto yy203; + if (yych <= 't') + goto yy258; + if (yych <= 'u') + goto yy259; + goto yy203; + } + } + yy219: + yych = *++p; + switch (yych) { + case 'A': + case 'a': + goto yy260; + case 'B': + case 'b': + goto yy261; + case 'D': + case 'd': + goto yy236; + case 'E': + case 'e': + goto yy262; + case 'F': + case 'f': + goto yy263; + case 'H': + case 'h': + goto yy264; + case 'I': + case 'i': + goto yy265; + case 'R': + case 'r': + goto yy266; + default: + goto yy203; + } + yy220: + yych = *++p; + if (yych == 'L') + goto yy236; + if (yych == 'l') + goto yy236; + goto yy203; + yy221: + yych = *++p; + if (yych == '-') + goto yy267; + goto yy203; + yy222: + ++p; + { return 4; } + yy223: + yych = *++p; + if (yych == 'C') + goto yy268; + if (yych == 'c') + goto yy268; + goto yy203; + yy224: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + goto yy203; + } else { + if (yych <= ' ') + goto yy252; + if (yych <= '.') + goto yy203; + goto yy253; + } + } else { + if (yych <= '@') { + if (yych == '>') + goto yy252; + goto yy203; + } else { + if (yych <= 'A') + goto yy254; + if (yych == 'a') + goto yy254; + goto yy203; + } + } + yy225: + yych = *++p; + if (yych <= 'U') { + if (yych == 'E') + goto yy257; + if (yych <= 'T') + goto yy203; + goto yy259; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy203; + goto yy257; + } else { + if (yych == 'u') + goto yy259; + goto yy203; + } + } + yy226: + yych = *++p; + switch (yych) { + case 'A': + case 'a': + goto yy260; + case 'B': + case 'b': + goto yy261; + case 'D': + case 'd': + goto yy236; + case 'F': + case 'f': + goto yy263; + case 'H': + case 'h': + goto yy264; + case 'I': + case 'i': + goto yy265; + case 'R': + case 'r': + goto yy266; + default: + goto yy203; + } + yy227: + yych = *++p; + if (yych == 'D') + goto yy269; + if (yych == 'd') + goto yy269; + goto yy203; + yy228: + yych = *++p; + if (yych == 'T') + goto yy270; + if (yych == 't') + goto yy270; + goto yy203; + yy229: + yych = *++p; + if (yych == 'I') + goto yy271; + if (yych == 'i') + goto yy271; + goto yy203; + yy230: + yych = *++p; + if (yych == 'S') + goto yy272; + if (yych == 's') + goto yy272; + goto yy203; + yy231: + yych = *++p; + if (yych == 'O') + goto yy273; + if (yych == 'o') + goto yy273; + goto yy203; + yy232: + yych = *++p; + if (yych == 'D') + goto yy274; + if (yych == 'd') + goto yy274; + goto yy203; + yy233: + yych = *++p; + if (yych == 'P') + goto yy275; + if (yych == 'p') + goto yy275; + goto yy203; + yy234: + yych = *++p; + if (yych == 'N') + goto yy276; + if (yych == 'n') + goto yy276; + goto yy203; + yy235: + yych = *++p; + if (yych == 'L') + goto yy277; + if (yych == 'l') + goto yy277; + goto yy203; + yy236: + yych = *++p; + if (yych <= ' ') { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + if (yych <= 0x1F) + goto yy203; + goto yy252; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy203; + goto yy253; + } else { + if (yych == '>') + goto yy252; + goto yy203; + } + } + yy237: + yych = *++p; + if (yych == 'T') + goto yy278; + if (yych == 't') + goto yy278; + goto yy203; + yy238: + yych = *++p; + if (yych <= 'V') { + if (yych <= 'Q') { + if (yych == 'A') + goto yy279; + goto yy203; + } else { + if (yych <= 'R') + goto yy236; + if (yych <= 'U') + goto yy203; + goto yy236; + } + } else { + if (yych <= 'q') { + if (yych == 'a') + goto yy279; + goto yy203; + } else { + if (yych <= 'r') + goto yy236; + if (yych == 'v') + goto yy236; + goto yy203; + } + } + yy239: + yych = *++p; + if (yych <= 'G') { + if (yych == 'E') + goto yy280; + if (yych <= 'F') + goto yy203; + goto yy281; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy203; + goto yy280; + } else { + if (yych == 'g') + goto yy281; + goto yy203; + } + } + yy240: + yych = *++p; + if (yych <= 'R') { + if (yych == 'O') + goto yy276; + if (yych <= 'Q') + goto yy203; + goto yy282; + } else { + if (yych <= 'o') { + if (yych <= 'n') + goto yy203; + goto yy276; + } else { + if (yych == 'r') + goto yy282; + goto yy203; + } + } + yy241: + yych = *++p; + if (yych == 'A') + goto yy283; + if (yych == 'a') + goto yy283; + goto yy203; + yy242: + yych = *++p; + if (yych == 'A') + goto yy284; + if (yych == 'a') + goto yy284; + goto yy203; + yy243: + yych = *++p; + if (yych == 'M') + goto yy220; + if (yych == 'm') + goto yy220; + goto yy203; + yy244: + yych = *++p; + if (yych == 'R') + goto yy285; + if (yych == 'r') + goto yy285; + goto yy203; + yy245: + yych = *++p; + if (yych == 'G') + goto yy286; + if (yych == 'g') + goto yy286; + goto yy203; + yy246: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + goto yy203; + } else { + if (yych <= ' ') + goto yy252; + if (yych <= '.') + goto yy203; + goto yy253; + } + } else { + if (yych <= 'M') { + if (yych == '>') + goto yy252; + goto yy203; + } else { + if (yych <= 'N') + goto yy287; + if (yych == 'n') + goto yy287; + goto yy203; + } + } + yy247: + yych = *++p; + if (yych == 'I') + goto yy288; + if (yych == 'i') + goto yy288; + goto yy203; + yy248: + yych = *++p; + if (yych == 'N') + goto yy289; + if (yych == 'n') + goto yy289; + goto yy203; + yy249: + yych = *++p; + if (yych == 'V') + goto yy236; + if (yych == 'v') + goto yy236; + goto yy203; + yy250: + yych = *++p; + if (yych == 'F') + goto yy290; + if (yych == 'f') + goto yy290; + goto yy203; + yy251: + yych = *++p; + if (yych == 'T') + goto yy291; + if (yych == 't') + goto yy291; + goto yy203; + yy252: + ++p; + { return 6; } + yy253: + yych = *++p; + if (yych == '>') + goto yy252; + goto yy203; + yy254: + yych = *++p; + if (yych == 'R') + goto yy292; + if (yych == 'r') + goto yy292; + goto yy203; + yy255: + yych = *++p; + if (yych == 'E') + goto yy293; + if (yych == 'e') + goto yy293; + goto yy203; + yy256: + yych = *++p; + if (yych == 'R') + goto yy294; + if (yych == 'r') + goto yy294; + goto yy203; + yy257: + yych = *++p; + if (yych <= 'C') { + if (yych == 'A') + goto yy295; + if (yych <= 'B') + goto yy203; + goto yy275; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy203; + goto yy295; + } else { + if (yych == 'c') + goto yy275; + goto yy203; + } + } + yy258: + yych = *++p; + if (yych == 'Y') + goto yy296; + if (yych == 'y') + goto yy296; + goto yy203; + yy259: + yych = *++p; + if (yych == 'M') + goto yy297; + if (yych == 'm') + goto yy297; + goto yy203; + yy260: + yych = *++p; + if (yych == 'B') + goto yy298; + if (yych == 'b') + goto yy298; + goto yy203; + yy261: + yych = *++p; + if (yych == 'O') + goto yy232; + if (yych == 'o') + goto yy232; + goto yy203; + yy262: + yych = *++p; + if (yych == 'X') + goto yy299; + if (yych == 'x') + goto yy299; + goto yy203; + yy263: + yych = *++p; + if (yych == 'O') + goto yy300; + if (yych == 'o') + goto yy300; + goto yy203; + yy264: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + goto yy203; + } else { + if (yych <= ' ') + goto yy252; + if (yych <= '.') + goto yy203; + goto yy253; + } + } else { + if (yych <= 'D') { + if (yych == '>') + goto yy252; + goto yy203; + } else { + if (yych <= 'E') + goto yy301; + if (yych == 'e') + goto yy301; + goto yy203; + } + } + yy265: + yych = *++p; + if (yych == 'T') + goto yy298; + if (yych == 't') + goto yy298; + goto yy203; + yy266: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + goto yy203; + } else { + if (yych <= ' ') + goto yy252; + if (yych <= '.') + goto yy203; + goto yy253; + } + } else { + if (yych <= '@') { + if (yych == '>') + goto yy252; + goto yy203; + } else { + if (yych <= 'A') + goto yy302; + if (yych == 'a') + goto yy302; + goto yy203; + } + } + yy267: + ++p; + { return 2; } + yy268: + yych = *++p; + if (yych == 'D') + goto yy303; + if (yych == 'd') + goto yy303; + goto yy203; + yy269: + yych = *++p; + if (yych == 'R') + goto yy304; + if (yych == 'r') + goto yy304; + goto yy203; + yy270: + yych = *++p; + if (yych == 'I') + goto yy305; + if (yych == 'i') + goto yy305; + goto yy203; + yy271: + yych = *++p; + if (yych == 'D') + goto yy306; + if (yych == 'd') + goto yy306; + goto yy203; + yy272: + yych = *++p; + if (yych == 'E') + goto yy307; + if (yych == 'e') + goto yy307; + goto yy203; + yy273: + yych = *++p; + if (yych == 'C') + goto yy308; + if (yych == 'c') + goto yy308; + goto yy203; + yy274: + yych = *++p; + if (yych == 'Y') + goto yy236; + if (yych == 'y') + goto yy236; + goto yy203; + yy275: + yych = *++p; + if (yych == 'T') + goto yy309; + if (yych == 't') + goto yy309; + goto yy203; + yy276: + yych = *++p; + if (yych == 'T') + goto yy310; + if (yych == 't') + goto yy310; + goto yy203; + yy277: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + goto yy203; + } else { + if (yych <= ' ') + goto yy252; + if (yych <= '.') + goto yy203; + goto yy253; + } + } else { + if (yych <= 'F') { + if (yych == '>') + goto yy252; + goto yy203; + } else { + if (yych <= 'G') + goto yy311; + if (yych == 'g') + goto yy311; + goto yy203; + } + } + yy278: + yych = *++p; + if (yych == 'A') + goto yy312; + if (yych == 'a') + goto yy312; + goto yy203; + yy279: + yych = *++p; + if (yych == 'L') + goto yy313; + if (yych == 'l') + goto yy313; + goto yy203; + yy280: + yych = *++p; + if (yych == 'L') + goto yy314; + if (yych == 'l') + goto yy314; + goto yy203; + yy281: + yych = *++p; + if (yych <= 'U') { + if (yych == 'C') + goto yy315; + if (yych <= 'T') + goto yy203; + goto yy316; + } else { + if (yych <= 'c') { + if (yych <= 'b') + goto yy203; + goto yy315; + } else { + if (yych == 'u') + goto yy316; + goto yy203; + } + } + yy282: + yych = *++p; + if (yych == 'M') + goto yy236; + if (yych == 'm') + goto yy236; + goto yy203; + yy283: + yych = *++p; + if (yych == 'M') + goto yy317; + if (yych == 'm') + goto yy317; + goto yy203; + yy284: + yych = *++p; + if (yych == 'D') + goto yy318; + if (yych == 'd') + goto yy318; + goto yy203; + yy285: + yych = *++p; + if (yych == 'A') + goto yy319; + if (yych == 'a') + goto yy319; + goto yy203; + yy286: + yych = *++p; + if (yych == 'E') + goto yy320; + if (yych == 'e') + goto yy320; + goto yy203; + yy287: + yych = *++p; + if (yych == 'K') + goto yy236; + if (yych == 'k') + goto yy236; + goto yy203; + yy288: + yych = *++p; + if (yych == 'N') + goto yy236; + if (yych == 'n') + goto yy236; + goto yy203; + yy289: + yych = *++p; + if (yych == 'U') + goto yy321; + if (yych == 'u') + goto yy321; + goto yy203; + yy290: + yych = *++p; + if (yych == 'R') + goto yy322; + if (yych == 'r') + goto yy322; + goto yy203; + yy291: + yych = *++p; + if (yych <= 'I') { + if (yych == 'G') + goto yy311; + if (yych <= 'H') + goto yy203; + goto yy323; + } else { + if (yych <= 'g') { + if (yych <= 'f') + goto yy203; + goto yy311; + } else { + if (yych == 'i') + goto yy323; + goto yy203; + } + } + yy292: + yych = *++p; + if (yych == 'A') + goto yy282; + if (yych == 'a') + goto yy282; + goto yy203; + yy293: + yych = *++p; + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy324; + goto yy203; + } else { + if (yych <= ' ') + goto yy324; + if (yych == '>') + goto yy324; + goto yy203; + } + yy294: + yych = *++p; + if (yych == 'I') + goto yy325; + if (yych == 'i') + goto yy325; + goto yy203; + yy295: + yych = *++p; + if (yych == 'R') + goto yy326; + if (yych == 'r') + goto yy326; + goto yy203; + yy296: + yych = *++p; + if (yych == 'L') + goto yy255; + if (yych == 'l') + goto yy255; + goto yy203; + yy297: + yych = *++p; + if (yych == 'M') + goto yy327; + if (yych == 'm') + goto yy327; + goto yy203; + yy298: + yych = *++p; + if (yych == 'L') + goto yy306; + if (yych == 'l') + goto yy306; + goto yy203; + yy299: + yych = *++p; + if (yych == 'T') + goto yy328; + if (yych == 't') + goto yy328; + goto yy203; + yy300: + yych = *++p; + if (yych == 'O') + goto yy329; + if (yych == 'o') + goto yy329; + goto yy203; + yy301: + yych = *++p; + if (yych == 'A') + goto yy330; + if (yych == 'a') + goto yy330; + goto yy203; + yy302: + yych = *++p; + if (yych == 'C') + goto yy287; + if (yych == 'c') + goto yy287; + goto yy203; + yy303: + yych = *++p; + if (yych == 'A') + goto yy331; + if (yych == 'a') + goto yy331; + goto yy203; + yy304: + yych = *++p; + if (yych == 'E') + goto yy332; + if (yych == 'e') + goto yy332; + goto yy203; + yy305: + yych = *++p; + if (yych == 'C') + goto yy298; + if (yych == 'c') + goto yy298; + goto yy203; + yy306: + yych = *++p; + if (yych == 'E') + goto yy236; + if (yych == 'e') + goto yy236; + goto yy203; + yy307: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + goto yy203; + } else { + if (yych <= ' ') + goto yy252; + if (yych <= '.') + goto yy203; + goto yy253; + } + } else { + if (yych <= 'E') { + if (yych == '>') + goto yy252; + goto yy203; + } else { + if (yych <= 'F') + goto yy333; + if (yych == 'f') + goto yy333; + goto yy203; + } + } + yy308: + yych = *++p; + if (yych == 'K') + goto yy334; + if (yych == 'k') + goto yy334; + goto yy203; + yy309: + yych = *++p; + if (yych == 'I') + goto yy323; + if (yych == 'i') + goto yy323; + goto yy203; + yy310: + yych = *++p; + if (yych == 'E') + goto yy335; + if (yych == 'e') + goto yy335; + goto yy203; + yy311: + yych = *++p; + if (yych == 'R') + goto yy336; + if (yych == 'r') + goto yy336; + goto yy203; + yy312: + yych = *++p; + if (yych == 'I') + goto yy337; + if (yych == 'i') + goto yy337; + goto yy203; + yy313: + yych = *++p; + if (yych == 'O') + goto yy338; + if (yych == 'o') + goto yy338; + goto yy203; + yy314: + yych = *++p; + if (yych == 'D') + goto yy339; + if (yych == 'd') + goto yy339; + goto yy203; + yy315: + yych = *++p; + if (yych == 'A') + goto yy233; + if (yych == 'a') + goto yy233; + goto yy203; + yy316: + yych = *++p; + if (yych == 'R') + goto yy306; + if (yych == 'r') + goto yy306; + goto yy203; + yy317: + yych = *++p; + if (yych == 'E') + goto yy340; + if (yych == 'e') + goto yy340; + goto yy203; + yy318: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + goto yy203; + } else { + if (yych <= ' ') + goto yy252; + if (yych <= '.') + goto yy203; + goto yy253; + } + } else { + if (yych <= 'D') { + if (yych == '>') + goto yy252; + goto yy203; + } else { + if (yych <= 'E') + goto yy335; + if (yych == 'e') + goto yy335; + goto yy203; + } + } + yy319: + yych = *++p; + if (yych == 'M') + goto yy306; + if (yych == 'm') + goto yy306; + goto yy203; + yy320: + yych = *++p; + if (yych == 'N') + goto yy330; + if (yych == 'n') + goto yy330; + goto yy203; + yy321: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + goto yy203; + } else { + if (yych <= ' ') + goto yy252; + if (yych <= '.') + goto yy203; + goto yy253; + } + } else { + if (yych <= 'H') { + if (yych == '>') + goto yy252; + goto yy203; + } else { + if (yych <= 'I') + goto yy341; + if (yych == 'i') + goto yy341; + goto yy203; + } + } + yy322: + yych = *++p; + if (yych == 'A') + goto yy342; + if (yych == 'a') + goto yy342; + goto yy203; + yy323: + yych = *++p; + if (yych == 'O') + goto yy288; + if (yych == 'o') + goto yy288; + goto yy203; + yy324: + ++p; + { return 1; } + yy325: + yych = *++p; + if (yych == 'P') + goto yy343; + if (yych == 'p') + goto yy343; + goto yy203; + yy326: + yych = *++p; + if (yych == 'C') + goto yy344; + if (yych == 'c') + goto yy344; + goto yy203; + yy327: + yych = *++p; + if (yych == 'A') + goto yy345; + if (yych == 'a') + goto yy345; + goto yy203; + yy328: + yych = *++p; + if (yych == 'A') + goto yy346; + if (yych == 'a') + goto yy346; + goto yy203; + yy329: + yych = *++p; + if (yych == 'T') + goto yy236; + if (yych == 't') + goto yy236; + goto yy203; + yy330: + yych = *++p; + if (yych == 'D') + goto yy236; + if (yych == 'd') + goto yy236; + goto yy203; + yy331: + yych = *++p; + if (yych == 'T') + goto yy347; + if (yych == 't') + goto yy347; + goto yy203; + yy332: + yych = *++p; + if (yych == 'S') + goto yy348; + if (yych == 's') + goto yy348; + goto yy203; + yy333: + yych = *++p; + if (yych == 'O') + goto yy349; + if (yych == 'o') + goto yy349; + goto yy203; + yy334: + yych = *++p; + if (yych == 'Q') + goto yy350; + if (yych == 'q') + goto yy350; + goto yy203; + yy335: + yych = *++p; + if (yych == 'R') + goto yy236; + if (yych == 'r') + goto yy236; + goto yy203; + yy336: + yych = *++p; + if (yych == 'O') + goto yy351; + if (yych == 'o') + goto yy351; + goto yy203; + yy337: + yych = *++p; + if (yych == 'L') + goto yy348; + if (yych == 'l') + goto yy348; + goto yy203; + yy338: + yych = *++p; + if (yych == 'G') + goto yy236; + if (yych == 'g') + goto yy236; + goto yy203; + yy339: + yych = *++p; + if (yych == 'S') + goto yy352; + if (yych == 's') + goto yy352; + goto yy203; + yy340: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy203; + if (yych <= '\r') + goto yy252; + goto yy203; + } else { + if (yych <= ' ') + goto yy252; + if (yych <= '.') + goto yy203; + goto yy253; + } + } else { + if (yych <= 'R') { + if (yych == '>') + goto yy252; + goto yy203; + } else { + if (yych <= 'S') + goto yy352; + if (yych == 's') + goto yy352; + goto yy203; + } + } + yy341: + yych = *++p; + if (yych == 'T') + goto yy353; + if (yych == 't') + goto yy353; + goto yy203; + yy342: + yych = *++p; + if (yych == 'M') + goto yy354; + if (yych == 'm') + goto yy354; + goto yy203; + yy343: + yych = *++p; + if (yych == 'T') + goto yy293; + if (yych == 't') + goto yy293; + goto yy203; + yy344: + yych = *++p; + if (yych == 'H') + goto yy236; + if (yych == 'h') + goto yy236; + goto yy203; + yy345: + yych = *++p; + if (yych == 'R') + goto yy274; + if (yych == 'r') + goto yy274; + goto yy203; + yy346: + yych = *++p; + if (yych == 'R') + goto yy355; + if (yych == 'r') + goto yy355; + goto yy203; + yy347: + yych = *++p; + if (yych == 'A') + goto yy356; + if (yych == 'a') + goto yy356; + goto yy203; + yy348: + yych = *++p; + if (yych == 'S') + goto yy236; + if (yych == 's') + goto yy236; + goto yy203; + yy349: + yych = *++p; + if (yych == 'N') + goto yy329; + if (yych == 'n') + goto yy329; + goto yy203; + yy350: + yych = *++p; + if (yych == 'U') + goto yy357; + if (yych == 'u') + goto yy357; + goto yy203; + yy351: + yych = *++p; + if (yych == 'U') + goto yy358; + if (yych == 'u') + goto yy358; + goto yy203; + yy352: + yych = *++p; + if (yych == 'E') + goto yy329; + if (yych == 'e') + goto yy329; + goto yy203; + yy353: + yych = *++p; + if (yych == 'E') + goto yy282; + if (yych == 'e') + goto yy282; + goto yy203; + yy354: + yych = *++p; + if (yych == 'E') + goto yy348; + if (yych == 'e') + goto yy348; + goto yy203; + yy355: + yych = *++p; + if (yych == 'E') + goto yy359; + if (yych == 'e') + goto yy359; + goto yy203; + yy356: + yych = *++p; + if (yych == '[') + goto yy360; + goto yy203; + yy357: + yych = *++p; + if (yych == 'O') + goto yy361; + if (yych == 'o') + goto yy361; + goto yy203; + yy358: + yych = *++p; + if (yych == 'P') + goto yy236; + if (yych == 'p') + goto yy236; + goto yy203; + yy359: + yych = *++p; + if (yych == 'A') + goto yy293; + if (yych == 'a') + goto yy293; + goto yy203; + yy360: + ++p; + { return 5; } + yy361: + yych = *++p; + if (yych == 'T') + goto yy306; + if (yych == 't') + goto yy306; + goto yy203; + } +} + +// 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, 210, 194, 198, 194, + 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 198, 224, 128, 224, 224, 224, 224, 64, 224, 224, + 224, 224, 224, 233, 232, 224, 233, 233, 233, 233, 233, 233, 233, 233, + 233, 233, 232, 224, 192, 192, 192, 224, 224, 233, 233, 233, 233, 233, + 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, + 233, 233, 233, 233, 233, 233, 233, 224, 224, 224, 224, 232, 192, 233, + 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, + 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 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, 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, 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, + }; + yych = *p; + if (yych == '<') + goto yy364; + ++p; + yy363 : { return 0; } + yy364: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '@') { + if (yych != '/') + goto yy363; + } else { + if (yych <= 'Z') + goto yy366; + if (yych <= '`') + goto yy363; + if (yych <= 'z') + goto yy366; + goto yy363; + } + yych = *++p; + if (yych <= '@') + goto yy365; + if (yych <= 'Z') + goto yy367; + if (yych <= '`') + goto yy365; + if (yych <= 'z') + goto yy367; + yy365: + p = marker; + if (yyaccept == 0) { + goto yy363; + } else { + goto yy374; + } + yy366: + yych = *++p; + if (yybm[0 + yych] & 2) { + goto yy368; + } + if (yych <= '=') { + if (yych <= '.') { + if (yych == '-') + goto yy366; + goto yy365; + } else { + if (yych <= '/') + goto yy369; + if (yych <= '9') + goto yy366; + goto yy365; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy370; + if (yych <= '@') + goto yy365; + goto yy366; + } else { + if (yych <= '`') + goto yy365; + if (yych <= 'z') + goto yy366; + goto yy365; + } + } + yy367: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy365; + if (yych <= '\r') + goto yy371; + goto yy365; + } else { + if (yych <= ' ') + goto yy371; + if (yych == '-') + goto yy367; + goto yy365; + } + } else { + if (yych <= '@') { + if (yych <= '9') + goto yy367; + if (yych == '>') + goto yy370; + goto yy365; + } else { + if (yych <= 'Z') + goto yy367; + if (yych <= '`') + goto yy365; + if (yych <= 'z') + goto yy367; + goto yy365; + } + } + yy368: + yych = *++p; + if (yybm[0 + yych] & 2) { + goto yy368; + } + if (yych <= '>') { + if (yych <= '9') { + if (yych != '/') + goto yy365; + } else { + if (yych <= ':') + goto yy372; + if (yych <= '=') + goto yy365; + goto yy370; + } + } else { + if (yych <= '^') { + if (yych <= '@') + goto yy365; + if (yych <= 'Z') + goto yy372; + goto yy365; + } else { + if (yych == '`') + goto yy365; + if (yych <= 'z') + goto yy372; + goto yy365; + } + } + yy369: + yych = *++p; + if (yych != '>') + goto yy365; + yy370: + yych = *++p; + if (yybm[0 + yych] & 4) { + goto yy370; + } + if (yych <= 0x08) + goto yy365; + if (yych <= '\n') + goto yy373; + if (yych <= '\v') + goto yy365; + if (yych <= '\r') + goto yy375; + goto yy365; + yy371: + yych = *++p; + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy365; + if (yych <= '\r') + goto yy371; + goto yy365; + } else { + if (yych <= ' ') + goto yy371; + if (yych == '>') + goto yy370; + goto yy365; + } + yy372: + yych = *++p; + if (yybm[0 + yych] & 8) { + goto yy372; + } + if (yych <= ',') { + if (yych <= '\r') { + if (yych <= 0x08) + goto yy365; + goto yy376; + } else { + if (yych == ' ') + goto yy376; + goto yy365; + } + } else { + if (yych <= '<') { + if (yych <= '/') + goto yy369; + goto yy365; + } else { + if (yych <= '=') + goto yy377; + if (yych <= '>') + goto yy370; + goto yy365; + } + } + yy373: + yyaccept = 1; + yych = *(marker = ++p); + if (yybm[0 + yych] & 4) { + goto yy370; + } + if (yych <= 0x08) + goto yy374; + if (yych <= '\n') + goto yy373; + if (yych <= '\v') + goto yy374; + if (yych <= '\r') + goto yy375; + yy374 : { return 7; } + yy375: + ++p; + goto yy374; + yy376: + yych = *++p; + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy365; + if (yych <= '\r') + goto yy376; + if (yych <= 0x1F) + goto yy365; + goto yy376; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy365; + goto yy369; + } else { + if (yych == ':') + goto yy372; + goto yy365; + } + } + } else { + if (yych <= 'Z') { + if (yych <= '=') + goto yy377; + if (yych <= '>') + goto yy370; + if (yych <= '@') + goto yy365; + goto yy372; + } else { + if (yych <= '_') { + if (yych <= '^') + goto yy365; + goto yy372; + } else { + if (yych <= '`') + goto yy365; + if (yych <= 'z') + goto yy372; + goto yy365; + } + } + } + yy377: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy378; + } + if (yych <= 0x00) + goto yy365; + if (yych <= ' ') + goto yy377; + if (yych <= '"') + goto yy379; + if (yych <= '\'') + goto yy380; + goto yy365; + yy378: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy378; + } + if (yych <= 0x00) + goto yy365; + if (yych <= ' ') + goto yy368; + if (yych == '>') + goto yy370; + goto yy365; + yy379: + yych = *++p; + if (yybm[0 + yych] & 64) { + goto yy379; + } + if (yych <= 0x00) + goto yy365; + goto yy381; + yy380: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy380; + } + if (yych <= 0x00) + goto yy365; + yy381: + yych = *++p; + if (yybm[0 + yych] & 2) { + goto yy368; + } + if (yych == '/') + goto yy369; + if (yych == '>') + goto yy370; + goto yy365; + } +} + +// 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[] = { + 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, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, + }; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x00) + goto yy383; + if (yych <= '\t') + goto yy385; + } else { + if (yych == '<') + goto yy386; + goto yy385; + } + yy383: + ++p; + yy384 : { return 0; } + yy385: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy384; + if (yych == '\n') + goto yy384; + goto yy388; + yy386: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy384; + if (yych <= '\t') + goto yy388; + goto yy384; + } else { + if (yych == '/') + goto yy391; + goto yy388; + } + yy387: + yych = *++p; + yy388: + if (yybm[0 + yych] & 64) { + goto yy387; + } + if (yych >= '\v') + goto yy390; + yy389: + p = marker; + if (yyaccept == 0) { + goto yy384; + } else { + goto yy404; + } + yy390: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy389; + if (yych <= '\t') + goto yy387; + goto yy389; + } else { + if (yych != '/') + goto yy387; + } + yy391: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'S') { + if (yych <= '\n') { + if (yych <= 0x00) + goto yy389; + if (yych <= '\t') + goto yy387; + goto yy389; + } else { + if (yych == 'P') + goto yy392; + if (yych <= 'R') + goto yy387; + goto yy393; + } + } else { + if (yych <= 'p') { + if (yych <= 'T') + goto yy394; + if (yych <= 'o') + goto yy387; + } else { + if (yych <= 'r') + goto yy387; + if (yych <= 's') + goto yy393; + if (yych <= 't') + goto yy394; + goto yy387; + } + } + yy392: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'Q') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'R') + goto yy395; + if (yych == 'r') + goto yy395; + goto yy387; + } + yy393: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'S') { + if (yych <= '\n') { + if (yych <= 0x00) + goto yy389; + if (yych <= '\t') + goto yy387; + goto yy389; + } else { + if (yych == 'C') + goto yy396; + goto yy387; + } + } else { + if (yych <= 'c') { + if (yych <= 'T') + goto yy397; + if (yych <= 'b') + goto yy387; + goto yy396; + } else { + if (yych == 't') + goto yy397; + goto yy387; + } + } + yy394: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'D') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'E') + goto yy398; + if (yych == 'e') + goto yy398; + goto yy387; + } + yy395: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'D') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'E') + goto yy399; + if (yych == 'e') + goto yy399; + goto yy387; + } + yy396: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'Q') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'R') + goto yy400; + if (yych == 'r') + goto yy400; + goto yy387; + } + yy397: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'X') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'Y') + goto yy401; + if (yych == 'y') + goto yy401; + goto yy387; + } + yy398: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'W') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'X') + goto yy402; + if (yych == 'x') + goto yy402; + goto yy387; + } + yy399: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy389; + if (yych <= '\t') + goto yy387; + goto yy389; + } else { + if (yych == '>') + goto yy403; + goto yy387; + } + yy400: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'H') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'I') + goto yy405; + if (yych == 'i') + goto yy405; + goto yy387; + } + yy401: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'K') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'L') + goto yy395; + if (yych == 'l') + goto yy395; + goto yy387; + } + yy402: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'S') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'T') + goto yy406; + if (yych == 't') + goto yy406; + goto yy387; + } + yy403: + yyaccept = 1; + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy387; + } + if (yych >= '\v') + goto yy390; + yy404 : { return (bufsize_t)(p - start); } + yy405: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'O') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'P') + goto yy407; + if (yych == 'p') + goto yy407; + goto yy387; + } + yy406: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= '@') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'A') + goto yy408; + if (yych == 'a') + goto yy408; + goto yy387; + } + yy407: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'S') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'T') + goto yy399; + if (yych == 't') + goto yy399; + goto yy387; + } + yy408: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'Q') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'R') + goto yy409; + if (yych != 'r') + goto yy387; + } + yy409: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= 'D') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'E') + goto yy410; + if (yych != 'e') + goto yy387; + } + yy410: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy390; + } + if (yych <= '@') { + if (yych <= 0x00) + goto yy389; + if (yych == '\n') + goto yy389; + goto yy387; + } else { + if (yych <= 'A') + goto yy399; + if (yych == 'a') + goto yy399; + goto yy387; + } + } +} + +// 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, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, + }; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x00) + goto yy412; + if (yych <= '\t') + goto yy414; + } else { + if (yych == '-') + goto yy415; + goto yy414; + } + yy412: + ++p; + yy413 : { return 0; } + yy414: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy413; + if (yych == '\n') + goto yy413; + goto yy417; + yy415: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy416; + } + if (yych <= '\n') + goto yy413; + goto yy420; + yy416: + yych = *++p; + yy417: + if (yybm[0 + yych] & 64) { + goto yy416; + } + if (yych >= '\v') + goto yy419; + yy418: + p = marker; + if (yyaccept == 0) { + goto yy413; + } else { + goto yy421; + } + yy419: + yych = *++p; + if (yybm[0 + yych] & 64) { + goto yy416; + } + if (yych <= '\n') + goto yy418; + yy420: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy420; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy418; + if (yych <= '\t') + goto yy416; + goto yy418; + } else { + if (yych != '>') + goto yy416; + } + yyaccept = 1; + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy416; + } + if (yych >= '\v') + goto yy419; + yy421 : { 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, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, + }; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x00) + goto yy423; + if (yych <= '\t') + goto yy425; + } else { + if (yych == '?') + goto yy426; + goto yy425; + } + yy423: + ++p; + yy424 : { return 0; } + yy425: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy424; + if (yych == '\n') + goto yy424; + goto yy428; + yy426: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy424; + if (yych <= '\t') + goto yy428; + goto yy424; + } else { + if (yych == '>') + goto yy431; + goto yy428; + } + yy427: + yych = *++p; + yy428: + if (yybm[0 + yych] & 64) { + goto yy427; + } + if (yych >= '\v') + goto yy430; + yy429: + p = marker; + if (yyaccept == 0) { + goto yy424; + } else { + goto yy432; + } + yy430: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy430; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy429; + if (yych <= '\t') + goto yy427; + goto yy429; + } else { + if (yych != '>') + goto yy427; + } + yy431: + yyaccept = 1; + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy427; + } + if (yych >= '\v') + goto yy430; + yy432 : { 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, 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, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 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; + if (yybm[0 + yych] & 64) { + goto yy437; + } + if (yych <= 0x00) + goto yy434; + if (yych != '\n') + goto yy436; + yy434: + ++p; + yy435 : { return 0; } + yy436: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy435; + if (yych == '\n') + goto yy435; + goto yy440; + yy437: + yyaccept = 1; + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy439; + } + if (yych >= '\v') + goto yy437; + yy438 : { return (bufsize_t)(p - start); } + yy439: + yych = *++p; + yy440: + if (yybm[0 + yych] & 128) { + goto yy439; + } + if (yych >= '\v') + goto yy437; + p = marker; + if (yyaccept == 0) { + goto yy435; + } else { + goto yy438; + } + } +} + +// 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, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, + }; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x00) + goto yy442; + if (yych <= '\t') + goto yy444; + } else { + if (yych == ']') + goto yy445; + goto yy444; + } + yy442: + ++p; + yy443 : { return 0; } + yy444: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy443; + if (yych == '\n') + goto yy443; + goto yy447; + yy445: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy446; + } + if (yych <= '\n') + goto yy443; + goto yy450; + yy446: + yych = *++p; + yy447: + if (yybm[0 + yych] & 64) { + goto yy446; + } + if (yych >= '\v') + goto yy449; + yy448: + p = marker; + if (yyaccept == 0) { + goto yy443; + } else { + goto yy451; + } + yy449: + yych = *++p; + if (yybm[0 + yych] & 64) { + goto yy446; + } + if (yych <= '\n') + goto yy448; + yy450: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy450; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy448; + if (yych <= '\t') + goto yy446; + goto yy448; + } else { + if (yych != '>') + goto yy446; + } + yyaccept = 1; + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy446; + } + if (yych >= '\v') + goto yy449; + yy451 : { return (bufsize_t)(p - start); } + } +} + +// 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, 192, 208, 208, 208, 208, 144, 80, 80, + 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 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 == '"') + goto yy454; + } else { + if (yych <= '\'') + goto yy455; + if (yych <= '(') + goto yy456; + } + ++p; + yy453 : { return 0; } + yy454: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy453; + goto yy458; + yy455: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy453; + goto yy464; + yy456: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy453; + if (yych == '(') + goto yy453; + goto yy469; + yy457: + yych = *++p; + yy458: + if (yybm[0 + yych] & 16) { + goto yy457; + } + if (yych <= 0x00) + goto yy459; + if (yych <= '"') + goto yy460; + goto yy462; + yy459: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy453; + } else { + goto yy461; + } + } else { + if (yyaccept == 2) { + goto yy466; + } else { + goto yy471; + } + } + yy460: + ++p; + yy461 : { return (bufsize_t)(p - start); } + yy462: + yych = *++p; + if (yybm[0 + yych] & 16) { + goto yy457; + } + if (yych <= 0x00) + goto yy459; + if (yych <= '"') + goto yy473; + goto yy462; + yy463: + yych = *++p; + yy464: + if (yybm[0 + yych] & 64) { + goto yy463; + } + if (yych <= 0x00) + goto yy459; + if (yych >= '(') + goto yy467; + yy465: + ++p; + yy466 : { return (bufsize_t)(p - start); } + yy467: + yych = *++p; + if (yybm[0 + yych] & 64) { + goto yy463; + } + if (yych <= 0x00) + goto yy459; + if (yych <= '\'') + goto yy474; + goto yy467; + yy468: + yych = *++p; + yy469: + if (yybm[0 + yych] & 128) { + goto yy468; + } + if (yych <= '(') + goto yy459; + if (yych >= '*') + goto yy472; + yy470: + ++p; + yy471 : { return (bufsize_t)(p - start); } + yy472: + yych = *++p; + if (yych <= ')') { + if (yych <= 0x00) + goto yy459; + if (yych <= '(') + goto yy468; + goto yy475; + } else { + if (yych == '\\') + goto yy472; + goto yy468; + } + yy473: + yyaccept = 1; + yych = *(marker = ++p); + if (yybm[0 + yych] & 16) { + goto yy457; + } + if (yych <= 0x00) + goto yy461; + if (yych <= '"') + goto yy460; + goto yy462; + yy474: + yyaccept = 2; + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy463; + } + if (yych <= 0x00) + goto yy466; + if (yych <= '\'') + goto yy465; + goto yy467; + yy475: + yyaccept = 3; + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy468; + } + if (yych <= '(') + goto yy471; + if (yych <= ')') + goto yy470; + goto yy472; + } +} + +// Match space characters, including newlines. +bufsize_t _scan_spacechars(const unsigned char *p) { + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy477; + } + ++p; + { return 0; } + yy477: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy477; + } + { return (bufsize_t)(p - start); } + } +} + +// Match ATX heading start. +bufsize_t _scan_atx_heading_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, 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 = *p; + if (yych == '#') + goto yy480; + ++p; + yy479 : { return 0; } + yy480: + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy481; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy479; + if (yych <= '\n') + goto yy483; + goto yy479; + } else { + if (yych <= '\r') + goto yy483; + if (yych == '#') + goto yy484; + goto yy479; + } + yy481: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy481; + } + yy482 : { return (bufsize_t)(p - start); } + yy483: + ++p; + goto yy482; + yy484: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy481; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy485; + if (yych <= '\n') + goto yy483; + } else { + if (yych <= '\r') + goto yy483; + if (yych == '#') + goto yy486; + } + yy485: + p = marker; + goto yy479; + yy486: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy481; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy485; + if (yych <= '\n') + goto yy483; + goto yy485; + } else { + if (yych <= '\r') + goto yy483; + if (yych != '#') + goto yy485; + } + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy481; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy485; + if (yych <= '\n') + goto yy483; + goto yy485; + } else { + if (yych <= '\r') + goto yy483; + if (yych != '#') + goto yy485; + } + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy481; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy485; + if (yych <= '\n') + goto yy483; + goto yy485; + } else { + if (yych <= '\r') + goto yy483; + if (yych != '#') + goto yy485; + } + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy481; + } + if (yych <= 0x08) + goto yy485; + if (yych <= '\n') + goto yy483; + if (yych == '\r') + goto yy483; + goto yy485; + } +} + +// 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, 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 == '-') + goto yy489; + if (yych == '=') + goto yy490; + ++p; + yy488 : { return 0; } + yy489: + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy495; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy488; + if (yych <= '\n') + goto yy492; + goto yy488; + } else { + if (yych <= '\r') + goto yy492; + if (yych == ' ') + goto yy492; + goto yy488; + } + yy490: + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy499; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy488; + if (yych <= '\n') + goto yy497; + goto yy488; + } else { + if (yych <= '\r') + goto yy497; + if (yych == ' ') + goto yy497; + goto yy488; + } + yy491: + yych = *++p; + yy492: + if (yybm[0 + yych] & 32) { + goto yy491; + } + if (yych <= 0x08) + goto yy493; + if (yych <= '\n') + goto yy494; + if (yych == '\r') + goto yy494; + yy493: + p = marker; + goto yy488; + yy494: + ++p; + { return 2; } + yy495: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy491; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy493; + if (yych <= '\n') + goto yy494; + goto yy493; + } else { + if (yych <= '\r') + goto yy494; + if (yych == '-') + goto yy495; + goto yy493; + } + yy496: + yych = *++p; + yy497: + if (yych <= '\f') { + if (yych <= 0x08) + goto yy493; + if (yych <= '\t') + goto yy496; + if (yych >= '\v') + goto yy493; + } else { + if (yych <= '\r') + goto yy498; + if (yych == ' ') + goto yy496; + goto yy493; + } + yy498: + ++p; + { return 1; } + yy499: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy499; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy493; + if (yych <= '\t') + goto yy496; + if (yych <= '\n') + goto yy498; + goto yy493; + } else { + if (yych <= '\r') + goto yy498; + if (yych == ' ') + goto yy496; + goto yy493; + } + } +} + +// Scan an opening code fence. +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, 192, 192, 192, 192, 192, 192, 192, 192, 192, 0, 192, 192, 0, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 144, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 224, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, + }; + yych = *p; + if (yych == '`') + goto yy502; + if (yych == '~') + goto yy503; + ++p; + yy501 : { return 0; } + yy502: + yych = *(marker = ++p); + if (yych == '`') + goto yy504; + goto yy501; + yy503: + yych = *(marker = ++p); + if (yych == '~') + goto yy506; + goto yy501; + yy504: + yych = *++p; + if (yybm[0 + yych] & 16) { + goto yy507; + } + yy505: + p = marker; + goto yy501; + yy506: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy508; + } + goto yy505; + yy507: + yych = *++p; + if (yybm[0 + yych] & 16) { + goto yy507; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy505; + if (yych <= '\t') { + marker = p; + goto yy509; + } + marker = p; + goto yy510; + } else { + if (yych == '\r') { + marker = p; + goto yy510; + } + marker = p; + goto yy509; + } + yy508: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy508; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy505; + if (yych <= '\t') { + marker = p; + goto yy511; + } + marker = p; + goto yy512; + } else { + if (yych == '\r') { + marker = p; + goto yy512; + } + marker = p; + goto yy511; + } + yy509: + yych = *++p; + if (yybm[0 + yych] & 64) { + goto yy509; + } + if (yych <= 0x00) + goto yy505; + if (yych >= 0x0E) + goto yy505; + yy510: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + yy511: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy511; + } + if (yych <= 0x00) + goto yy505; + yy512: + ++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) { + 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, 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, 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, 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, + }; + yych = *p; + if (yych == '`') + goto yy515; + if (yych == '~') + goto yy516; + ++p; + yy514 : { return 0; } + yy515: + yych = *(marker = ++p); + if (yych == '`') + goto yy517; + goto yy514; + yy516: + yych = *(marker = ++p); + if (yych == '~') + goto yy519; + goto yy514; + yy517: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy520; + } + yy518: + p = marker; + goto yy514; + yy519: + yych = *++p; + if (yybm[0 + yych] & 64) { + goto yy521; + } + goto yy518; + yy520: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy520; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy518; + if (yych <= '\t') { + marker = p; + goto yy522; + } + if (yych <= '\n') { + marker = p; + goto yy523; + } + goto yy518; + } else { + if (yych <= '\r') { + marker = p; + goto yy523; + } + if (yych == ' ') { + marker = p; + goto yy522; + } + goto yy518; + } + yy521: + yych = *++p; + if (yybm[0 + yych] & 64) { + goto yy521; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy518; + if (yych <= '\t') { + marker = p; + goto yy524; + } + if (yych <= '\n') { + marker = p; + goto yy525; + } + goto yy518; + } else { + if (yych <= '\r') { + marker = p; + goto yy525; + } + if (yych == ' ') { + marker = p; + goto yy524; + } + goto yy518; + } + yy522: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy522; + } + if (yych <= 0x08) + goto yy518; + if (yych <= '\n') + goto yy523; + if (yych != '\r') + goto yy518; + yy523: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + yy524: + yych = *++p; + if (yych <= '\f') { + if (yych <= 0x08) + goto yy518; + if (yych <= '\t') + goto yy524; + if (yych >= '\v') + goto yy518; + } else { + if (yych <= '\r') + goto yy525; + if (yych == ' ') + goto yy524; + goto yy518; + } + yy525: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + } +} + +// 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 = *p; + if (yych <= 'V') { + if (yych <= 'F') { + if (yych == 'D') + goto yy528; + if (yych >= 'F') + goto yy529; + } else { + if (yych == 'J') + goto yy530; + if (yych >= 'V') + goto yy531; + } + } else { + if (yych <= 'f') { + if (yych == 'd') + goto yy528; + if (yych >= 'f') + goto yy529; + } else { + if (yych <= 'j') { + if (yych >= 'j') + goto yy530; + } else { + if (yych == 'v') + goto yy531; + } + } + } + ++p; + yy527 : { return 0; } + yy528: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'A') + goto yy532; + if (yych == 'a') + goto yy532; + goto yy527; + yy529: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'I') + goto yy534; + if (yych == 'i') + goto yy534; + goto yy527; + yy530: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'A') + goto yy535; + if (yych == 'a') + goto yy535; + goto yy527; + yy531: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'B') + goto yy536; + if (yych == 'b') + goto yy536; + goto yy527; + yy532: + yych = *++p; + if (yych == 'T') + goto yy537; + if (yych == 't') + goto yy537; + yy533: + p = marker; + if (yyaccept == 0) { + goto yy527; + } else { + goto yy545; + } + yy534: + yych = *++p; + if (yych == 'L') + goto yy538; + if (yych == 'l') + goto yy538; + goto yy533; + yy535: + yych = *++p; + if (yych == 'V') + goto yy539; + if (yych == 'v') + goto yy539; + goto yy533; + yy536: + yych = *++p; + if (yych == 'S') + goto yy540; + if (yych == 's') + goto yy540; + goto yy533; + yy537: + yych = *++p; + if (yych == 'A') + goto yy541; + if (yych == 'a') + goto yy541; + goto yy533; + yy538: + yych = *++p; + if (yych == 'E') + goto yy542; + if (yych == 'e') + goto yy542; + goto yy533; + yy539: + yych = *++p; + if (yych == 'A') + goto yy536; + if (yych == 'a') + goto yy536; + goto yy533; + yy540: + yych = *++p; + if (yych == 'C') + goto yy543; + if (yych == 'c') + goto yy543; + goto yy533; + yy541: + yych = *++p; + if (yych == ':') + goto yy544; + goto yy533; + yy542: + yych = *++p; + if (yych == ':') + goto yy546; + goto yy533; + yy543: + yych = *++p; + if (yych == 'R') + goto yy547; + if (yych == 'r') + goto yy547; + goto yy533; + yy544: + yyaccept = 1; + yych = *(marker = ++p); + if (yych == 'I') + goto yy548; + if (yych == 'i') + goto yy548; + yy545 : { return (bufsize_t)(p - start); } + yy546: + ++p; + goto yy545; + yy547: + yych = *++p; + if (yych == 'I') + goto yy549; + if (yych == 'i') + goto yy549; + goto yy533; + yy548: + yych = *++p; + if (yych == 'M') + goto yy550; + if (yych == 'm') + goto yy550; + goto yy533; + yy549: + yych = *++p; + if (yych == 'P') + goto yy551; + if (yych == 'p') + goto yy551; + goto yy533; + yy550: + yych = *++p; + if (yych == 'A') + goto yy552; + if (yych == 'a') + goto yy552; + goto yy533; + yy551: + yych = *++p; + if (yych == 'T') + goto yy542; + if (yych == 't') + goto yy542; + goto yy533; + yy552: + yych = *++p; + if (yych == 'G') + goto yy553; + if (yych != 'g') + goto yy533; + yy553: + yych = *++p; + if (yych == 'E') + goto yy554; + if (yych != 'e') + goto yy533; + yy554: + yych = *++p; + if (yych != '/') + goto yy533; + yych = *++p; + if (yych <= 'W') { + if (yych <= 'J') { + if (yych == 'G') + goto yy555; + if (yych <= 'I') + goto yy533; + goto yy556; + } else { + if (yych == 'P') + goto yy557; + if (yych <= 'V') + goto yy533; + goto yy558; + } + } else { + if (yych <= 'j') { + if (yych == 'g') + goto yy555; + if (yych <= 'i') + goto yy533; + goto yy556; + } else { + if (yych <= 'p') { + if (yych <= 'o') + goto yy533; + goto yy557; + } else { + if (yych == 'w') + goto yy558; + goto yy533; + } + } + } + yy555: + yych = *++p; + if (yych == 'I') + goto yy559; + if (yych == 'i') + goto yy559; + goto yy533; + yy556: + yych = *++p; + if (yych == 'P') + goto yy560; + if (yych == 'p') + goto yy560; + goto yy533; + yy557: + yych = *++p; + if (yych == 'N') + goto yy561; + if (yych == 'n') + goto yy561; + goto yy533; + yy558: + yych = *++p; + if (yych == 'E') + goto yy562; + if (yych == 'e') + goto yy562; + goto yy533; + yy559: + yych = *++p; + if (yych == 'F') + goto yy563; + if (yych == 'f') + goto yy563; + goto yy533; + yy560: + yych = *++p; + if (yych == 'E') + goto yy561; + if (yych != 'e') + goto yy533; + yy561: + yych = *++p; + if (yych == 'G') + goto yy563; + if (yych == 'g') + goto yy563; + goto yy533; + yy562: + yych = *++p; + if (yych == 'B') + goto yy564; + if (yych == 'b') + goto yy564; + goto yy533; + yy563: + ++p; + { return 0; } + yy564: + yych = *++p; + if (yych == 'P') + goto yy563; + if (yych == 'p') + goto yy563; + goto yy533; + } +} diff --git a/cmark/src/scanners.h b/cmark/src/scanners.h new file mode 100644 index 0000000000..27f927342a --- /dev/null +++ b/cmark/src/scanners.h @@ -0,0 +1,59 @@ +#include "cmark.h" +#include "chunk.h" + +#ifdef __cplusplus +extern "C" { +#endif + +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_comment(const unsigned char *p); +bufsize_t _scan_html_pi(const unsigned char *p); +bufsize_t _scan_html_declaration(const unsigned char *p); +bufsize_t _scan_html_cdata(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_title(const unsigned char *p); +bufsize_t _scan_spacechars(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_open_code_fence(const unsigned char *p); +bufsize_t _scan_close_code_fence(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_comment(c, n) _scan_at(&_scan_html_comment, c, n) +#define scan_html_pi(c, n) _scan_at(&_scan_html_pi, c, n) +#define scan_html_declaration(c, n) _scan_at(&_scan_html_declaration, c, n) +#define scan_html_cdata(c, n) _scan_at(&_scan_html_cdata, 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_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) +#define scan_setext_heading_line(c, n) \ + _scan_at(&_scan_setext_heading_line, 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_dangerous_url(c, n) _scan_at(&_scan_dangerous_url, c, n) + +#ifdef __cplusplus +} +#endif diff --git a/cmark/src/scanners.re b/cmark/src/scanners.re new file mode 100644 index 0000000000..16238b7745 --- /dev/null +++ b/cmark/src/scanners.re @@ -0,0 +1,330 @@ +#include <stdlib.h> +#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; + + 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; +} + +/*!re2c + re2c:define:YYCTYPE = "unsigned char"; + re2c:define:YYCURSOR = p; + re2c:define:YYMARKER = marker; + re2c:define:YYCTXMARKER = marker; + re2c:yyfill:enable = 0; + + spacechar = [ \t\v\f\r\n]; + + reg_char = [^\\()\x00-\x20]; + + escaped_char = [\\][!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~-]; + + 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'|'h2'|'h3'|'h4'|'h5'|'h6'|'head'|'header'|'hr'|'html'|'iframe'|'legend'|'li'|'link'|'main'|'menu'|'menuitem'|'nav'|'noframes'|'ol'|'optgroup'|'option'|'p'|'param'|'section'|'search'|'title'|'summary'|'table'|'tbody'|'td'|'tfoot'|'th'|'thead'|'title'|'tr'|'track'|'ul'; + + attributename = [a-zA-Z_:][a-zA-Z0-9:._-]*; + + unquotedvalue = [^ \t\r\n\v\f"'=<>`\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-] | "--" [^\x00>])* "-->"; + + processinginstruction = ([^?>\x00]+ | [?][^>\x00] | [>])+; + + declaration = [A-Za-z]+ [^>\x00]*; + + cdata = "CDATA[" ([^\]\x00]+ | "]" [^\]\x00] | "]]" [^>\x00])*; + + htmltag = opentag | closetag; + + 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 = [A-Za-z][A-Za-z0-9.+-]{1,31}; +*/ + +// Try to match a scheme including colon. +bufsize_t _scan_scheme(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + scheme [:] { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// 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; +/*!re2c + scheme [:][^\x00-\x20<>]*[>] { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// 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; +/*!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 (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Try to match an HTML tag after first <, returning num of chars matched. +bufsize_t _scan_html_tag(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + htmltag { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +bufsize_t _scan_html_comment(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + htmlcomment { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +bufsize_t _scan_html_pi(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + processinginstruction { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +bufsize_t _scan_html_declaration(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + (void) marker; +/*!re2c + declaration { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +bufsize_t _scan_html_cdata(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + cdata { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// 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'|'textarea'|'style') (spacechar | [>]) { return 1; } + '<!--' { return 2; } + '<?' { return 3; } + '<!' [A-Za-z] { return 4; } + '<![CDATA[' { return 5; } + [<] [/]? blocktagname (spacechar | [/]? [>]) { return 6; } + * { return 0; } +*/ +} + +// 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; +/*!re2c + [<] (opentag | closetag) [\t\n\f ]* [\r\n] { return 7; } + * { return 0; } +*/ +} + +// 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; +/*!re2c + [^\n\x00]* [<] [/] ('script'|'pre'|'textarea'|'style') [>] { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// 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; +/*!re2c + [^\n\x00]* '-->' { 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 + [^\n\x00]* '?>' { 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 + [^\n\x00]* '>' { 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 + [^\n\x00]* ']]>' { return (bufsize_t)(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). +bufsize_t _scan_link_title(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + ["] (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. +bufsize_t _scan_spacechars(const unsigned char *p) +{ + const unsigned char *start = p; \ +/*!re2c + [ \t\v\f\r\n]+ { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Match ATX heading start. +bufsize_t _scan_atx_heading_start(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [#]{1,6} ([ \t]+|[\r\n]) { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// 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; +/*!re2c + [=]+ [ \t]* [\r\n] { return 1; } + [-]+ [ \t]* [\r\n] { return 2; } + * { return 0; } +*/ +} + +// Scan an opening code fence. +bufsize_t _scan_open_code_fence(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = 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; } +*/ +} + +// Scan a closing code fence with length at least len. +bufsize_t _scan_close_code_fence(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); } + * { 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/cmark/src/utf8.c b/cmark/src/utf8.c new file mode 100644 index 0000000000..48697c77d7 --- /dev/null +++ b/cmark/src/utf8.c @@ -0,0 +1,428 @@ +#include <stdlib.h> +#include <stdint.h> +#include <assert.h> + +#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, bufsize_t str_len) { + int length, i; + + if (!str_len) + return 0; + + length = utf8proc_utf8class[str[0]]; + + if (!length) + return -1; + + 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; + } + + 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; +} + +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 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 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 < 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); +} + +#include "case_fold.inc" + +int cf_compare(const void *v1, const void *v2) { + uint32_t entry1 = *(uint32_t *) v1; + uint32_t entry2 = *(uint32_t *) v2; + + return (int32_t) CF_CODE_POINT(entry1) - (int32_t) CF_CODE_POINT(entry2); +} + +void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, + bufsize_t len) { + int32_t c; + + while (len > 0) { + bufsize_t char_len = cmark_utf8proc_iterate(str, len, &c); + + if (char_len == 1) { + if (c >= 'A' && c <= 'Z') + c += 'a' - 'A'; + cmark_strbuf_putc(dest, c); + } else if (c >= CF_MAX) { + cmark_strbuf_put(dest, str, char_len); + } else if (char_len >= 0) { + uint32_t key = c; + uint32_t *entry = bsearch(&key, cf_table, + CF_TABLE_SIZE, sizeof(uint32_t), + cf_compare); + if (entry == NULL) { + cmark_strbuf_put(dest, str, char_len); + } else { + cmark_strbuf_put(dest, cf_repl + CF_REPL_IDX(*entry), + CF_REPL_SIZE(*entry)); + } + } 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 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 or S classes. +int cmark_utf8proc_is_punctuation_or_symbol(int32_t uc) { + if (uc < 128) { + return cmark_ispunct((char)uc); + } else { + return ( + uc > 128 && + ((uc >= 161 && uc <= 169) || (uc >= 171 && uc <= 172) || + (uc >= 174 && uc <= 177) || (uc == 180) || (uc >= 182 && uc <= 184) || + (uc == 187) || (uc == 191) || (uc == 215) || (uc == 247) || + (uc >= 706 && uc <= 709) || (uc >= 722 && uc <= 735) || + (uc >= 741 && uc <= 747) || (uc == 749) || (uc >= 751 && uc <= 767) || + (uc == 885) || (uc == 894) || (uc >= 900 && uc <= 901) || + (uc == 903) || (uc == 1014) || (uc == 1154) || + (uc >= 1370 && uc <= 1375) || (uc >= 1417 && uc <= 1418) || + (uc >= 1421 && uc <= 1423) || (uc == 1470) || (uc == 1472) || + (uc == 1475) || (uc == 1478) || (uc >= 1523 && uc <= 1524) || + (uc >= 1542 && uc <= 1551) || (uc == 1563) || + (uc >= 1565 && uc <= 1567) || (uc >= 1642 && uc <= 1645) || + (uc == 1748) || (uc == 1758) || (uc == 1769) || + (uc >= 1789 && uc <= 1790) || (uc >= 1792 && uc <= 1805) || + (uc >= 2038 && uc <= 2041) || (uc >= 2046 && uc <= 2047) || + (uc >= 2096 && uc <= 2110) || (uc == 2142) || (uc == 2184) || + (uc >= 2404 && uc <= 2405) || (uc == 2416) || + (uc >= 2546 && uc <= 2547) || (uc >= 2554 && uc <= 2555) || + (uc == 2557) || (uc == 2678) || (uc >= 2800 && uc <= 2801) || + (uc == 2928) || (uc >= 3059 && uc <= 3066) || (uc == 3191) || + (uc == 3199) || (uc == 3204) || (uc == 3407) || (uc == 3449) || + (uc == 3572) || (uc == 3647) || (uc == 3663) || + (uc >= 3674 && uc <= 3675) || (uc >= 3841 && uc <= 3863) || + (uc >= 3866 && uc <= 3871) || (uc == 3892) || (uc == 3894) || + (uc == 3896) || (uc >= 3898 && uc <= 3901) || (uc == 3973) || + (uc >= 4030 && uc <= 4037) || (uc >= 4039 && uc <= 4044) || + (uc >= 4046 && uc <= 4058) || (uc >= 4170 && uc <= 4175) || + (uc >= 4254 && uc <= 4255) || (uc == 4347) || + (uc >= 4960 && uc <= 4968) || (uc >= 5008 && uc <= 5017) || + (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 <= 6107) || (uc >= 6144 && uc <= 6154) || + (uc == 6464) || (uc >= 6468 && uc <= 6469) || + (uc >= 6622 && uc <= 6655) || (uc >= 6686 && uc <= 6687) || + (uc >= 6816 && uc <= 6822) || (uc >= 6824 && uc <= 6829) || + (uc >= 7002 && uc <= 7018) || (uc >= 7028 && uc <= 7038) || + (uc >= 7164 && uc <= 7167) || (uc >= 7227 && uc <= 7231) || + (uc >= 7294 && uc <= 7295) || (uc >= 7360 && uc <= 7367) || + (uc == 7379) || (uc == 8125) || (uc >= 8127 && uc <= 8129) || + (uc >= 8141 && uc <= 8143) || (uc >= 8157 && uc <= 8159) || + (uc >= 8173 && uc <= 8175) || (uc >= 8189 && uc <= 8190) || + (uc >= 8208 && uc <= 8231) || (uc >= 8240 && uc <= 8286) || + (uc >= 8314 && uc <= 8318) || (uc >= 8330 && uc <= 8334) || + (uc >= 8352 && uc <= 8384) || (uc >= 8448 && uc <= 8449) || + (uc >= 8451 && uc <= 8454) || (uc >= 8456 && uc <= 8457) || + (uc == 8468) || (uc >= 8470 && uc <= 8472) || + (uc >= 8478 && uc <= 8483) || (uc == 8485) || (uc == 8487) || + (uc == 8489) || (uc == 8494) || (uc >= 8506 && uc <= 8507) || + (uc >= 8512 && uc <= 8516) || (uc >= 8522 && uc <= 8525) || + (uc == 8527) || (uc >= 8586 && uc <= 8587) || + (uc >= 8592 && uc <= 9254) || (uc >= 9280 && uc <= 9290) || + (uc >= 9372 && uc <= 9449) || (uc >= 9472 && uc <= 10101) || + (uc >= 10132 && uc <= 11123) || (uc >= 11126 && uc <= 11157) || + (uc >= 11159 && uc <= 11263) || (uc >= 11493 && uc <= 11498) || + (uc >= 11513 && uc <= 11516) || (uc >= 11518 && uc <= 11519) || + (uc == 11632) || (uc >= 11776 && uc <= 11822) || + (uc >= 11824 && uc <= 11869) || (uc >= 11904 && uc <= 11929) || + (uc >= 11931 && uc <= 12019) || (uc >= 12032 && uc <= 12245) || + (uc >= 12272 && uc <= 12283) || (uc >= 12289 && uc <= 12292) || + (uc >= 12296 && uc <= 12320) || (uc == 12336) || + (uc >= 12342 && uc <= 12343) || (uc >= 12349 && uc <= 12351) || + (uc >= 12443 && uc <= 12444) || (uc == 12448) || (uc == 12539) || + (uc >= 12688 && uc <= 12689) || (uc >= 12694 && uc <= 12703) || + (uc >= 12736 && uc <= 12771) || (uc >= 12800 && uc <= 12830) || + (uc >= 12842 && uc <= 12871) || (uc == 12880) || + (uc >= 12896 && uc <= 12927) || (uc >= 12938 && uc <= 12976) || + (uc >= 12992 && uc <= 13311) || (uc >= 19904 && uc <= 19967) || + (uc >= 42128 && uc <= 42182) || (uc >= 42238 && uc <= 42239) || + (uc >= 42509 && uc <= 42511) || (uc == 42611) || (uc == 42622) || + (uc >= 42738 && uc <= 42743) || (uc >= 42752 && uc <= 42774) || + (uc >= 42784 && uc <= 42785) || (uc >= 42889 && uc <= 42890) || + (uc >= 43048 && uc <= 43051) || (uc >= 43062 && uc <= 43065) || + (uc >= 43124 && uc <= 43127) || (uc >= 43214 && uc <= 43215) || + (uc >= 43256 && uc <= 43258) || (uc == 43260) || + (uc >= 43310 && uc <= 43311) || (uc == 43359) || + (uc >= 43457 && uc <= 43469) || (uc >= 43486 && uc <= 43487) || + (uc >= 43612 && uc <= 43615) || (uc >= 43639 && uc <= 43641) || + (uc >= 43742 && uc <= 43743) || (uc >= 43760 && uc <= 43761) || + (uc == 43867) || (uc >= 43882 && uc <= 43883) || (uc == 44011) || + (uc == 64297) || (uc >= 64434 && uc <= 64450) || + (uc >= 64830 && uc <= 64847) || (uc == 64975) || + (uc >= 65020 && uc <= 65023) || (uc >= 65040 && uc <= 65049) || + (uc >= 65072 && uc <= 65106) || (uc >= 65108 && uc <= 65126) || + (uc >= 65128 && uc <= 65131) || (uc >= 65281 && uc <= 65295) || + (uc >= 65306 && uc <= 65312) || (uc >= 65339 && uc <= 65344) || + (uc >= 65371 && uc <= 65381) || (uc >= 65504 && uc <= 65510) || + (uc >= 65512 && uc <= 65518) || (uc >= 65532 && uc <= 65533) || + (uc >= 65792 && uc <= 65794) || (uc >= 65847 && uc <= 65855) || + (uc >= 65913 && uc <= 65929) || (uc >= 65932 && uc <= 65934) || + (uc >= 65936 && uc <= 65948) || (uc == 65952) || + (uc >= 66000 && uc <= 66044) || (uc == 66463) || (uc == 66512) || + (uc == 66927) || (uc == 67671) || (uc >= 67703 && uc <= 67704) || + (uc == 67871) || (uc == 67903) || (uc >= 68176 && uc <= 68184) || + (uc == 68223) || (uc == 68296) || (uc >= 68336 && uc <= 68342) || + (uc >= 68409 && uc <= 68415) || (uc >= 68505 && uc <= 68508) || + (uc == 69293) || (uc >= 69461 && uc <= 69465) || + (uc >= 69510 && uc <= 69513) || (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 == 70107) || + (uc >= 70109 && uc <= 70111) || (uc >= 70200 && uc <= 70205) || + (uc == 70313) || (uc >= 70731 && uc <= 70735) || + (uc >= 70746 && uc <= 70747) || (uc == 70749) || (uc == 70854) || + (uc >= 71105 && uc <= 71127) || (uc >= 71233 && uc <= 71235) || + (uc >= 71264 && uc <= 71276) || (uc == 71353) || + (uc >= 71484 && uc <= 71487) || (uc == 71739) || + (uc >= 72004 && uc <= 72006) || (uc == 72162) || + (uc >= 72255 && uc <= 72262) || (uc >= 72346 && uc <= 72348) || + (uc >= 72350 && uc <= 72354) || (uc >= 72448 && uc <= 72457) || + (uc >= 72769 && uc <= 72773) || (uc >= 72816 && uc <= 72817) || + (uc >= 73463 && uc <= 73464) || (uc >= 73539 && uc <= 73551) || + (uc >= 73685 && uc <= 73713) || (uc == 73727) || + (uc >= 74864 && uc <= 74868) || (uc >= 77809 && uc <= 77810) || + (uc >= 92782 && uc <= 92783) || (uc == 92917) || + (uc >= 92983 && uc <= 92991) || (uc >= 92996 && uc <= 92997) || + (uc >= 93847 && uc <= 93850) || (uc == 94178) || (uc == 113820) || + (uc == 113823) || (uc >= 118608 && uc <= 118723) || + (uc >= 118784 && uc <= 119029) || (uc >= 119040 && uc <= 119078) || + (uc >= 119081 && uc <= 119140) || (uc >= 119146 && uc <= 119148) || + (uc >= 119171 && uc <= 119172) || (uc >= 119180 && uc <= 119209) || + (uc >= 119214 && uc <= 119274) || (uc >= 119296 && uc <= 119361) || + (uc == 119365) || (uc >= 119552 && uc <= 119638) || (uc == 120513) || + (uc == 120539) || (uc == 120571) || (uc == 120597) || (uc == 120629) || + (uc == 120655) || (uc == 120687) || (uc == 120713) || (uc == 120745) || + (uc == 120771) || (uc >= 120832 && uc <= 121343) || + (uc >= 121399 && uc <= 121402) || (uc >= 121453 && uc <= 121460) || + (uc >= 121462 && uc <= 121475) || (uc >= 121477 && uc <= 121483) || + (uc == 123215) || (uc == 123647) || (uc >= 125278 && uc <= 125279) || + (uc == 126124) || (uc == 126128) || (uc == 126254) || + (uc >= 126704 && uc <= 126705) || (uc >= 126976 && uc <= 127019) || + (uc >= 127024 && uc <= 127123) || (uc >= 127136 && uc <= 127150) || + (uc >= 127153 && uc <= 127167) || (uc >= 127169 && uc <= 127183) || + (uc >= 127185 && uc <= 127221) || (uc >= 127245 && uc <= 127405) || + (uc >= 127462 && uc <= 127490) || (uc >= 127504 && uc <= 127547) || + (uc >= 127552 && uc <= 127560) || (uc >= 127568 && uc <= 127569) || + (uc >= 127584 && uc <= 127589) || (uc >= 127744 && uc <= 128727) || + (uc >= 128732 && uc <= 128748) || (uc >= 128752 && uc <= 128764) || + (uc >= 128768 && uc <= 128886) || (uc >= 128891 && uc <= 128985) || + (uc >= 128992 && uc <= 129003) || (uc == 129008) || + (uc >= 129024 && uc <= 129035) || (uc >= 129040 && uc <= 129095) || + (uc >= 129104 && uc <= 129113) || (uc >= 129120 && uc <= 129159) || + (uc >= 129168 && uc <= 129197) || (uc >= 129200 && uc <= 129201) || + (uc >= 129280 && uc <= 129619) || (uc >= 129632 && uc <= 129645) || + (uc >= 129648 && uc <= 129660) || (uc >= 129664 && uc <= 129672) || + (uc >= 129680 && uc <= 129725) || (uc >= 129727 && uc <= 129733) || + (uc >= 129742 && uc <= 129755) || (uc >= 129760 && uc <= 129768) || + (uc >= 129776 && uc <= 129784) || (uc >= 129792 && uc <= 129938) || + (uc >= 129940 && uc <= 129994))); + } +} diff --git a/cmark/src/utf8.h b/cmark/src/utf8.h new file mode 100644 index 0000000000..4b84c19c8d --- /dev/null +++ b/cmark/src/utf8.h @@ -0,0 +1,24 @@ +#ifndef CMARK_UTF8_H +#define CMARK_UTF8_H + +#include <stdint.h> +#include "buffer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +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_or_symbol(int32_t uc); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/src/xml.c b/cmark/src/xml.c new file mode 100644 index 0000000000..2ca2de82ce --- /dev/null +++ b/cmark/src/xml.c @@ -0,0 +1,229 @@ +#include <assert.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "cmark.h" +#include "node.h" +#include "buffer.h" + +#define BUFFER_SIZE 100 +#define MAX_INDENT 40 + +// Functions to convert cmark_nodes to XML strings. + +// C0 control characters, U+FFFE and U+FFF aren't allowed in XML. +static const char XML_ESCAPE_TABLE[256] = { + /* 0x00 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, + /* 0x10 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + /* 0x20 */ 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0, + /* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x80 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x90 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xA0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xB0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, + /* 0xC0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xD0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xE0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xF0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +// U+FFFD Replacement Character encoded in UTF-8 +#define UTF8_REPL "\xEF\xBF\xBD" + +static const char *XML_ESCAPES[] = { + "", UTF8_REPL, """, "&", "<", ">" +}; + +static void escape_xml(cmark_strbuf *ob, const unsigned char *src, + bufsize_t size) { + bufsize_t i = 0, org, esc = 0; + + while (i < size) { + org = i; + while (i < size && (esc = XML_ESCAPE_TABLE[src[i]]) == 0) + i++; + + if (i > org) + cmark_strbuf_put(ob, src + org, i - org); + + if (i >= size) + break; + + if (esc == 9) { + // To replace U+FFFE and U+FFFF with U+FFFD, only the last byte has to + // be changed. + // We know that src[i] is 0xBE or 0xBF. + if (i >= 2 && src[i-2] == 0xEF && src[i-1] == 0xBF) { + cmark_strbuf_putc(ob, 0xBD); + } else { + cmark_strbuf_putc(ob, src[i]); + } + } else { + cmark_strbuf_puts(ob, XML_ESCAPES[esc]); + } + + i++; + } +} + +static void escape_xml_str(cmark_strbuf *dest, const unsigned char *source) { + if (source) + escape_xml(dest, source, (bufsize_t)strlen((char *)source)); +} + +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 < MAX_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); + char buffer[BUFFER_SIZE]; + + 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) { + 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); + } + + 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_BLOCK: + case CMARK_NODE_HTML_INLINE: + cmark_strbuf_puts(xml, " xml:space=\"preserve\">"); + escape_xml(xml, node->data, node->len); + cmark_strbuf_puts(xml, "</"); + cmark_strbuf_puts(xml, cmark_node_get_type_string(node)); + literal = true; + break; + case CMARK_NODE_LIST: + switch (cmark_node_get_list_type(node)) { + case CMARK_ORDERED_LIST: + cmark_strbuf_puts(xml, " type=\"ordered\""); + 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) { + cmark_strbuf_puts(xml, " delimiter=\"paren\""); + } else if (delim == CMARK_PERIOD_DELIM) { + cmark_strbuf_puts(xml, " delimiter=\"period\""); + } + break; + case CMARK_BULLET_LIST: + cmark_strbuf_puts(xml, " type=\"bullet\""); + break; + default: + break; + } + snprintf(buffer, BUFFER_SIZE, " tight=\"%s\"", + (cmark_node_get_list_tight(node) ? "true" : "false")); + cmark_strbuf_puts(xml, buffer); + break; + case CMARK_NODE_HEADING: + snprintf(buffer, BUFFER_SIZE, " level=\"%d\"", node->as.heading.level); + cmark_strbuf_puts(xml, buffer); + break; + case CMARK_NODE_CODE_BLOCK: + if (node->as.code.info) { + cmark_strbuf_puts(xml, " info=\""); + escape_xml_str(xml, node->as.code.info); + cmark_strbuf_putc(xml, '"'); + } + cmark_strbuf_puts(xml, " xml:space=\"preserve\">"); + escape_xml(xml, node->data, node->len); + cmark_strbuf_puts(xml, "</"); + 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_str(xml, node->as.custom.on_enter); + cmark_strbuf_putc(xml, '"'); + cmark_strbuf_puts(xml, " on_exit=\""); + escape_xml_str(xml, node->as.custom.on_exit); + cmark_strbuf_putc(xml, '"'); + break; + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + cmark_strbuf_puts(xml, " destination=\""); + escape_xml_str(xml, node->as.link.url); + cmark_strbuf_putc(xml, '"'); + if (node->as.link.title) { + cmark_strbuf_puts(xml, " title=\""); + escape_xml_str(xml, node->as.link.title); + 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, "</"); + cmark_strbuf_puts(xml, cmark_node_get_type_string(node)); + cmark_strbuf_puts(xml, ">\n"); + } + + return 1; +} + +char *cmark_render_xml(cmark_node *root, int options) { + char *result; + cmark_strbuf xml = CMARK_BUF_INIT(root->mem); + 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, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); + cmark_strbuf_puts(state.xml, + "<!DOCTYPE document SYSTEM \"CommonMark.dtd\">\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; +} |