Includes cmark markdown parser library.

41 files changed, 29278 insertions, 0 deletions

diff --git a/lib/cmark/src/CMakeLists.txt b/lib/cmark/src/CMakeLists.txt
new file mode 100644
index 0000000..48ddd01
--- /dev/null
+++ b/lib/cmark/src/CMakeLists.txt
@@ -0,0 +1,174 @@
+if(${CMAKE_VERSION} VERSION_GREATER "3.3")
+    cmake_policy(SET CMP0063 NEW)
+endif()
+
+set(LIBRARY "libcmark")
+set(STATICLIBRARY "libcmark_static")
+set(HEADERS
+  cmark.h
+  parser.h
+  buffer.h
+  node.h
+  iterator.h
+  chunk.h
+  references.h
+  utf8.h
+  scanners.h
+  inlines.h
+  houdini.h
+  cmark_ctype.h
+  render.h
+  )
+set(LIBRARY_SOURCES
+  cmark.c
+  node.c
+  iterator.c
+  blocks.c
+  inlines.c
+  scanners.c
+  scanners.re
+  utf8.c
+  buffer.c
+  references.c
+  render.c
+  man.c
+  xml.c
+  html.c
+  commonmark.c
+  latex.c
+  houdini_href_e.c
+  houdini_html_e.c
+  houdini_html_u.c
+  cmark_ctype.c
+  ${HEADERS}
+  )
+
+set(PROGRAM "cmark")
+set(PROGRAM_SOURCES main.c)
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmark_version.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h)
+
+include (GenerateExportHeader)
+
+add_executable(${PROGRAM} ${PROGRAM_SOURCES})
+
+if (CMARK_STATIC)
+  target_link_libraries(${PROGRAM} ${STATICLIBRARY})
+  # Disable the PUBLIC declarations when compiling the executable:
+  set_target_properties(${PROGRAM} PROPERTIES
+    COMPILE_FLAGS -DCMARK_STATIC_DEFINE)
+elseif (CMARK_SHARED)
+  target_link_libraries(${PROGRAM} ${LIBRARY})
+endif()
+
+# -fvisibility=hidden
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
+
+if (CMARK_SHARED)
+  add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES})
+  set_target_properties(${LIBRARY} PROPERTIES
+    MACOSX_RPATH TRUE
+    OUTPUT_NAME "cmark"
+    # Avoid name clash between PROGRAM and LIBRARY pdb files.
+    PDB_NAME cmark_dll
+    # Include minor version and patch level in soname for now.
+    SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}
+    VERSION ${PROJECT_VERSION})
+  target_include_directories(${LIBRARY} INTERFACE
+    $<INSTALL_INTERFACE:include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+
+  generate_export_header(${LIBRARY}
+    BASE_NAME ${PROJECT_NAME})
+
+  list(APPEND CMARK_INSTALL ${LIBRARY})
+endif()
+
+if (CMARK_STATIC)
+  add_library(${STATICLIBRARY} STATIC ${LIBRARY_SOURCES})
+  set_target_properties(${STATICLIBRARY} PROPERTIES
+    COMPILE_FLAGS -DCMARK_STATIC_DEFINE
+    OUTPUT_NAME "cmark$<$<BOOL:${MSVC}>:_static>"
+    POSITION_INDEPENDENT_CODE ON
+    VERSION ${PROJECT_VERSION})
+  target_include_directories(${STATICLIBRARY} INTERFACE
+    $<INSTALL_INTERFACE:include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+
+  if (NOT CMARK_SHARED)
+    generate_export_header(${STATICLIBRARY}
+      BASE_NAME ${PROJECT_NAME})
+  endif()
+
+  list(APPEND CMARK_INSTALL ${STATICLIBRARY})
+endif()
+
+if (MSVC)
+  set_property(TARGET ${PROGRAM}
+    APPEND PROPERTY LINK_FLAGS /INCREMENTAL:NO)
+endif(MSVC)
+
+if(NOT MSVC OR CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
+  set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON)
+  include(InstallRequiredSystemLibraries)
+endif()
+
+set(libdir lib${LIB_SUFFIX})
+
+install(TARGETS ${PROGRAM} ${CMARK_INSTALL}
+  EXPORT cmark
+  RUNTIME DESTINATION bin
+  LIBRARY DESTINATION ${libdir}
+  ARCHIVE DESTINATION ${libdir}
+  )
+
+if(CMARK_SHARED OR CMARK_STATIC)
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark.pc.in
+    ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc @ONLY)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc
+    DESTINATION ${libdir}/pkgconfig)
+
+  install(FILES
+    cmark.h
+    ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h
+    ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h
+    DESTINATION include
+    )
+
+  install(EXPORT cmark DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+
+  set(CMARK_TARGETS_FILE ${CMAKE_CURRENT_BINARY_DIR}/cmarkTargets.cmake)
+  configure_file(cmarkConfig.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/cmarkConfig.cmake)
+  export(TARGETS ${CMARK_INSTALL} FILE ${CMARK_TARGETS_FILE})
+endif()
+
+# Feature tests
+include(CheckIncludeFile)
+include(CheckCSourceCompiles)
+CHECK_INCLUDE_FILE(stdbool.h HAVE_STDBOOL_H)
+CHECK_C_SOURCE_COMPILES(
+  "int main() { __builtin_expect(0,0); return 0; }"
+  HAVE___BUILTIN_EXPECT)
+CHECK_C_SOURCE_COMPILES("
+  int f(void) __attribute__ (());
+  int main() { return 0; }
+" HAVE___ATTRIBUTE__)
+
+CONFIGURE_FILE(
+  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/config.h)
+
+if(CMARK_LIB_FUZZER)
+  add_executable(cmark-fuzz ../test/cmark-fuzz.c ${LIBRARY_SOURCES})
+  target_link_libraries(cmark-fuzz "${CMAKE_LIB_FUZZER_PATH}")
+
+  # cmark is written in C but the libFuzzer runtime is written in C++ which
+  # needs to link against the C++ runtime.
+  set_target_properties(cmark-fuzz PROPERTIES
+    LINKER_LANGUAGE CXX)
+endif()
diff --git a/lib/cmark/src/blocks.c b/lib/cmark/src/blocks.c
new file mode 100644
index 0000000..a979b3a
--- /dev/null
+++ b/lib/cmark/src/blocks.c
@@ -0,0 +1,1300 @@
+/**
+ * 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 <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+
+#include "cmark_ctype.h"
+#include "config.h"
+#include "parser.h"
+#include "cmark.h"
+#include "node.h"
+#include "references.h"
+#include "utf8.h"
+#include "scanners.h"
+#include "inlines.h"
+#include "houdini.h"
+#include "buffer.h"
+#include "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 CMARK_INLINE cmark_node_type S_type(const cmark_node *node) {
+  return (cmark_node_type)node->type;
+}
+
+static void S_set_last_line_blank(cmark_node *node, bool is_blank) {
+  if (is_blank)
+    node->flags |= CMARK_NODE__LAST_LINE_BLANK;
+  else
+    node->flags &= ~CMARK_NODE__LAST_LINE_BLANK;
+}
+
+static void S_set_last_line_checked(cmark_node *node) {
+  node->flags |= CMARK_NODE__LAST_LINE_CHECKED;
+}
+
+static CMARK_INLINE bool S_is_line_end_char(char c) {
+  return (c == '\n' || c == '\r');
+}
+
+static CMARK_INLINE bool S_is_space_or_tab(char c) {
+  return (c == ' ' || c == '\t');
+}
+
+static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
+                          size_t len, bool eof);
+
+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(int options, cmark_mem *mem) {
+  cmark_parser *parser = (cmark_parser *)mem->calloc(1, sizeof(cmark_parser));
+  parser->mem = mem;
+
+  cmark_node *document = make_document(mem);
+
+  cmark_strbuf_init(mem, &parser->curline, 256);
+  cmark_strbuf_init(mem, &parser->linebuf, 0);
+  cmark_strbuf_init(mem, &parser->content, 0);
+
+  parser->refmap = cmark_reference_map_new(mem);
+  parser->root = document;
+  parser->current = document;
+  parser->line_number = 0;
+  parser->offset = 0;
+  parser->column = 0;
+  parser->first_nonspace = 0;
+  parser->first_nonspace_column = 0;
+  parser->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(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 CMARK_INLINE bool can_contain(cmark_node_type parent_type,
+                                     cmark_node_type child_type) {
+  return (parent_type == CMARK_NODE_DOCUMENT ||
+          parent_type == CMARK_NODE_BLOCK_QUOTE ||
+          parent_type == CMARK_NODE_ITEM ||
+          (parent_type == CMARK_NODE_LIST && child_type == CMARK_NODE_ITEM));
+}
+
+static CMARK_INLINE bool accepts_lines(cmark_node_type block_type) {
+  return (block_type == CMARK_NODE_PARAGRAPH ||
+          block_type == CMARK_NODE_HEADING ||
+          block_type == CMARK_NODE_CODE_BLOCK);
+}
+
+static CMARK_INLINE bool contains_inlines(cmark_node_type block_type) {
+  return (block_type == CMARK_NODE_PARAGRAPH ||
+          block_type == CMARK_NODE_HEADING);
+}
+
+static void add_line(cmark_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);
+  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};
+
+  // 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_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)->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 &&
+                              (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) &&
+               (matched = 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>, </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/lib/cmark/src/buffer.c b/lib/cmark/src/buffer.c
new file mode 100644
index 0000000..d946493
--- /dev/null
+++ b/lib/cmark/src/buffer.c
@@ -0,0 +1,278 @@
+#include <stdarg.h>
+#include <string.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <limits.h>
+
+#include "config.h"
+#include "cmark_ctype.h"
+#include "buffer.h"
+
+/* Used as default value for cmark_strbuf->ptr so that people can always
+ * assume ptr is non-NULL and zero terminated even for new cmark_strbufs.
+ */
+unsigned char cmark_strbuf__initbuf[1];
+
+#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 CMARK_INLINE void S_strbuf_grow_by(cmark_strbuf *buf, bufsize_t add) {
+  cmark_strbuf_grow(buf, buf->size + add);
+}
+
+void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) {
+  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;
+}
+
+bufsize_t cmark_strbuf_len(const cmark_strbuf *buf) { return buf->size; }
+
+void cmark_strbuf_free(cmark_strbuf *buf) {
+  if (!buf)
+    return;
+
+  if (buf->ptr != cmark_strbuf__initbuf)
+    buf->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_sets(cmark_strbuf *buf, const char *string) {
+  cmark_strbuf_set(buf, (const unsigned char *)string,
+                   string ? strlen(string) : 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, strlen(string));
+}
+
+void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize,
+                            const cmark_strbuf *buf) {
+  bufsize_t copylen;
+
+  assert(buf);
+  if (!data || datasize <= 0)
+    return;
+
+  data[0] = '\0';
+
+  if (buf->size == 0 || buf->asize <= 0)
+    return;
+
+  copylen = buf->size;
+  if (copylen > datasize - 1)
+    copylen = datasize - 1;
+  memmove(data, buf->ptr, copylen);
+  data[copylen] = '\0';
+}
+
+void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) {
+  cmark_strbuf t = *buf_a;
+  *buf_a = *buf_b;
+  *buf_b = t;
+}
+
+unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) {
+  unsigned char *data = buf->ptr;
+
+  if (buf->asize == 0) {
+    /* return an empty string */
+    return (unsigned char *)buf->mem->calloc(1, 1);
+  }
+
+  cmark_strbuf_init(buf->mem, buf, 0);
+  return data;
+}
+
+int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b) {
+  int result = memcmp(a->ptr, b->ptr, MIN(a->size, b->size));
+  return (result != 0) ? result
+                       : (a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0;
+}
+
+bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos) {
+  if (pos >= buf->size)
+    return -1;
+  if (pos < 0)
+    pos = 0;
+
+  const unsigned char *p =
+      (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos);
+  if (!p)
+    return -1;
+
+  return (bufsize_t)(p - (const unsigned char *)buf->ptr);
+}
+
+bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos) {
+  if (pos < 0 || buf->size == 0)
+    return -1;
+  if (pos >= buf->size)
+    pos = buf->size - 1;
+
+  bufsize_t i;
+  for (i = pos; i >= 0; i--) {
+    if (buf->ptr[i] == (unsigned char)c)
+      return i;
+  }
+
+  return -1;
+}
+
+void cmark_strbuf_truncate(cmark_strbuf *buf, 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.
+extern void cmark_strbuf_unescape(cmark_strbuf *buf) {
+  bufsize_t r, w;
+
+  for (r = 0, w = 0; r < buf->size; ++r) {
+    if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1]))
+      r++;
+
+    buf->ptr[w++] = buf->ptr[r];
+  }
+
+  cmark_strbuf_truncate(buf, w);
+}
diff --git a/lib/cmark/src/buffer.h b/lib/cmark/src/buffer.h
new file mode 100644
index 0000000..55b552f
--- /dev/null
+++ b/lib/cmark/src/buffer.h
@@ -0,0 +1,84 @@
+#ifndef CMARK_BUFFER_H
+#define CMARK_BUFFER_H
+
+#include <stddef.h>
+#include <stdarg.h>
+#include <string.h>
+#include <limits.h>
+#include <stdint.h>
+#include "config.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);
+void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b);
+
+bufsize_t cmark_strbuf_len(const cmark_strbuf *buf);
+
+int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b);
+
+unsigned char *cmark_strbuf_detach(cmark_strbuf *buf);
+void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize,
+                            const cmark_strbuf *buf);
+
+/*
+static CMARK_INLINE const char *cmark_strbuf_cstr(const cmark_strbuf *buf) {
+ return (char *)buf->ptr;
+}
+*/
+
+#define cmark_strbuf_at(buf, n) ((buf)->ptr[n])
+
+void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data,
+                      bufsize_t len);
+void cmark_strbuf_sets(cmark_strbuf *buf, const char *string);
+void cmark_strbuf_putc(cmark_strbuf *buf, int c);
+void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
+                      bufsize_t len);
+void cmark_strbuf_puts(cmark_strbuf *buf, const char *string);
+void cmark_strbuf_clear(cmark_strbuf *buf);
+
+bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos);
+bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos);
+void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n);
+void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len);
+void cmark_strbuf_rtrim(cmark_strbuf *buf);
+void cmark_strbuf_trim(cmark_strbuf *buf);
+void cmark_strbuf_normalize_whitespace(cmark_strbuf *s);
+void cmark_strbuf_unescape(cmark_strbuf *s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/cmark/src/case_fold_switch.inc b/lib/cmark/src/case_fold_switch.inc
new file mode 100644
index 0000000..fc1b6d8
--- /dev/null
+++ b/lib/cmark/src/case_fold_switch.inc
@@ -0,0 +1,4594 @@
+    switch (c) {
+      case 0x0041:
+        bufpush(0x0061);
+        break;
+      case 0x0042:
+        bufpush(0x0062);
+        break;
+      case 0x0043:
+        bufpush(0x0063);
+        break;
+      case 0x0044:
+        bufpush(0x0064);
+        break;
+      case 0x0045:
+        bufpush(0x0065);
+        break;
+      case 0x0046:
+        bufpush(0x0066);
+        break;
+      case 0x0047:
+        bufpush(0x0067);
+        break;
+      case 0x0048:
+        bufpush(0x0068);
+        break;
+      case 0x0049:
+        bufpush(0x0069);
+        break;
+      case 0x004A:
+        bufpush(0x006A);
+        break;
+      case 0x004B:
+        bufpush(0x006B);
+        break;
+      case 0x004C:
+        bufpush(0x006C);
+        break;
+      case 0x004D:
+        bufpush(0x006D);
+        break;
+      case 0x004E:
+        bufpush(0x006E);
+        break;
+      case 0x004F:
+        bufpush(0x006F);
+        break;
+      case 0x0050:
+        bufpush(0x0070);
+        break;
+      case 0x0051:
+        bufpush(0x0071);
+        break;
+      case 0x0052:
+        bufpush(0x0072);
+        break;
+      case 0x0053:
+        bufpush(0x0073);
+        break;
+      case 0x0054:
+        bufpush(0x0074);
+        break;
+      case 0x0055:
+        bufpush(0x0075);
+        break;
+      case 0x0056:
+        bufpush(0x0076);
+        break;
+      case 0x0057:
+        bufpush(0x0077);
+        break;
+      case 0x0058:
+        bufpush(0x0078);
+        break;
+      case 0x0059:
+        bufpush(0x0079);
+        break;
+      case 0x005A:
+        bufpush(0x007A);
+        break;
+      case 0x00B5:
+        bufpush(0x03BC);
+        break;
+      case 0x00C0:
+        bufpush(0x00E0);
+        break;
+      case 0x00C1:
+        bufpush(0x00E1);
+        break;
+      case 0x00C2:
+        bufpush(0x00E2);
+        break;
+      case 0x00C3:
+        bufpush(0x00E3);
+        break;
+      case 0x00C4:
+        bufpush(0x00E4);
+        break;
+      case 0x00C5:
+        bufpush(0x00E5);
+        break;
+      case 0x00C6:
+        bufpush(0x00E6);
+        break;
+      case 0x00C7:
+        bufpush(0x00E7);
+        break;
+      case 0x00C8:
+        bufpush(0x00E8);
+        break;
+      case 0x00C9:
+        bufpush(0x00E9);
+        break;
+      case 0x00CA:
+        bufpush(0x00EA);
+        break;
+      case 0x00CB:
+        bufpush(0x00EB);
+        break;
+      case 0x00CC:
+        bufpush(0x00EC);
+        break;
+      case 0x00CD:
+        bufpush(0x00ED);
+        break;
+      case 0x00CE:
+        bufpush(0x00EE);
+        break;
+      case 0x00CF:
+        bufpush(0x00EF);
+        break;
+      case 0x00D0:
+        bufpush(0x00F0);
+        break;
+      case 0x00D1:
+        bufpush(0x00F1);
+        break;
+      case 0x00D2:
+        bufpush(0x00F2);
+        break;
+      case 0x00D3:
+        bufpush(0x00F3);
+        break;
+      case 0x00D4:
+        bufpush(0x00F4);
+        break;
+      case 0x00D5:
+        bufpush(0x00F5);
+        break;
+      case 0x00D6:
+        bufpush(0x00F6);
+        break;
+      case 0x00D8:
+        bufpush(0x00F8);
+        break;
+      case 0x00D9:
+        bufpush(0x00F9);
+        break;
+      case 0x00DA:
+        bufpush(0x00FA);
+        break;
+      case 0x00DB:
+        bufpush(0x00FB);
+        break;
+      case 0x00DC:
+        bufpush(0x00FC);
+        break;
+      case 0x00DD:
+        bufpush(0x00FD);
+        break;
+      case 0x00DE:
+        bufpush(0x00FE);
+        break;
+      case 0x00DF:
+        bufpush(0x0073);
+        bufpush(0x0073);
+        break;
+      case 0x0100:
+        bufpush(0x0101);
+        break;
+      case 0x0102:
+        bufpush(0x0103);
+        break;
+      case 0x0104:
+        bufpush(0x0105);
+        break;
+      case 0x0106:
+        bufpush(0x0107);
+        break;
+      case 0x0108:
+        bufpush(0x0109);
+        break;
+      case 0x010A:
+        bufpush(0x010B);
+        break;
+      case 0x010C:
+        bufpush(0x010D);
+        break;
+      case 0x010E:
+        bufpush(0x010F);
+        break;
+      case 0x0110:
+        bufpush(0x0111);
+        break;
+      case 0x0112:
+        bufpush(0x0113);
+        break;
+      case 0x0114:
+        bufpush(0x0115);
+        break;
+      case 0x0116:
+        bufpush(0x0117);
+        break;
+      case 0x0118:
+        bufpush(0x0119);
+        break;
+      case 0x011A:
+        bufpush(0x011B);
+        break;
+      case 0x011C:
+        bufpush(0x011D);
+        break;
+      case 0x011E:
+        bufpush(0x011F);
+        break;
+      case 0x0120:
+        bufpush(0x0121);
+        break;
+      case 0x0122:
+        bufpush(0x0123);
+        break;
+      case 0x0124:
+        bufpush(0x0125);
+        break;
+      case 0x0126:
+        bufpush(0x0127);
+        break;
+      case 0x0128:
+        bufpush(0x0129);
+        break;
+      case 0x012A:
+        bufpush(0x012B);
+        break;
+      case 0x012C:
+        bufpush(0x012D);
+        break;
+      case 0x012E:
+        bufpush(0x012F);
+        break;
+      case 0x0130:
+        bufpush(0x0069);
+        bufpush(0x0307);
+        break;
+      case 0x0132:
+        bufpush(0x0133);
+        break;
+      case 0x0134:
+        bufpush(0x0135);
+        break;
+      case 0x0136:
+        bufpush(0x0137);
+        break;
+      case 0x0139:
+        bufpush(0x013A);
+        break;
+      case 0x013B:
+        bufpush(0x013C);
+        break;
+      case 0x013D:
+        bufpush(0x013E);
+        break;
+      case 0x013F:
+        bufpush(0x0140);
+        break;
+      case 0x0141:
+        bufpush(0x0142);
+        break;
+      case 0x0143:
+        bufpush(0x0144);
+        break;
+      case 0x0145:
+        bufpush(0x0146);
+        break;
+      case 0x0147:
+        bufpush(0x0148);
+        break;
+      case 0x0149:
+        bufpush(0x02BC);
+        bufpush(0x006E);
+        break;
+      case 0x014A:
+        bufpush(0x014B);
+        break;
+      case 0x014C:
+        bufpush(0x014D);
+        break;
+      case 0x014E:
+        bufpush(0x014F);
+        break;
+      case 0x0150:
+        bufpush(0x0151);
+        break;
+      case 0x0152:
+        bufpush(0x0153);
+        break;
+      case 0x0154:
+        bufpush(0x0155);
+        break;
+      case 0x0156:
+        bufpush(0x0157);
+        break;
+      case 0x0158:
+        bufpush(0x0159);
+        break;
+      case 0x015A:
+        bufpush(0x015B);
+        break;
+      case 0x015C:
+        bufpush(0x015D);
+        break;
+      case 0x015E:
+        bufpush(0x015F);
+        break;
+      case 0x0160:
+        bufpush(0x0161);
+        break;
+      case 0x0162:
+        bufpush(0x0163);
+        break;
+      case 0x0164:
+        bufpush(0x0165);
+        break;
+      case 0x0166:
+        bufpush(0x0167);
+        break;
+      case 0x0168:
+        bufpush(0x0169);
+        break;
+      case 0x016A:
+        bufpush(0x016B);
+        break;
+      case 0x016C:
+        bufpush(0x016D);
+        break;
+      case 0x016E:
+        bufpush(0x016F);
+        break;
+      case 0x0170:
+        bufpush(0x0171);
+        break;
+      case 0x0172:
+        bufpush(0x0173);
+        break;
+      case 0x0174:
+        bufpush(0x0175);
+        break;
+      case 0x0176:
+        bufpush(0x0177);
+        break;
+      case 0x0178:
+        bufpush(0x00FF);
+        break;
+      case 0x0179:
+        bufpush(0x017A);
+        break;
+      case 0x017B:
+        bufpush(0x017C);
+        break;
+      case 0x017D:
+        bufpush(0x017E);
+        break;
+      case 0x017F:
+        bufpush(0x0073);
+        break;
+      case 0x0181:
+        bufpush(0x0253);
+        break;
+      case 0x0182:
+        bufpush(0x0183);
+        break;
+      case 0x0184:
+        bufpush(0x0185);
+        break;
+      case 0x0186:
+        bufpush(0x0254);
+        break;
+      case 0x0187:
+        bufpush(0x0188);
+        break;
+      case 0x0189:
+        bufpush(0x0256);
+        break;
+      case 0x018A:
+        bufpush(0x0257);
+        break;
+      case 0x018B:
+        bufpush(0x018C);
+        break;
+      case 0x018E:
+        bufpush(0x01DD);
+        break;
+      case 0x018F:
+        bufpush(0x0259);
+        break;
+      case 0x0190:
+        bufpush(0x025B);
+        break;
+      case 0x0191:
+        bufpush(0x0192);
+        break;
+      case 0x0193:
+        bufpush(0x0260);
+        break;
+      case 0x0194:
+        bufpush(0x0263);
+        break;
+      case 0x0196:
+        bufpush(0x0269);
+        break;
+      case 0x0197:
+        bufpush(0x0268);
+        break;
+      case 0x0198:
+        bufpush(0x0199);
+        break;
+      case 0x019C:
+        bufpush(0x026F);
+        break;
+      case 0x019D:
+        bufpush(0x0272);
+        break;
+      case 0x019F:
+        bufpush(0x0275);
+        break;
+      case 0x01A0:
+        bufpush(0x01A1);
+        break;
+      case 0x01A2:
+        bufpush(0x01A3);
+        break;
+      case 0x01A4:
+        bufpush(0x01A5);
+        break;
+      case 0x01A6:
+        bufpush(0x0280);
+        break;
+      case 0x01A7:
+        bufpush(0x01A8);
+        break;
+      case 0x01A9:
+        bufpush(0x0283);
+        break;
+      case 0x01AC:
+        bufpush(0x01AD);
+        break;
+      case 0x01AE:
+        bufpush(0x0288);
+        break;
+      case 0x01AF:
+        bufpush(0x01B0);
+        break;
+      case 0x01B1:
+        bufpush(0x028A);
+        break;
+      case 0x01B2:
+        bufpush(0x028B);
+        break;
+      case 0x01B3:
+        bufpush(0x01B4);
+        break;
+      case 0x01B5:
+        bufpush(0x01B6);
+        break;
+      case 0x01B7:
+        bufpush(0x0292);
+        break;
+      case 0x01B8:
+        bufpush(0x01B9);
+        break;
+      case 0x01BC:
+        bufpush(0x01BD);
+        break;
+      case 0x01C4:
+        bufpush(0x01C6);
+        break;
+      case 0x01C5:
+        bufpush(0x01C6);
+        break;
+      case 0x01C7:
+        bufpush(0x01C9);
+        break;
+      case 0x01C8:
+        bufpush(0x01C9);
+        break;
+      case 0x01CA:
+        bufpush(0x01CC);
+        break;
+      case 0x01CB:
+        bufpush(0x01CC);
+        break;
+      case 0x01CD:
+        bufpush(0x01CE);
+        break;
+      case 0x01CF:
+        bufpush(0x01D0);
+        break;
+      case 0x01D1:
+        bufpush(0x01D2);
+        break;
+      case 0x01D3:
+        bufpush(0x01D4);
+        break;
+      case 0x01D5:
+        bufpush(0x01D6);
+        break;
+      case 0x01D7:
+        bufpush(0x01D8);
+        break;
+      case 0x01D9:
+        bufpush(0x01DA);
+        break;
+      case 0x01DB:
+        bufpush(0x01DC);
+        break;
+      case 0x01DE:
+        bufpush(0x01DF);
+        break;
+      case 0x01E0:
+        bufpush(0x01E1);
+        break;
+      case 0x01E2:
+        bufpush(0x01E3);
+        break;
+      case 0x01E4:
+        bufpush(0x01E5);
+        break;
+      case 0x01E6:
+        bufpush(0x01E7);
+        break;
+      case 0x01E8:
+        bufpush(0x01E9);
+        break;
+      case 0x01EA:
+        bufpush(0x01EB);
+        break;
+      case 0x01EC:
+        bufpush(0x01ED);
+        break;
+      case 0x01EE:
+        bufpush(0x01EF);
+        break;
+      case 0x01F0:
+        bufpush(0x006A);
+        bufpush(0x030C);
+        break;
+      case 0x01F1:
+        bufpush(0x01F3);
+        break;
+      case 0x01F2:
+        bufpush(0x01F3);
+        break;
+      case 0x01F4:
+        bufpush(0x01F5);
+        break;
+      case 0x01F6:
+        bufpush(0x0195);
+        break;
+      case 0x01F7:
+        bufpush(0x01BF);
+        break;
+      case 0x01F8:
+        bufpush(0x01F9);
+        break;
+      case 0x01FA:
+        bufpush(0x01FB);
+        break;
+      case 0x01FC:
+        bufpush(0x01FD);
+        break;
+      case 0x01FE:
+        bufpush(0x01FF);
+        break;
+      case 0x0200:
+        bufpush(0x0201);
+        break;
+      case 0x0202:
+        bufpush(0x0203);
+        break;
+      case 0x0204:
+        bufpush(0x0205);
+        break;
+      case 0x0206:
+        bufpush(0x0207);
+        break;
+      case 0x0208:
+        bufpush(0x0209);
+        break;
+      case 0x020A:
+        bufpush(0x020B);
+        break;
+      case 0x020C:
+        bufpush(0x020D);
+        break;
+      case 0x020E:
+        bufpush(0x020F);
+        break;
+      case 0x0210:
+        bufpush(0x0211);
+        break;
+      case 0x0212:
+        bufpush(0x0213);
+        break;
+      case 0x0214:
+        bufpush(0x0215);
+        break;
+      case 0x0216:
+        bufpush(0x0217);
+        break;
+      case 0x0218:
+        bufpush(0x0219);
+        break;
+      case 0x021A:
+        bufpush(0x021B);
+        break;
+      case 0x021C:
+        bufpush(0x021D);
+        break;
+      case 0x021E:
+        bufpush(0x021F);
+        break;
+      case 0x0220:
+        bufpush(0x019E);
+        break;
+      case 0x0222:
+        bufpush(0x0223);
+        break;
+      case 0x0224:
+        bufpush(0x0225);
+        break;
+      case 0x0226:
+        bufpush(0x0227);
+        break;
+      case 0x0228:
+        bufpush(0x0229);
+        break;
+      case 0x022A:
+        bufpush(0x022B);
+        break;
+      case 0x022C:
+        bufpush(0x022D);
+        break;
+      case 0x022E:
+        bufpush(0x022F);
+        break;
+      case 0x0230:
+        bufpush(0x0231);
+        break;
+      case 0x0232:
+        bufpush(0x0233);
+        break;
+      case 0x023A:
+        bufpush(0x2C65);
+        break;
+      case 0x023B:
+        bufpush(0x023C);
+        break;
+      case 0x023D:
+        bufpush(0x019A);
+        break;
+      case 0x023E:
+        bufpush(0x2C66);
+        break;
+      case 0x0241:
+        bufpush(0x0242);
+        break;
+      case 0x0243:
+        bufpush(0x0180);
+        break;
+      case 0x0244:
+        bufpush(0x0289);
+        break;
+      case 0x0245:
+        bufpush(0x028C);
+        break;
+      case 0x0246:
+        bufpush(0x0247);
+        break;
+      case 0x0248:
+        bufpush(0x0249);
+        break;
+      case 0x024A:
+        bufpush(0x024B);
+        break;
+      case 0x024C:
+        bufpush(0x024D);
+        break;
+      case 0x024E:
+        bufpush(0x024F);
+        break;
+      case 0x0345:
+        bufpush(0x03B9);
+        break;
+      case 0x0370:
+        bufpush(0x0371);
+        break;
+      case 0x0372:
+        bufpush(0x0373);
+        break;
+      case 0x0376:
+        bufpush(0x0377);
+        break;
+      case 0x037F:
+        bufpush(0x03F3);
+        break;
+      case 0x0386:
+        bufpush(0x03AC);
+        break;
+      case 0x0388:
+        bufpush(0x03AD);
+        break;
+      case 0x0389:
+        bufpush(0x03AE);
+        break;
+      case 0x038A:
+        bufpush(0x03AF);
+        break;
+      case 0x038C:
+        bufpush(0x03CC);
+        break;
+      case 0x038E:
+        bufpush(0x03CD);
+        break;
+      case 0x038F:
+        bufpush(0x03CE);
+        break;
+      case 0x0390:
+        bufpush(0x03B9);
+        bufpush(0x0308);
+        bufpush(0x0301);
+        break;
+      case 0x0391:
+        bufpush(0x03B1);
+        break;
+      case 0x0392:
+        bufpush(0x03B2);
+        break;
+      case 0x0393:
+        bufpush(0x03B3);
+        break;
+      case 0x0394:
+        bufpush(0x03B4);
+        break;
+      case 0x0395:
+        bufpush(0x03B5);
+        break;
+      case 0x0396:
+        bufpush(0x03B6);
+        break;
+      case 0x0397:
+        bufpush(0x03B7);
+        break;
+      case 0x0398:
+        bufpush(0x03B8);
+        break;
+      case 0x0399:
+        bufpush(0x03B9);
+        break;
+      case 0x039A:
+        bufpush(0x03BA);
+        break;
+      case 0x039B:
+        bufpush(0x03BB);
+        break;
+      case 0x039C:
+        bufpush(0x03BC);
+        break;
+      case 0x039D:
+        bufpush(0x03BD);
+        break;
+      case 0x039E:
+        bufpush(0x03BE);
+        break;
+      case 0x039F:
+        bufpush(0x03BF);
+        break;
+      case 0x03A0:
+        bufpush(0x03C0);
+        break;
+      case 0x03A1:
+        bufpush(0x03C1);
+        break;
+      case 0x03A3:
+        bufpush(0x03C3);
+        break;
+      case 0x03A4:
+        bufpush(0x03C4);
+        break;
+      case 0x03A5:
+        bufpush(0x03C5);
+        break;
+      case 0x03A6:
+        bufpush(0x03C6);
+        break;
+      case 0x03A7:
+        bufpush(0x03C7);
+        break;
+      case 0x03A8:
+        bufpush(0x03C8);
+        break;
+      case 0x03A9:
+        bufpush(0x03C9);
+        break;
+      case 0x03AA:
+        bufpush(0x03CA);
+        break;
+      case 0x03AB:
+        bufpush(0x03CB);
+        break;
+      case 0x03B0:
+        bufpush(0x03C5);
+        bufpush(0x0308);
+        bufpush(0x0301);
+        break;
+      case 0x03C2:
+        bufpush(0x03C3);
+        break;
+      case 0x03CF:
+        bufpush(0x03D7);
+        break;
+      case 0x03D0:
+        bufpush(0x03B2);
+        break;
+      case 0x03D1:
+        bufpush(0x03B8);
+        break;
+      case 0x03D5:
+        bufpush(0x03C6);
+        break;
+      case 0x03D6:
+        bufpush(0x03C0);
+        break;
+      case 0x03D8:
+        bufpush(0x03D9);
+        break;
+      case 0x03DA:
+        bufpush(0x03DB);
+        break;
+      case 0x03DC:
+        bufpush(0x03DD);
+        break;
+      case 0x03DE:
+        bufpush(0x03DF);
+        break;
+      case 0x03E0:
+        bufpush(0x03E1);
+        break;
+      case 0x03E2:
+        bufpush(0x03E3);
+        break;
+      case 0x03E4:
+        bufpush(0x03E5);
+        break;
+      case 0x03E6:
+        bufpush(0x03E7);
+        break;
+      case 0x03E8:
+        bufpush(0x03E9);
+        break;
+      case 0x03EA:
+        bufpush(0x03EB);
+        break;
+      case 0x03EC:
+        bufpush(0x03ED);
+        break;
+      case 0x03EE:
+        bufpush(0x03EF);
+        break;
+      case 0x03F0:
+        bufpush(0x03BA);
+        break;
+      case 0x03F1:
+        bufpush(0x03C1);
+        break;
+      case 0x03F4:
+        bufpush(0x03B8);
+        break;
+      case 0x03F5:
+        bufpush(0x03B5);
+        break;
+      case 0x03F7:
+        bufpush(0x03F8);
+        break;
+      case 0x03F9:
+        bufpush(0x03F2);
+        break;
+      case 0x03FA:
+        bufpush(0x03FB);
+        break;
+      case 0x03FD:
+        bufpush(0x037B);
+        break;
+      case 0x03FE:
+        bufpush(0x037C);
+        break;
+      case 0x03FF:
+        bufpush(0x037D);
+        break;
+      case 0x0400:
+        bufpush(0x0450);
+        break;
+      case 0x0401:
+        bufpush(0x0451);
+        break;
+      case 0x0402:
+        bufpush(0x0452);
+        break;
+      case 0x0403:
+        bufpush(0x0453);
+        break;
+      case 0x0404:
+        bufpush(0x0454);
+        break;
+      case 0x0405:
+        bufpush(0x0455);
+        break;
+      case 0x0406:
+        bufpush(0x0456);
+        break;
+      case 0x0407:
+        bufpush(0x0457);
+        break;
+      case 0x0408:
+        bufpush(0x0458);
+        break;
+      case 0x0409:
+        bufpush(0x0459);
+        break;
+      case 0x040A:
+        bufpush(0x045A);
+        break;
+      case 0x040B:
+        bufpush(0x045B);
+        break;
+      case 0x040C:
+        bufpush(0x045C);
+        break;
+      case 0x040D:
+        bufpush(0x045D);
+        break;
+      case 0x040E:
+        bufpush(0x045E);
+        break;
+      case 0x040F:
+        bufpush(0x045F);
+        break;
+      case 0x0410:
+        bufpush(0x0430);
+        break;
+      case 0x0411:
+        bufpush(0x0431);
+        break;
+      case 0x0412:
+        bufpush(0x0432);
+        break;
+      case 0x0413:
+        bufpush(0x0433);
+        break;
+      case 0x0414:
+        bufpush(0x0434);
+        break;
+      case 0x0415:
+        bufpush(0x0435);
+        break;
+      case 0x0416:
+        bufpush(0x0436);
+        break;
+      case 0x0417:
+        bufpush(0x0437);
+        break;
+      case 0x0418:
+        bufpush(0x0438);
+        break;
+      case 0x0419:
+        bufpush(0x0439);
+        break;
+      case 0x041A:
+        bufpush(0x043A);
+        break;
+      case 0x041B:
+        bufpush(0x043B);
+        break;
+      case 0x041C:
+        bufpush(0x043C);
+        break;
+      case 0x041D:
+        bufpush(0x043D);
+        break;
+      case 0x041E:
+        bufpush(0x043E);
+        break;
+      case 0x041F:
+        bufpush(0x043F);
+        break;
+      case 0x0420:
+        bufpush(0x0440);
+        break;
+      case 0x0421:
+        bufpush(0x0441);
+        break;
+      case 0x0422:
+        bufpush(0x0442);
+        break;
+      case 0x0423:
+        bufpush(0x0443);
+        break;
+      case 0x0424:
+        bufpush(0x0444);
+        break;
+      case 0x0425:
+        bufpush(0x0445);
+        break;
+      case 0x0426:
+        bufpush(0x0446);
+        break;
+      case 0x0427:
+        bufpush(0x0447);
+        break;
+      case 0x0428:
+        bufpush(0x0448);
+        break;
+      case 0x0429:
+        bufpush(0x0449);
+        break;
+      case 0x042A:
+        bufpush(0x044A);
+        break;
+      case 0x042B:
+        bufpush(0x044B);
+        break;
+      case 0x042C:
+        bufpush(0x044C);
+        break;
+      case 0x042D:
+        bufpush(0x044D);
+        break;
+      case 0x042E:
+        bufpush(0x044E);
+        break;
+      case 0x042F:
+        bufpush(0x044F);
+        break;
+      case 0x0460:
+        bufpush(0x0461);
+        break;
+      case 0x0462:
+        bufpush(0x0463);
+        break;
+      case 0x0464:
+        bufpush(0x0465);
+        break;
+      case 0x0466:
+        bufpush(0x0467);
+        break;
+      case 0x0468:
+        bufpush(0x0469);
+        break;
+      case 0x046A:
+        bufpush(0x046B);
+        break;
+      case 0x046C:
+        bufpush(0x046D);
+        break;
+      case 0x046E:
+        bufpush(0x046F);
+        break;
+      case 0x0470:
+        bufpush(0x0471);
+        break;
+      case 0x0472:
+        bufpush(0x0473);
+        break;
+      case 0x0474:
+        bufpush(0x0475);
+        break;
+      case 0x0476:
+        bufpush(0x0477);
+        break;
+      case 0x0478:
+        bufpush(0x0479);
+        break;
+      case 0x047A:
+        bufpush(0x047B);
+        break;
+      case 0x047C:
+        bufpush(0x047D);
+        break;
+      case 0x047E:
+        bufpush(0x047F);
+        break;
+      case 0x0480:
+        bufpush(0x0481);
+        break;
+      case 0x048A:
+        bufpush(0x048B);
+        break;
+      case 0x048C:
+        bufpush(0x048D);
+        break;
+      case 0x048E:
+        bufpush(0x048F);
+        break;
+      case 0x0490:
+        bufpush(0x0491);
+        break;
+      case 0x0492:
+        bufpush(0x0493);
+        break;
+      case 0x0494:
+        bufpush(0x0495);
+        break;
+      case 0x0496:
+        bufpush(0x0497);
+        break;
+      case 0x0498:
+        bufpush(0x0499);
+        break;
+      case 0x049A:
+        bufpush(0x049B);
+        break;
+      case 0x049C:
+        bufpush(0x049D);
+        break;
+      case 0x049E:
+        bufpush(0x049F);
+        break;
+      case 0x04A0:
+        bufpush(0x04A1);
+        break;
+      case 0x04A2:
+        bufpush(0x04A3);
+        break;
+      case 0x04A4:
+        bufpush(0x04A5);
+        break;
+      case 0x04A6:
+        bufpush(0x04A7);
+        break;
+      case 0x04A8:
+        bufpush(0x04A9);
+        break;
+      case 0x04AA:
+        bufpush(0x04AB);
+        break;
+      case 0x04AC:
+        bufpush(0x04AD);
+        break;
+      case 0x04AE:
+        bufpush(0x04AF);
+        break;
+      case 0x04B0:
+        bufpush(0x04B1);
+        break;
+      case 0x04B2:
+        bufpush(0x04B3);
+        break;
+      case 0x04B4:
+        bufpush(0x04B5);
+        break;
+      case 0x04B6:
+        bufpush(0x04B7);
+        break;
+      case 0x04B8:
+        bufpush(0x04B9);
+        break;
+      case 0x04BA:
+        bufpush(0x04BB);
+        break;
+      case 0x04BC:
+        bufpush(0x04BD);
+        break;
+      case 0x04BE:
+        bufpush(0x04BF);
+        break;
+      case 0x04C0:
+        bufpush(0x04CF);
+        break;
+      case 0x04C1:
+        bufpush(0x04C2);
+        break;
+      case 0x04C3:
+        bufpush(0x04C4);
+        break;
+      case 0x04C5:
+        bufpush(0x04C6);
+        break;
+      case 0x04C7:
+        bufpush(0x04C8);
+        break;
+      case 0x04C9:
+        bufpush(0x04CA);
+        break;
+      case 0x04CB:
+        bufpush(0x04CC);
+        break;
+      case 0x04CD:
+        bufpush(0x04CE);
+        break;
+      case 0x04D0:
+        bufpush(0x04D1);
+        break;
+      case 0x04D2:
+        bufpush(0x04D3);
+        break;
+      case 0x04D4:
+        bufpush(0x04D5);
+        break;
+      case 0x04D6:
+        bufpush(0x04D7);
+        break;
+      case 0x04D8:
+        bufpush(0x04D9);
+        break;
+      case 0x04DA:
+        bufpush(0x04DB);
+        break;
+      case 0x04DC:
+        bufpush(0x04DD);
+        break;
+      case 0x04DE:
+        bufpush(0x04DF);
+        break;
+      case 0x04E0:
+        bufpush(0x04E1);
+        break;
+      case 0x04E2:
+        bufpush(0x04E3);
+        break;
+      case 0x04E4:
+        bufpush(0x04E5);
+        break;
+      case 0x04E6:
+        bufpush(0x04E7);
+        break;
+      case 0x04E8:
+        bufpush(0x04E9);
+        break;
+      case 0x04EA:
+        bufpush(0x04EB);
+        break;
+      case 0x04EC:
+        bufpush(0x04ED);
+        break;
+      case 0x04EE:
+        bufpush(0x04EF);
+        break;
+      case 0x04F0:
+        bufpush(0x04F1);
+        break;
+      case 0x04F2:
+        bufpush(0x04F3);
+        break;
+      case 0x04F4:
+        bufpush(0x04F5);
+        break;
+      case 0x04F6:
+        bufpush(0x04F7);
+        break;
+      case 0x04F8:
+        bufpush(0x04F9);
+        break;
+      case 0x04FA:
+        bufpush(0x04FB);
+        break;
+      case 0x04FC:
+        bufpush(0x04FD);
+        break;
+      case 0x04FE:
+        bufpush(0x04FF);
+        break;
+      case 0x0500:
+        bufpush(0x0501);
+        break;
+      case 0x0502:
+        bufpush(0x0503);
+        break;
+      case 0x0504:
+        bufpush(0x0505);
+        break;
+      case 0x0506:
+        bufpush(0x0507);
+        break;
+      case 0x0508:
+        bufpush(0x0509);
+        break;
+      case 0x050A:
+        bufpush(0x050B);
+        break;
+      case 0x050C:
+        bufpush(0x050D);
+        break;
+      case 0x050E:
+        bufpush(0x050F);
+        break;
+      case 0x0510:
+        bufpush(0x0511);
+        break;
+      case 0x0512:
+        bufpush(0x0513);
+        break;
+      case 0x0514:
+        bufpush(0x0515);
+        break;
+      case 0x0516:
+        bufpush(0x0517);
+        break;
+      case 0x0518:
+        bufpush(0x0519);
+        break;
+      case 0x051A:
+        bufpush(0x051B);
+        break;
+      case 0x051C:
+        bufpush(0x051D);
+        break;
+      case 0x051E:
+        bufpush(0x051F);
+        break;
+      case 0x0520:
+        bufpush(0x0521);
+        break;
+      case 0x0522:
+        bufpush(0x0523);
+        break;
+      case 0x0524:
+        bufpush(0x0525);
+        break;
+      case 0x0526:
+        bufpush(0x0527);
+        break;
+      case 0x0528:
+        bufpush(0x0529);
+        break;
+      case 0x052A:
+        bufpush(0x052B);
+        break;
+      case 0x052C:
+        bufpush(0x052D);
+        break;
+      case 0x052E:
+        bufpush(0x052F);
+        break;
+      case 0x0531:
+        bufpush(0x0561);
+        break;
+      case 0x0532:
+        bufpush(0x0562);
+        break;
+      case 0x0533:
+        bufpush(0x0563);
+        break;
+      case 0x0534:
+        bufpush(0x0564);
+        break;
+      case 0x0535:
+        bufpush(0x0565);
+        break;
+      case 0x0536:
+        bufpush(0x0566);
+        break;
+      case 0x0537:
+        bufpush(0x0567);
+        break;
+      case 0x0538:
+        bufpush(0x0568);
+        break;
+      case 0x0539:
+        bufpush(0x0569);
+        break;
+      case 0x053A:
+        bufpush(0x056A);
+        break;
+      case 0x053B:
+        bufpush(0x056B);
+        break;
+      case 0x053C:
+        bufpush(0x056C);
+        break;
+      case 0x053D:
+        bufpush(0x056D);
+        break;
+      case 0x053E:
+        bufpush(0x056E);
+        break;
+      case 0x053F:
+        bufpush(0x056F);
+        break;
+      case 0x0540:
+        bufpush(0x0570);
+        break;
+      case 0x0541:
+        bufpush(0x0571);
+        break;
+      case 0x0542:
+        bufpush(0x0572);
+        break;
+      case 0x0543:
+        bufpush(0x0573);
+        break;
+      case 0x0544:
+        bufpush(0x0574);
+        break;
+      case 0x0545:
+        bufpush(0x0575);
+        break;
+      case 0x0546:
+        bufpush(0x0576);
+        break;
+      case 0x0547:
+        bufpush(0x0577);
+        break;
+      case 0x0548:
+        bufpush(0x0578);
+        break;
+      case 0x0549:
+        bufpush(0x0579);
+        break;
+      case 0x054A:
+        bufpush(0x057A);
+        break;
+      case 0x054B:
+        bufpush(0x057B);
+        break;
+      case 0x054C:
+        bufpush(0x057C);
+        break;
+      case 0x054D:
+        bufpush(0x057D);
+        break;
+      case 0x054E:
+        bufpush(0x057E);
+        break;
+      case 0x054F:
+        bufpush(0x057F);
+        break;
+      case 0x0550:
+        bufpush(0x0580);
+        break;
+      case 0x0551:
+        bufpush(0x0581);
+        break;
+      case 0x0552:
+        bufpush(0x0582);
+        break;
+      case 0x0553:
+        bufpush(0x0583);
+        break;
+      case 0x0554:
+        bufpush(0x0584);
+        break;
+      case 0x0555:
+        bufpush(0x0585);
+        break;
+      case 0x0556:
+        bufpush(0x0586);
+        break;
+      case 0x0587:
+        bufpush(0x0565);
+        bufpush(0x0582);
+        break;
+      case 0x10A0:
+        bufpush(0x2D00);
+        break;
+      case 0x10A1:
+        bufpush(0x2D01);
+        break;
+      case 0x10A2:
+        bufpush(0x2D02);
+        break;
+      case 0x10A3:
+        bufpush(0x2D03);
+        break;
+      case 0x10A4:
+        bufpush(0x2D04);
+        break;
+      case 0x10A5:
+        bufpush(0x2D05);
+        break;
+      case 0x10A6:
+        bufpush(0x2D06);
+        break;
+      case 0x10A7:
+        bufpush(0x2D07);
+        break;
+      case 0x10A8:
+        bufpush(0x2D08);
+        break;
+      case 0x10A9:
+        bufpush(0x2D09);
+        break;
+      case 0x10AA:
+        bufpush(0x2D0A);
+        break;
+      case 0x10AB:
+        bufpush(0x2D0B);
+        break;
+      case 0x10AC:
+        bufpush(0x2D0C);
+        break;
+      case 0x10AD:
+        bufpush(0x2D0D);
+        break;
+      case 0x10AE:
+        bufpush(0x2D0E);
+        break;
+      case 0x10AF:
+        bufpush(0x2D0F);
+        break;
+      case 0x10B0:
+        bufpush(0x2D10);
+        break;
+      case 0x10B1:
+        bufpush(0x2D11);
+        break;
+      case 0x10B2:
+        bufpush(0x2D12);
+        break;
+      case 0x10B3:
+        bufpush(0x2D13);
+        break;
+      case 0x10B4:
+        bufpush(0x2D14);
+        break;
+      case 0x10B5:
+        bufpush(0x2D15);
+        break;
+      case 0x10B6:
+        bufpush(0x2D16);
+        break;
+      case 0x10B7:
+        bufpush(0x2D17);
+        break;
+      case 0x10B8:
+        bufpush(0x2D18);
+        break;
+      case 0x10B9:
+        bufpush(0x2D19);
+        break;
+      case 0x10BA:
+        bufpush(0x2D1A);
+        break;
+      case 0x10BB:
+        bufpush(0x2D1B);
+        break;
+      case 0x10BC:
+        bufpush(0x2D1C);
+        break;
+      case 0x10BD:
+        bufpush(0x2D1D);
+        break;
+      case 0x10BE:
+        bufpush(0x2D1E);
+        break;
+      case 0x10BF:
+        bufpush(0x2D1F);
+        break;
+      case 0x10C0:
+        bufpush(0x2D20);
+        break;
+      case 0x10C1:
+        bufpush(0x2D21);
+        break;
+      case 0x10C2:
+        bufpush(0x2D22);
+        break;
+      case 0x10C3:
+        bufpush(0x2D23);
+        break;
+      case 0x10C4:
+        bufpush(0x2D24);
+        break;
+      case 0x10C5:
+        bufpush(0x2D25);
+        break;
+      case 0x10C7:
+        bufpush(0x2D27);
+        break;
+      case 0x10CD:
+        bufpush(0x2D2D);
+        break;
+      case 0x13F8:
+        bufpush(0x13F0);
+        break;
+      case 0x13F9:
+        bufpush(0x13F1);
+        break;
+      case 0x13FA:
+        bufpush(0x13F2);
+        break;
+      case 0x13FB:
+        bufpush(0x13F3);
+        break;
+      case 0x13FC:
+        bufpush(0x13F4);
+        break;
+      case 0x13FD:
+        bufpush(0x13F5);
+        break;
+      case 0x1C80:
+        bufpush(0x0432);
+        break;
+      case 0x1C81:
+        bufpush(0x0434);
+        break;
+      case 0x1C82:
+        bufpush(0x043E);
+        break;
+      case 0x1C83:
+        bufpush(0x0441);
+        break;
+      case 0x1C84:
+        bufpush(0x0442);
+        break;
+      case 0x1C85:
+        bufpush(0x0442);
+        break;
+      case 0x1C86:
+        bufpush(0x044A);
+        break;
+      case 0x1C87:
+        bufpush(0x0463);
+        break;
+      case 0x1C88:
+        bufpush(0xA64B);
+        break;
+      case 0x1C90:
+        bufpush(0x10D0);
+        break;
+      case 0x1C91:
+        bufpush(0x10D1);
+        break;
+      case 0x1C92:
+        bufpush(0x10D2);
+        break;
+      case 0x1C93:
+        bufpush(0x10D3);
+        break;
+      case 0x1C94:
+        bufpush(0x10D4);
+        break;
+      case 0x1C95:
+        bufpush(0x10D5);
+        break;
+      case 0x1C96:
+        bufpush(0x10D6);
+        break;
+      case 0x1C97:
+        bufpush(0x10D7);
+        break;
+      case 0x1C98:
+        bufpush(0x10D8);
+        break;
+      case 0x1C99:
+        bufpush(0x10D9);
+        break;
+      case 0x1C9A:
+        bufpush(0x10DA);
+        break;
+      case 0x1C9B:
+        bufpush(0x10DB);
+        break;
+      case 0x1C9C:
+        bufpush(0x10DC);
+        break;
+      case 0x1C9D:
+        bufpush(0x10DD);
+        break;
+      case 0x1C9E:
+        bufpush(0x10DE);
+        break;
+      case 0x1C9F:
+        bufpush(0x10DF);
+        break;
+      case 0x1CA0:
+        bufpush(0x10E0);
+        break;
+      case 0x1CA1:
+        bufpush(0x10E1);
+        break;
+      case 0x1CA2:
+        bufpush(0x10E2);
+        break;
+      case 0x1CA3:
+        bufpush(0x10E3);
+        break;
+      case 0x1CA4:
+        bufpush(0x10E4);
+        break;
+      case 0x1CA5:
+        bufpush(0x10E5);
+        break;
+      case 0x1CA6:
+        bufpush(0x10E6);
+        break;
+      case 0x1CA7:
+        bufpush(0x10E7);
+        break;
+      case 0x1CA8:
+        bufpush(0x10E8);
+        break;
+      case 0x1CA9:
+        bufpush(0x10E9);
+        break;
+      case 0x1CAA:
+        bufpush(0x10EA);
+        break;
+      case 0x1CAB:
+        bufpush(0x10EB);
+        break;
+      case 0x1CAC:
+        bufpush(0x10EC);
+        break;
+      case 0x1CAD:
+        bufpush(0x10ED);
+        break;
+      case 0x1CAE:
+        bufpush(0x10EE);
+        break;
+      case 0x1CAF:
+        bufpush(0x10EF);
+        break;
+      case 0x1CB0:
+        bufpush(0x10F0);
+        break;
+      case 0x1CB1:
+        bufpush(0x10F1);
+        break;
+      case 0x1CB2:
+        bufpush(0x10F2);
+        break;
+      case 0x1CB3:
+        bufpush(0x10F3);
+        break;
+      case 0x1CB4:
+        bufpush(0x10F4);
+        break;
+      case 0x1CB5:
+        bufpush(0x10F5);
+        break;
+      case 0x1CB6:
+        bufpush(0x10F6);
+        break;
+      case 0x1CB7:
+        bufpush(0x10F7);
+        break;
+      case 0x1CB8:
+        bufpush(0x10F8);
+        break;
+      case 0x1CB9:
+        bufpush(0x10F9);
+        break;
+      case 0x1CBA:
+        bufpush(0x10FA);
+        break;
+      case 0x1CBD:
+        bufpush(0x10FD);
+        break;
+      case 0x1CBE:
+        bufpush(0x10FE);
+        break;
+      case 0x1CBF:
+        bufpush(0x10FF);
+        break;
+      case 0x1E00:
+        bufpush(0x1E01);
+        break;
+      case 0x1E02:
+        bufpush(0x1E03);
+        break;
+      case 0x1E04:
+        bufpush(0x1E05);
+        break;
+      case 0x1E06:
+        bufpush(0x1E07);
+        break;
+      case 0x1E08:
+        bufpush(0x1E09);
+        break;
+      case 0x1E0A:
+        bufpush(0x1E0B);
+        break;
+      case 0x1E0C:
+        bufpush(0x1E0D);
+        break;
+      case 0x1E0E:
+        bufpush(0x1E0F);
+        break;
+      case 0x1E10:
+        bufpush(0x1E11);
+        break;
+      case 0x1E12:
+        bufpush(0x1E13);
+        break;
+      case 0x1E14:
+        bufpush(0x1E15);
+        break;
+      case 0x1E16:
+        bufpush(0x1E17);
+        break;
+      case 0x1E18:
+        bufpush(0x1E19);
+        break;
+      case 0x1E1A:
+        bufpush(0x1E1B);
+        break;
+      case 0x1E1C:
+        bufpush(0x1E1D);
+        break;
+      case 0x1E1E:
+        bufpush(0x1E1F);
+        break;
+      case 0x1E20:
+        bufpush(0x1E21);
+        break;
+      case 0x1E22:
+        bufpush(0x1E23);
+        break;
+      case 0x1E24:
+        bufpush(0x1E25);
+        break;
+      case 0x1E26:
+        bufpush(0x1E27);
+        break;
+      case 0x1E28:
+        bufpush(0x1E29);
+        break;
+      case 0x1E2A:
+        bufpush(0x1E2B);
+        break;
+      case 0x1E2C:
+        bufpush(0x1E2D);
+        break;
+      case 0x1E2E:
+        bufpush(0x1E2F);
+        break;
+      case 0x1E30:
+        bufpush(0x1E31);
+        break;
+      case 0x1E32:
+        bufpush(0x1E33);
+        break;
+      case 0x1E34:
+        bufpush(0x1E35);
+        break;
+      case 0x1E36:
+        bufpush(0x1E37);
+        break;
+      case 0x1E38:
+        bufpush(0x1E39);
+        break;
+      case 0x1E3A:
+        bufpush(0x1E3B);
+        break;
+      case 0x1E3C:
+        bufpush(0x1E3D);
+        break;
+      case 0x1E3E:
+        bufpush(0x1E3F);
+        break;
+      case 0x1E40:
+        bufpush(0x1E41);
+        break;
+      case 0x1E42:
+        bufpush(0x1E43);
+        break;
+      case 0x1E44:
+        bufpush(0x1E45);
+        break;
+      case 0x1E46:
+        bufpush(0x1E47);
+        break;
+      case 0x1E48:
+        bufpush(0x1E49);
+        break;
+      case 0x1E4A:
+        bufpush(0x1E4B);
+        break;
+      case 0x1E4C:
+        bufpush(0x1E4D);
+        break;
+      case 0x1E4E:
+        bufpush(0x1E4F);
+        break;
+      case 0x1E50:
+        bufpush(0x1E51);
+        break;
+      case 0x1E52:
+        bufpush(0x1E53);
+        break;
+      case 0x1E54:
+        bufpush(0x1E55);
+        break;
+      case 0x1E56:
+        bufpush(0x1E57);
+        break;
+      case 0x1E58:
+        bufpush(0x1E59);
+        break;
+      case 0x1E5A:
+        bufpush(0x1E5B);
+        break;
+      case 0x1E5C:
+        bufpush(0x1E5D);
+        break;
+      case 0x1E5E:
+        bufpush(0x1E5F);
+        break;
+      case 0x1E60:
+        bufpush(0x1E61);
+        break;
+      case 0x1E62:
+        bufpush(0x1E63);
+        break;
+      case 0x1E64:
+        bufpush(0x1E65);
+        break;
+      case 0x1E66:
+        bufpush(0x1E67);
+        break;
+      case 0x1E68:
+        bufpush(0x1E69);
+        break;
+      case 0x1E6A:
+        bufpush(0x1E6B);
+        break;
+      case 0x1E6C:
+        bufpush(0x1E6D);
+        break;
+      case 0x1E6E:
+        bufpush(0x1E6F);
+        break;
+      case 0x1E70:
+        bufpush(0x1E71);
+        break;
+      case 0x1E72:
+        bufpush(0x1E73);
+        break;
+      case 0x1E74:
+        bufpush(0x1E75);
+        break;
+      case 0x1E76:
+        bufpush(0x1E77);
+        break;
+      case 0x1E78:
+        bufpush(0x1E79);
+        break;
+      case 0x1E7A:
+        bufpush(0x1E7B);
+        break;
+      case 0x1E7C:
+        bufpush(0x1E7D);
+        break;
+      case 0x1E7E:
+        bufpush(0x1E7F);
+        break;
+      case 0x1E80:
+        bufpush(0x1E81);
+        break;
+      case 0x1E82:
+        bufpush(0x1E83);
+        break;
+      case 0x1E84:
+        bufpush(0x1E85);
+        break;
+      case 0x1E86:
+        bufpush(0x1E87);
+        break;
+      case 0x1E88:
+        bufpush(0x1E89);
+        break;
+      case 0x1E8A:
+        bufpush(0x1E8B);
+        break;
+      case 0x1E8C:
+        bufpush(0x1E8D);
+        break;
+      case 0x1E8E:
+        bufpush(0x1E8F);
+        break;
+      case 0x1E90:
+        bufpush(0x1E91);
+        break;
+      case 0x1E92:
+        bufpush(0x1E93);
+        break;
+      case 0x1E94:
+        bufpush(0x1E95);
+        break;
+      case 0x1E96:
+        bufpush(0x0068);
+        bufpush(0x0331);
+        break;
+      case 0x1E97:
+        bufpush(0x0074);
+        bufpush(0x0308);
+        break;
+      case 0x1E98:
+        bufpush(0x0077);
+        bufpush(0x030A);
+        break;
+      case 0x1E99:
+        bufpush(0x0079);
+        bufpush(0x030A);
+        break;
+      case 0x1E9A:
+        bufpush(0x0061);
+        bufpush(0x02BE);
+        break;
+      case 0x1E9B:
+        bufpush(0x1E61);
+        break;
+      case 0x1E9E:
+        bufpush(0x0073);
+        bufpush(0x0073);
+        break;
+      case 0x1EA0:
+        bufpush(0x1EA1);
+        break;
+      case 0x1EA2:
+        bufpush(0x1EA3);
+        break;
+      case 0x1EA4:
+        bufpush(0x1EA5);
+        break;
+      case 0x1EA6:
+        bufpush(0x1EA7);
+        break;
+      case 0x1EA8:
+        bufpush(0x1EA9);
+        break;
+      case 0x1EAA:
+        bufpush(0x1EAB);
+        break;
+      case 0x1EAC:
+        bufpush(0x1EAD);
+        break;
+      case 0x1EAE:
+        bufpush(0x1EAF);
+        break;
+      case 0x1EB0:
+        bufpush(0x1EB1);
+        break;
+      case 0x1EB2:
+        bufpush(0x1EB3);
+        break;
+      case 0x1EB4:
+        bufpush(0x1EB5);
+        break;
+      case 0x1EB6:
+        bufpush(0x1EB7);
+        break;
+      case 0x1EB8:
+        bufpush(0x1EB9);
+        break;
+      case 0x1EBA:
+        bufpush(0x1EBB);
+        break;
+      case 0x1EBC:
+        bufpush(0x1EBD);
+        break;
+      case 0x1EBE:
+        bufpush(0x1EBF);
+        break;
+      case 0x1EC0:
+        bufpush(0x1EC1);
+        break;
+      case 0x1EC2:
+        bufpush(0x1EC3);
+        break;
+      case 0x1EC4:
+        bufpush(0x1EC5);
+        break;
+      case 0x1EC6:
+        bufpush(0x1EC7);
+        break;
+      case 0x1EC8:
+        bufpush(0x1EC9);
+        break;
+      case 0x1ECA:
+        bufpush(0x1ECB);
+        break;
+      case 0x1ECC:
+        bufpush(0x1ECD);
+        break;
+      case 0x1ECE:
+        bufpush(0x1ECF);
+        break;
+      case 0x1ED0:
+        bufpush(0x1ED1);
+        break;
+      case 0x1ED2:
+        bufpush(0x1ED3);
+        break;
+      case 0x1ED4:
+        bufpush(0x1ED5);
+        break;
+      case 0x1ED6:
+        bufpush(0x1ED7);
+        break;
+      case 0x1ED8:
+        bufpush(0x1ED9);
+        break;
+      case 0x1EDA:
+        bufpush(0x1EDB);
+        break;
+      case 0x1EDC:
+        bufpush(0x1EDD);
+        break;
+      case 0x1EDE:
+        bufpush(0x1EDF);
+        break;
+      case 0x1EE0:
+        bufpush(0x1EE1);
+        break;
+      case 0x1EE2:
+        bufpush(0x1EE3);
+        break;
+      case 0x1EE4:
+        bufpush(0x1EE5);
+        break;
+      case 0x1EE6:
+        bufpush(0x1EE7);
+        break;
+      case 0x1EE8:
+        bufpush(0x1EE9);
+        break;
+      case 0x1EEA:
+        bufpush(0x1EEB);
+        break;
+      case 0x1EEC:
+        bufpush(0x1EED);
+        break;
+      case 0x1EEE:
+        bufpush(0x1EEF);
+        break;
+      case 0x1EF0:
+        bufpush(0x1EF1);
+        break;
+      case 0x1EF2:
+        bufpush(0x1EF3);
+        break;
+      case 0x1EF4:
+        bufpush(0x1EF5);
+        break;
+      case 0x1EF6:
+        bufpush(0x1EF7);
+        break;
+      case 0x1EF8:
+        bufpush(0x1EF9);
+        break;
+      case 0x1EFA:
+        bufpush(0x1EFB);
+        break;
+      case 0x1EFC:
+        bufpush(0x1EFD);
+        break;
+      case 0x1EFE:
+        bufpush(0x1EFF);
+        break;
+      case 0x1F08:
+        bufpush(0x1F00);
+        break;
+      case 0x1F09:
+        bufpush(0x1F01);
+        break;
+      case 0x1F0A:
+        bufpush(0x1F02);
+        break;
+      case 0x1F0B:
+        bufpush(0x1F03);
+        break;
+      case 0x1F0C:
+        bufpush(0x1F04);
+        break;
+      case 0x1F0D:
+        bufpush(0x1F05);
+        break;
+      case 0x1F0E:
+        bufpush(0x1F06);
+        break;
+      case 0x1F0F:
+        bufpush(0x1F07);
+        break;
+      case 0x1F18:
+        bufpush(0x1F10);
+        break;
+      case 0x1F19:
+        bufpush(0x1F11);
+        break;
+      case 0x1F1A:
+        bufpush(0x1F12);
+        break;
+      case 0x1F1B:
+        bufpush(0x1F13);
+        break;
+      case 0x1F1C:
+        bufpush(0x1F14);
+        break;
+      case 0x1F1D:
+        bufpush(0x1F15);
+        break;
+      case 0x1F28:
+        bufpush(0x1F20);
+        break;
+      case 0x1F29:
+        bufpush(0x1F21);
+        break;
+      case 0x1F2A:
+        bufpush(0x1F22);
+        break;
+      case 0x1F2B:
+        bufpush(0x1F23);
+        break;
+      case 0x1F2C:
+        bufpush(0x1F24);
+        break;
+      case 0x1F2D:
+        bufpush(0x1F25);
+        break;
+      case 0x1F2E:
+        bufpush(0x1F26);
+        break;
+      case 0x1F2F:
+        bufpush(0x1F27);
+        break;
+      case 0x1F38:
+        bufpush(0x1F30);
+        break;
+      case 0x1F39:
+        bufpush(0x1F31);
+        break;
+      case 0x1F3A:
+        bufpush(0x1F32);
+        break;
+      case 0x1F3B:
+        bufpush(0x1F33);
+        break;
+      case 0x1F3C:
+        bufpush(0x1F34);
+        break;
+      case 0x1F3D:
+        bufpush(0x1F35);
+        break;
+      case 0x1F3E:
+        bufpush(0x1F36);
+        break;
+      case 0x1F3F:
+        bufpush(0x1F37);
+        break;
+      case 0x1F48:
+        bufpush(0x1F40);
+        break;
+      case 0x1F49:
+        bufpush(0x1F41);
+        break;
+      case 0x1F4A:
+        bufpush(0x1F42);
+        break;
+      case 0x1F4B:
+        bufpush(0x1F43);
+        break;
+      case 0x1F4C:
+        bufpush(0x1F44);
+        break;
+      case 0x1F4D:
+        bufpush(0x1F45);
+        break;
+      case 0x1F50:
+        bufpush(0x03C5);
+        bufpush(0x0313);
+        break;
+      case 0x1F52:
+        bufpush(0x03C5);
+        bufpush(0x0313);
+        bufpush(0x0300);
+        break;
+      case 0x1F54:
+        bufpush(0x03C5);
+        bufpush(0x0313);
+        bufpush(0x0301);
+        break;
+      case 0x1F56:
+        bufpush(0x03C5);
+        bufpush(0x0313);
+        bufpush(0x0342);
+        break;
+      case 0x1F59:
+        bufpush(0x1F51);
+        break;
+      case 0x1F5B:
+        bufpush(0x1F53);
+        break;
+      case 0x1F5D:
+        bufpush(0x1F55);
+        break;
+      case 0x1F5F:
+        bufpush(0x1F57);
+        break;
+      case 0x1F68:
+        bufpush(0x1F60);
+        break;
+      case 0x1F69:
+        bufpush(0x1F61);
+        break;
+      case 0x1F6A:
+        bufpush(0x1F62);
+        break;
+      case 0x1F6B:
+        bufpush(0x1F63);
+        break;
+      case 0x1F6C:
+        bufpush(0x1F64);
+        break;
+      case 0x1F6D:
+        bufpush(0x1F65);
+        break;
+      case 0x1F6E:
+        bufpush(0x1F66);
+        break;
+      case 0x1F6F:
+        bufpush(0x1F67);
+        break;
+      case 0x1F80:
+        bufpush(0x1F00);
+        bufpush(0x03B9);
+        break;
+      case 0x1F81:
+        bufpush(0x1F01);
+        bufpush(0x03B9);
+        break;
+      case 0x1F82:
+        bufpush(0x1F02);
+        bufpush(0x03B9);
+        break;
+      case 0x1F83:
+        bufpush(0x1F03);
+        bufpush(0x03B9);
+        break;
+      case 0x1F84:
+        bufpush(0x1F04);
+        bufpush(0x03B9);
+        break;
+      case 0x1F85:
+        bufpush(0x1F05);
+        bufpush(0x03B9);
+        break;
+      case 0x1F86:
+        bufpush(0x1F06);
+        bufpush(0x03B9);
+        break;
+      case 0x1F87:
+        bufpush(0x1F07);
+        bufpush(0x03B9);
+        break;
+      case 0x1F88:
+        bufpush(0x1F00);
+        bufpush(0x03B9);
+        break;
+      case 0x1F89:
+        bufpush(0x1F01);
+        bufpush(0x03B9);
+        break;
+      case 0x1F8A:
+        bufpush(0x1F02);
+        bufpush(0x03B9);
+        break;
+      case 0x1F8B:
+        bufpush(0x1F03);
+        bufpush(0x03B9);
+        break;
+      case 0x1F8C:
+        bufpush(0x1F04);
+        bufpush(0x03B9);
+        break;
+      case 0x1F8D:
+        bufpush(0x1F05);
+        bufpush(0x03B9);
+        break;
+      case 0x1F8E:
+        bufpush(0x1F06);
+        bufpush(0x03B9);
+        break;
+      case 0x1F8F:
+        bufpush(0x1F07);
+        bufpush(0x03B9);
+        break;
+      case 0x1F90:
+        bufpush(0x1F20);
+        bufpush(0x03B9);
+        break;
+      case 0x1F91:
+        bufpush(0x1F21);
+        bufpush(0x03B9);
+        break;
+      case 0x1F92:
+        bufpush(0x1F22);
+        bufpush(0x03B9);
+        break;
+      case 0x1F93:
+        bufpush(0x1F23);
+        bufpush(0x03B9);
+        break;
+      case 0x1F94:
+        bufpush(0x1F24);
+        bufpush(0x03B9);
+        break;
+      case 0x1F95:
+        bufpush(0x1F25);
+        bufpush(0x03B9);
+        break;
+      case 0x1F96:
+        bufpush(0x1F26);
+        bufpush(0x03B9);
+        break;
+      case 0x1F97:
+        bufpush(0x1F27);
+        bufpush(0x03B9);
+        break;
+      case 0x1F98:
+        bufpush(0x1F20);
+        bufpush(0x03B9);
+        break;
+      case 0x1F99:
+        bufpush(0x1F21);
+        bufpush(0x03B9);
+        break;
+      case 0x1F9A:
+        bufpush(0x1F22);
+        bufpush(0x03B9);
+        break;
+      case 0x1F9B:
+        bufpush(0x1F23);
+        bufpush(0x03B9);
+        break;
+      case 0x1F9C:
+        bufpush(0x1F24);
+        bufpush(0x03B9);
+        break;
+      case 0x1F9D:
+        bufpush(0x1F25);
+        bufpush(0x03B9);
+        break;
+      case 0x1F9E:
+        bufpush(0x1F26);
+        bufpush(0x03B9);
+        break;
+      case 0x1F9F:
+        bufpush(0x1F27);
+        bufpush(0x03B9);
+        break;
+      case 0x1FA0:
+        bufpush(0x1F60);
+        bufpush(0x03B9);
+        break;
+      case 0x1FA1:
+        bufpush(0x1F61);
+        bufpush(0x03B9);
+        break;
+      case 0x1FA2:
+        bufpush(0x1F62);
+        bufpush(0x03B9);
+        break;
+      case 0x1FA3:
+        bufpush(0x1F63);
+        bufpush(0x03B9);
+        break;
+      case 0x1FA4:
+        bufpush(0x1F64);
+        bufpush(0x03B9);
+        break;
+      case 0x1FA5:
+        bufpush(0x1F65);
+        bufpush(0x03B9);
+        break;
+      case 0x1FA6:
+        bufpush(0x1F66);
+        bufpush(0x03B9);
+        break;
+      case 0x1FA7:
+        bufpush(0x1F67);
+        bufpush(0x03B9);
+        break;
+      case 0x1FA8:
+        bufpush(0x1F60);
+        bufpush(0x03B9);
+        break;
+      case 0x1FA9:
+        bufpush(0x1F61);
+        bufpush(0x03B9);
+        break;
+      case 0x1FAA:
+        bufpush(0x1F62);
+        bufpush(0x03B9);
+        break;
+      case 0x1FAB:
+        bufpush(0x1F63);
+        bufpush(0x03B9);
+        break;
+      case 0x1FAC:
+        bufpush(0x1F64);
+        bufpush(0x03B9);
+        break;
+      case 0x1FAD:
+        bufpush(0x1F65);
+        bufpush(0x03B9);
+        break;
+      case 0x1FAE:
+        bufpush(0x1F66);
+        bufpush(0x03B9);
+        break;
+      case 0x1FAF:
+        bufpush(0x1F67);
+        bufpush(0x03B9);
+        break;
+      case 0x1FB2:
+        bufpush(0x1F70);
+        bufpush(0x03B9);
+        break;
+      case 0x1FB3:
+        bufpush(0x03B1);
+        bufpush(0x03B9);
+        break;
+      case 0x1FB4:
+        bufpush(0x03AC);
+        bufpush(0x03B9);
+        break;
+      case 0x1FB6:
+        bufpush(0x03B1);
+        bufpush(0x0342);
+        break;
+      case 0x1FB7:
+        bufpush(0x03B1);
+        bufpush(0x0342);
+        bufpush(0x03B9);
+        break;
+      case 0x1FB8:
+        bufpush(0x1FB0);
+        break;
+      case 0x1FB9:
+        bufpush(0x1FB1);
+        break;
+      case 0x1FBA:
+        bufpush(0x1F70);
+        break;
+      case 0x1FBB:
+        bufpush(0x1F71);
+        break;
+      case 0x1FBC:
+        bufpush(0x03B1);
+        bufpush(0x03B9);
+        break;
+      case 0x1FBE:
+        bufpush(0x03B9);
+        break;
+      case 0x1FC2:
+        bufpush(0x1F74);
+        bufpush(0x03B9);
+        break;
+      case 0x1FC3:
+        bufpush(0x03B7);
+        bufpush(0x03B9);
+        break;
+      case 0x1FC4:
+        bufpush(0x03AE);
+        bufpush(0x03B9);
+        break;
+      case 0x1FC6:
+        bufpush(0x03B7);
+        bufpush(0x0342);
+        break;
+      case 0x1FC7:
+        bufpush(0x03B7);
+        bufpush(0x0342);
+        bufpush(0x03B9);
+        break;
+      case 0x1FC8:
+        bufpush(0x1F72);
+        break;
+      case 0x1FC9:
+        bufpush(0x1F73);
+        break;
+      case 0x1FCA:
+        bufpush(0x1F74);
+        break;
+      case 0x1FCB:
+        bufpush(0x1F75);
+        break;
+      case 0x1FCC:
+        bufpush(0x03B7);
+        bufpush(0x03B9);
+        break;
+      case 0x1FD2:
+        bufpush(0x03B9);
+        bufpush(0x0308);
+        bufpush(0x0300);
+        break;
+      case 0x1FD3:
+        bufpush(0x03B9);
+        bufpush(0x0308);
+        bufpush(0x0301);
+        break;
+      case 0x1FD6:
+        bufpush(0x03B9);
+        bufpush(0x0342);
+        break;
+      case 0x1FD7:
+        bufpush(0x03B9);
+        bufpush(0x0308);
+        bufpush(0x0342);
+        break;
+      case 0x1FD8:
+        bufpush(0x1FD0);
+        break;
+      case 0x1FD9:
+        bufpush(0x1FD1);
+        break;
+      case 0x1FDA:
+        bufpush(0x1F76);
+        break;
+      case 0x1FDB:
+        bufpush(0x1F77);
+        break;
+      case 0x1FE2:
+        bufpush(0x03C5);
+        bufpush(0x0308);
+        bufpush(0x0300);
+        break;
+      case 0x1FE3:
+        bufpush(0x03C5);
+        bufpush(0x0308);
+        bufpush(0x0301);
+        break;
+      case 0x1FE4:
+        bufpush(0x03C1);
+        bufpush(0x0313);
+        break;
+      case 0x1FE6:
+        bufpush(0x03C5);
+        bufpush(0x0342);
+        break;
+      case 0x1FE7:
+        bufpush(0x03C5);
+        bufpush(0x0308);
+        bufpush(0x0342);
+        break;
+      case 0x1FE8:
+        bufpush(0x1FE0);
+        break;
+      case 0x1FE9:
+        bufpush(0x1FE1);
+        break;
+      case 0x1FEA:
+        bufpush(0x1F7A);
+        break;
+      case 0x1FEB:
+        bufpush(0x1F7B);
+        break;
+      case 0x1FEC:
+        bufpush(0x1FE5);
+        break;
+      case 0x1FF2:
+        bufpush(0x1F7C);
+        bufpush(0x03B9);
+        break;
+      case 0x1FF3:
+        bufpush(0x03C9);
+        bufpush(0x03B9);
+        break;
+      case 0x1FF4:
+        bufpush(0x03CE);
+        bufpush(0x03B9);
+        break;
+      case 0x1FF6:
+        bufpush(0x03C9);
+        bufpush(0x0342);
+        break;
+      case 0x1FF7:
+        bufpush(0x03C9);
+        bufpush(0x0342);
+        bufpush(0x03B9);
+        break;
+      case 0x1FF8:
+        bufpush(0x1F78);
+        break;
+      case 0x1FF9:
+        bufpush(0x1F79);
+        break;
+      case 0x1FFA:
+        bufpush(0x1F7C);
+        break;
+      case 0x1FFB:
+        bufpush(0x1F7D);
+        break;
+      case 0x1FFC:
+        bufpush(0x03C9);
+        bufpush(0x03B9);
+        break;
+      case 0x2126:
+        bufpush(0x03C9);
+        break;
+      case 0x212A:
+        bufpush(0x006B);
+        break;
+      case 0x212B:
+        bufpush(0x00E5);
+        break;
+      case 0x2132:
+        bufpush(0x214E);
+        break;
+      case 0x2160:
+        bufpush(0x2170);
+        break;
+      case 0x2161:
+        bufpush(0x2171);
+        break;
+      case 0x2162:
+        bufpush(0x2172);
+        break;
+      case 0x2163:
+        bufpush(0x2173);
+        break;
+      case 0x2164:
+        bufpush(0x2174);
+        break;
+      case 0x2165:
+        bufpush(0x2175);
+        break;
+      case 0x2166:
+        bufpush(0x2176);
+        break;
+      case 0x2167:
+        bufpush(0x2177);
+        break;
+      case 0x2168:
+        bufpush(0x2178);
+        break;
+      case 0x2169:
+        bufpush(0x2179);
+        break;
+      case 0x216A:
+        bufpush(0x217A);
+        break;
+      case 0x216B:
+        bufpush(0x217B);
+        break;
+      case 0x216C:
+        bufpush(0x217C);
+        break;
+      case 0x216D:
+        bufpush(0x217D);
+        break;
+      case 0x216E:
+        bufpush(0x217E);
+        break;
+      case 0x216F:
+        bufpush(0x217F);
+        break;
+      case 0x2183:
+        bufpush(0x2184);
+        break;
+      case 0x24B6:
+        bufpush(0x24D0);
+        break;
+      case 0x24B7:
+        bufpush(0x24D1);
+        break;
+      case 0x24B8:
+        bufpush(0x24D2);
+        break;
+      case 0x24B9:
+        bufpush(0x24D3);
+        break;
+      case 0x24BA:
+        bufpush(0x24D4);
+        break;
+      case 0x24BB:
+        bufpush(0x24D5);
+        break;
+      case 0x24BC:
+        bufpush(0x24D6);
+        break;
+      case 0x24BD:
+        bufpush(0x24D7);
+        break;
+      case 0x24BE:
+        bufpush(0x24D8);
+        break;
+      case 0x24BF:
+        bufpush(0x24D9);
+        break;
+      case 0x24C0:
+        bufpush(0x24DA);
+        break;
+      case 0x24C1:
+        bufpush(0x24DB);
+        break;
+      case 0x24C2:
+        bufpush(0x24DC);
+        break;
+      case 0x24C3:
+        bufpush(0x24DD);
+        break;
+      case 0x24C4:
+        bufpush(0x24DE);
+        break;
+      case 0x24C5:
+        bufpush(0x24DF);
+        break;
+      case 0x24C6:
+        bufpush(0x24E0);
+        break;
+      case 0x24C7:
+        bufpush(0x24E1);
+        break;
+      case 0x24C8:
+        bufpush(0x24E2);
+        break;
+      case 0x24C9:
+        bufpush(0x24E3);
+        break;
+      case 0x24CA:
+        bufpush(0x24E4);
+        break;
+      case 0x24CB:
+        bufpush(0x24E5);
+        break;
+      case 0x24CC:
+        bufpush(0x24E6);
+        break;
+      case 0x24CD:
+        bufpush(0x24E7);
+        break;
+      case 0x24CE:
+        bufpush(0x24E8);
+        break;
+      case 0x24CF:
+        bufpush(0x24E9);
+        break;
+      case 0x2C00:
+        bufpush(0x2C30);
+        break;
+      case 0x2C01:
+        bufpush(0x2C31);
+        break;
+      case 0x2C02:
+        bufpush(0x2C32);
+        break;
+      case 0x2C03:
+        bufpush(0x2C33);
+        break;
+      case 0x2C04:
+        bufpush(0x2C34);
+        break;
+      case 0x2C05:
+        bufpush(0x2C35);
+        break;
+      case 0x2C06:
+        bufpush(0x2C36);
+        break;
+      case 0x2C07:
+        bufpush(0x2C37);
+        break;
+      case 0x2C08:
+        bufpush(0x2C38);
+        break;
+      case 0x2C09:
+        bufpush(0x2C39);
+        break;
+      case 0x2C0A:
+        bufpush(0x2C3A);
+        break;
+      case 0x2C0B:
+        bufpush(0x2C3B);
+        break;
+      case 0x2C0C:
+        bufpush(0x2C3C);
+        break;
+      case 0x2C0D:
+        bufpush(0x2C3D);
+        break;
+      case 0x2C0E:
+        bufpush(0x2C3E);
+        break;
+      case 0x2C0F:
+        bufpush(0x2C3F);
+        break;
+      case 0x2C10:
+        bufpush(0x2C40);
+        break;
+      case 0x2C11:
+        bufpush(0x2C41);
+        break;
+      case 0x2C12:
+        bufpush(0x2C42);
+        break;
+      case 0x2C13:
+        bufpush(0x2C43);
+        break;
+      case 0x2C14:
+        bufpush(0x2C44);
+        break;
+      case 0x2C15:
+        bufpush(0x2C45);
+        break;
+      case 0x2C16:
+        bufpush(0x2C46);
+        break;
+      case 0x2C17:
+        bufpush(0x2C47);
+        break;
+      case 0x2C18:
+        bufpush(0x2C48);
+        break;
+      case 0x2C19:
+        bufpush(0x2C49);
+        break;
+      case 0x2C1A:
+        bufpush(0x2C4A);
+        break;
+      case 0x2C1B:
+        bufpush(0x2C4B);
+        break;
+      case 0x2C1C:
+        bufpush(0x2C4C);
+        break;
+      case 0x2C1D:
+        bufpush(0x2C4D);
+        break;
+      case 0x2C1E:
+        bufpush(0x2C4E);
+        break;
+      case 0x2C1F:
+        bufpush(0x2C4F);
+        break;
+      case 0x2C20:
+        bufpush(0x2C50);
+        break;
+      case 0x2C21:
+        bufpush(0x2C51);
+        break;
+      case 0x2C22:
+        bufpush(0x2C52);
+        break;
+      case 0x2C23:
+        bufpush(0x2C53);
+        break;
+      case 0x2C24:
+        bufpush(0x2C54);
+        break;
+      case 0x2C25:
+        bufpush(0x2C55);
+        break;
+      case 0x2C26:
+        bufpush(0x2C56);
+        break;
+      case 0x2C27:
+        bufpush(0x2C57);
+        break;
+      case 0x2C28:
+        bufpush(0x2C58);
+        break;
+      case 0x2C29:
+        bufpush(0x2C59);
+        break;
+      case 0x2C2A:
+        bufpush(0x2C5A);
+        break;
+      case 0x2C2B:
+        bufpush(0x2C5B);
+        break;
+      case 0x2C2C:
+        bufpush(0x2C5C);
+        break;
+      case 0x2C2D:
+        bufpush(0x2C5D);
+        break;
+      case 0x2C2E:
+        bufpush(0x2C5E);
+        break;
+      case 0x2C60:
+        bufpush(0x2C61);
+        break;
+      case 0x2C62:
+        bufpush(0x026B);
+        break;
+      case 0x2C63:
+        bufpush(0x1D7D);
+        break;
+      case 0x2C64:
+        bufpush(0x027D);
+        break;
+      case 0x2C67:
+        bufpush(0x2C68);
+        break;
+      case 0x2C69:
+        bufpush(0x2C6A);
+        break;
+      case 0x2C6B:
+        bufpush(0x2C6C);
+        break;
+      case 0x2C6D:
+        bufpush(0x0251);
+        break;
+      case 0x2C6E:
+        bufpush(0x0271);
+        break;
+      case 0x2C6F:
+        bufpush(0x0250);
+        break;
+      case 0x2C70:
+        bufpush(0x0252);
+        break;
+      case 0x2C72:
+        bufpush(0x2C73);
+        break;
+      case 0x2C75:
+        bufpush(0x2C76);
+        break;
+      case 0x2C7E:
+        bufpush(0x023F);
+        break;
+      case 0x2C7F:
+        bufpush(0x0240);
+        break;
+      case 0x2C80:
+        bufpush(0x2C81);
+        break;
+      case 0x2C82:
+        bufpush(0x2C83);
+        break;
+      case 0x2C84:
+        bufpush(0x2C85);
+        break;
+      case 0x2C86:
+        bufpush(0x2C87);
+        break;
+      case 0x2C88:
+        bufpush(0x2C89);
+        break;
+      case 0x2C8A:
+        bufpush(0x2C8B);
+        break;
+      case 0x2C8C:
+        bufpush(0x2C8D);
+        break;
+      case 0x2C8E:
+        bufpush(0x2C8F);
+        break;
+      case 0x2C90:
+        bufpush(0x2C91);
+        break;
+      case 0x2C92:
+        bufpush(0x2C93);
+        break;
+      case 0x2C94:
+        bufpush(0x2C95);
+        break;
+      case 0x2C96:
+        bufpush(0x2C97);
+        break;
+      case 0x2C98:
+        bufpush(0x2C99);
+        break;
+      case 0x2C9A:
+        bufpush(0x2C9B);
+        break;
+      case 0x2C9C:
+        bufpush(0x2C9D);
+        break;
+      case 0x2C9E:
+        bufpush(0x2C9F);
+        break;
+      case 0x2CA0:
+        bufpush(0x2CA1);
+        break;
+      case 0x2CA2:
+        bufpush(0x2CA3);
+        break;
+      case 0x2CA4:
+        bufpush(0x2CA5);
+        break;
+      case 0x2CA6:
+        bufpush(0x2CA7);
+        break;
+      case 0x2CA8:
+        bufpush(0x2CA9);
+        break;
+      case 0x2CAA:
+        bufpush(0x2CAB);
+        break;
+      case 0x2CAC:
+        bufpush(0x2CAD);
+        break;
+      case 0x2CAE:
+        bufpush(0x2CAF);
+        break;
+      case 0x2CB0:
+        bufpush(0x2CB1);
+        break;
+      case 0x2CB2:
+        bufpush(0x2CB3);
+        break;
+      case 0x2CB4:
+        bufpush(0x2CB5);
+        break;
+      case 0x2CB6:
+        bufpush(0x2CB7);
+        break;
+      case 0x2CB8:
+        bufpush(0x2CB9);
+        break;
+      case 0x2CBA:
+        bufpush(0x2CBB);
+        break;
+      case 0x2CBC:
+        bufpush(0x2CBD);
+        break;
+      case 0x2CBE:
+        bufpush(0x2CBF);
+        break;
+      case 0x2CC0:
+        bufpush(0x2CC1);
+        break;
+      case 0x2CC2:
+        bufpush(0x2CC3);
+        break;
+      case 0x2CC4:
+        bufpush(0x2CC5);
+        break;
+      case 0x2CC6:
+        bufpush(0x2CC7);
+        break;
+      case 0x2CC8:
+        bufpush(0x2CC9);
+        break;
+      case 0x2CCA:
+        bufpush(0x2CCB);
+        break;
+      case 0x2CCC:
+        bufpush(0x2CCD);
+        break;
+      case 0x2CCE:
+        bufpush(0x2CCF);
+        break;
+      case 0x2CD0:
+        bufpush(0x2CD1);
+        break;
+      case 0x2CD2:
+        bufpush(0x2CD3);
+        break;
+      case 0x2CD4:
+        bufpush(0x2CD5);
+        break;
+      case 0x2CD6:
+        bufpush(0x2CD7);
+        break;
+      case 0x2CD8:
+        bufpush(0x2CD9);
+        break;
+      case 0x2CDA:
+        bufpush(0x2CDB);
+        break;
+      case 0x2CDC:
+        bufpush(0x2CDD);
+        break;
+      case 0x2CDE:
+        bufpush(0x2CDF);
+        break;
+      case 0x2CE0:
+        bufpush(0x2CE1);
+        break;
+      case 0x2CE2:
+        bufpush(0x2CE3);
+        break;
+      case 0x2CEB:
+        bufpush(0x2CEC);
+        break;
+      case 0x2CED:
+        bufpush(0x2CEE);
+        break;
+      case 0x2CF2:
+        bufpush(0x2CF3);
+        break;
+      case 0xA640:
+        bufpush(0xA641);
+        break;
+      case 0xA642:
+        bufpush(0xA643);
+        break;
+      case 0xA644:
+        bufpush(0xA645);
+        break;
+      case 0xA646:
+        bufpush(0xA647);
+        break;
+      case 0xA648:
+        bufpush(0xA649);
+        break;
+      case 0xA64A:
+        bufpush(0xA64B);
+        break;
+      case 0xA64C:
+        bufpush(0xA64D);
+        break;
+      case 0xA64E:
+        bufpush(0xA64F);
+        break;
+      case 0xA650:
+        bufpush(0xA651);
+        break;
+      case 0xA652:
+        bufpush(0xA653);
+        break;
+      case 0xA654:
+        bufpush(0xA655);
+        break;
+      case 0xA656:
+        bufpush(0xA657);
+        break;
+      case 0xA658:
+        bufpush(0xA659);
+        break;
+      case 0xA65A:
+        bufpush(0xA65B);
+        break;
+      case 0xA65C:
+        bufpush(0xA65D);
+        break;
+      case 0xA65E:
+        bufpush(0xA65F);
+        break;
+      case 0xA660:
+        bufpush(0xA661);
+        break;
+      case 0xA662:
+        bufpush(0xA663);
+        break;
+      case 0xA664:
+        bufpush(0xA665);
+        break;
+      case 0xA666:
+        bufpush(0xA667);
+        break;
+      case 0xA668:
+        bufpush(0xA669);
+        break;
+      case 0xA66A:
+        bufpush(0xA66B);
+        break;
+      case 0xA66C:
+        bufpush(0xA66D);
+        break;
+      case 0xA680:
+        bufpush(0xA681);
+        break;
+      case 0xA682:
+        bufpush(0xA683);
+        break;
+      case 0xA684:
+        bufpush(0xA685);
+        break;
+      case 0xA686:
+        bufpush(0xA687);
+        break;
+      case 0xA688:
+        bufpush(0xA689);
+        break;
+      case 0xA68A:
+        bufpush(0xA68B);
+        break;
+      case 0xA68C:
+        bufpush(0xA68D);
+        break;
+      case 0xA68E:
+        bufpush(0xA68F);
+        break;
+      case 0xA690:
+        bufpush(0xA691);
+        break;
+      case 0xA692:
+        bufpush(0xA693);
+        break;
+      case 0xA694:
+        bufpush(0xA695);
+        break;
+      case 0xA696:
+        bufpush(0xA697);
+        break;
+      case 0xA698:
+        bufpush(0xA699);
+        break;
+      case 0xA69A:
+        bufpush(0xA69B);
+        break;
+      case 0xA722:
+        bufpush(0xA723);
+        break;
+      case 0xA724:
+        bufpush(0xA725);
+        break;
+      case 0xA726:
+        bufpush(0xA727);
+        break;
+      case 0xA728:
+        bufpush(0xA729);
+        break;
+      case 0xA72A:
+        bufpush(0xA72B);
+        break;
+      case 0xA72C:
+        bufpush(0xA72D);
+        break;
+      case 0xA72E:
+        bufpush(0xA72F);
+        break;
+      case 0xA732:
+        bufpush(0xA733);
+        break;
+      case 0xA734:
+        bufpush(0xA735);
+        break;
+      case 0xA736:
+        bufpush(0xA737);
+        break;
+      case 0xA738:
+        bufpush(0xA739);
+        break;
+      case 0xA73A:
+        bufpush(0xA73B);
+        break;
+      case 0xA73C:
+        bufpush(0xA73D);
+        break;
+      case 0xA73E:
+        bufpush(0xA73F);
+        break;
+      case 0xA740:
+        bufpush(0xA741);
+        break;
+      case 0xA742:
+        bufpush(0xA743);
+        break;
+      case 0xA744:
+        bufpush(0xA745);
+        break;
+      case 0xA746:
+        bufpush(0xA747);
+        break;
+      case 0xA748:
+        bufpush(0xA749);
+        break;
+      case 0xA74A:
+        bufpush(0xA74B);
+        break;
+      case 0xA74C:
+        bufpush(0xA74D);
+        break;
+      case 0xA74E:
+        bufpush(0xA74F);
+        break;
+      case 0xA750:
+        bufpush(0xA751);
+        break;
+      case 0xA752:
+        bufpush(0xA753);
+        break;
+      case 0xA754:
+        bufpush(0xA755);
+        break;
+      case 0xA756:
+        bufpush(0xA757);
+        break;
+      case 0xA758:
+        bufpush(0xA759);
+        break;
+      case 0xA75A:
+        bufpush(0xA75B);
+        break;
+      case 0xA75C:
+        bufpush(0xA75D);
+        break;
+      case 0xA75E:
+        bufpush(0xA75F);
+        break;
+      case 0xA760:
+        bufpush(0xA761);
+        break;
+      case 0xA762:
+        bufpush(0xA763);
+        break;
+      case 0xA764:
+        bufpush(0xA765);
+        break;
+      case 0xA766:
+        bufpush(0xA767);
+        break;
+      case 0xA768:
+        bufpush(0xA769);
+        break;
+      case 0xA76A:
+        bufpush(0xA76B);
+        break;
+      case 0xA76C:
+        bufpush(0xA76D);
+        break;
+      case 0xA76E:
+        bufpush(0xA76F);
+        break;
+      case 0xA779:
+        bufpush(0xA77A);
+        break;
+      case 0xA77B:
+        bufpush(0xA77C);
+        break;
+      case 0xA77D:
+        bufpush(0x1D79);
+        break;
+      case 0xA77E:
+        bufpush(0xA77F);
+        break;
+      case 0xA780:
+        bufpush(0xA781);
+        break;
+      case 0xA782:
+        bufpush(0xA783);
+        break;
+      case 0xA784:
+        bufpush(0xA785);
+        break;
+      case 0xA786:
+        bufpush(0xA787);
+        break;
+      case 0xA78B:
+        bufpush(0xA78C);
+        break;
+      case 0xA78D:
+        bufpush(0x0265);
+        break;
+      case 0xA790:
+        bufpush(0xA791);
+        break;
+      case 0xA792:
+        bufpush(0xA793);
+        break;
+      case 0xA796:
+        bufpush(0xA797);
+        break;
+      case 0xA798:
+        bufpush(0xA799);
+        break;
+      case 0xA79A:
+        bufpush(0xA79B);
+        break;
+      case 0xA79C:
+        bufpush(0xA79D);
+        break;
+      case 0xA79E:
+        bufpush(0xA79F);
+        break;
+      case 0xA7A0:
+        bufpush(0xA7A1);
+        break;
+      case 0xA7A2:
+        bufpush(0xA7A3);
+        break;
+      case 0xA7A4:
+        bufpush(0xA7A5);
+        break;
+      case 0xA7A6:
+        bufpush(0xA7A7);
+        break;
+      case 0xA7A8:
+        bufpush(0xA7A9);
+        break;
+      case 0xA7AA:
+        bufpush(0x0266);
+        break;
+      case 0xA7AB:
+        bufpush(0x025C);
+        break;
+      case 0xA7AC:
+        bufpush(0x0261);
+        break;
+      case 0xA7AD:
+        bufpush(0x026C);
+        break;
+      case 0xA7AE:
+        bufpush(0x026A);
+        break;
+      case 0xA7B0:
+        bufpush(0x029E);
+        break;
+      case 0xA7B1:
+        bufpush(0x0287);
+        break;
+      case 0xA7B2:
+        bufpush(0x029D);
+        break;
+      case 0xA7B3:
+        bufpush(0xAB53);
+        break;
+      case 0xA7B4:
+        bufpush(0xA7B5);
+        break;
+      case 0xA7B6:
+        bufpush(0xA7B7);
+        break;
+      case 0xA7B8:
+        bufpush(0xA7B9);
+        break;
+      case 0xA7BA:
+        bufpush(0xA7BB);
+        break;
+      case 0xA7BC:
+        bufpush(0xA7BD);
+        break;
+      case 0xA7BE:
+        bufpush(0xA7BF);
+        break;
+      case 0xA7C2:
+        bufpush(0xA7C3);
+        break;
+      case 0xA7C4:
+        bufpush(0xA794);
+        break;
+      case 0xA7C5:
+        bufpush(0x0282);
+        break;
+      case 0xA7C6:
+        bufpush(0x1D8E);
+        break;
+      case 0xA7C7:
+        bufpush(0xA7C8);
+        break;
+      case 0xA7C9:
+        bufpush(0xA7CA);
+        break;
+      case 0xA7F5:
+        bufpush(0xA7F6);
+        break;
+      case 0xAB70:
+        bufpush(0x13A0);
+        break;
+      case 0xAB71:
+        bufpush(0x13A1);
+        break;
+      case 0xAB72:
+        bufpush(0x13A2);
+        break;
+      case 0xAB73:
+        bufpush(0x13A3);
+        break;
+      case 0xAB74:
+        bufpush(0x13A4);
+        break;
+      case 0xAB75:
+        bufpush(0x13A5);
+        break;
+      case 0xAB76:
+        bufpush(0x13A6);
+        break;
+      case 0xAB77:
+        bufpush(0x13A7);
+        break;
+      case 0xAB78:
+        bufpush(0x13A8);
+        break;
+      case 0xAB79:
+        bufpush(0x13A9);
+        break;
+      case 0xAB7A:
+        bufpush(0x13AA);
+        break;
+      case 0xAB7B:
+        bufpush(0x13AB);
+        break;
+      case 0xAB7C:
+        bufpush(0x13AC);
+        break;
+      case 0xAB7D:
+        bufpush(0x13AD);
+        break;
+      case 0xAB7E:
+        bufpush(0x13AE);
+        break;
+      case 0xAB7F:
+        bufpush(0x13AF);
+        break;
+      case 0xAB80:
+        bufpush(0x13B0);
+        break;
+      case 0xAB81:
+        bufpush(0x13B1);
+        break;
+      case 0xAB82:
+        bufpush(0x13B2);
+        break;
+      case 0xAB83:
+        bufpush(0x13B3);
+        break;
+      case 0xAB84:
+        bufpush(0x13B4);
+        break;
+      case 0xAB85:
+        bufpush(0x13B5);
+        break;
+      case 0xAB86:
+        bufpush(0x13B6);
+        break;
+      case 0xAB87:
+        bufpush(0x13B7);
+        break;
+      case 0xAB88:
+        bufpush(0x13B8);
+        break;
+      case 0xAB89:
+        bufpush(0x13B9);
+        break;
+      case 0xAB8A:
+        bufpush(0x13BA);
+        break;
+      case 0xAB8B:
+        bufpush(0x13BB);
+        break;
+      case 0xAB8C:
+        bufpush(0x13BC);
+        break;
+      case 0xAB8D:
+        bufpush(0x13BD);
+        break;
+      case 0xAB8E:
+        bufpush(0x13BE);
+        break;
+      case 0xAB8F:
+        bufpush(0x13BF);
+        break;
+      case 0xAB90:
+        bufpush(0x13C0);
+        break;
+      case 0xAB91:
+        bufpush(0x13C1);
+        break;
+      case 0xAB92:
+        bufpush(0x13C2);
+        break;
+      case 0xAB93:
+        bufpush(0x13C3);
+        break;
+      case 0xAB94:
+        bufpush(0x13C4);
+        break;
+      case 0xAB95:
+        bufpush(0x13C5);
+        break;
+      case 0xAB96:
+        bufpush(0x13C6);
+        break;
+      case 0xAB97:
+        bufpush(0x13C7);
+        break;
+      case 0xAB98:
+        bufpush(0x13C8);
+        break;
+      case 0xAB99:
+        bufpush(0x13C9);
+        break;
+      case 0xAB9A:
+        bufpush(0x13CA);
+        break;
+      case 0xAB9B:
+        bufpush(0x13CB);
+        break;
+      case 0xAB9C:
+        bufpush(0x13CC);
+        break;
+      case 0xAB9D:
+        bufpush(0x13CD);
+        break;
+      case 0xAB9E:
+        bufpush(0x13CE);
+        break;
+      case 0xAB9F:
+        bufpush(0x13CF);
+        break;
+      case 0xABA0:
+        bufpush(0x13D0);
+        break;
+      case 0xABA1:
+        bufpush(0x13D1);
+        break;
+      case 0xABA2:
+        bufpush(0x13D2);
+        break;
+      case 0xABA3:
+        bufpush(0x13D3);
+        break;
+      case 0xABA4:
+        bufpush(0x13D4);
+        break;
+      case 0xABA5:
+        bufpush(0x13D5);
+        break;
+      case 0xABA6:
+        bufpush(0x13D6);
+        break;
+      case 0xABA7:
+        bufpush(0x13D7);
+        break;
+      case 0xABA8:
+        bufpush(0x13D8);
+        break;
+      case 0xABA9:
+        bufpush(0x13D9);
+        break;
+      case 0xABAA:
+        bufpush(0x13DA);
+        break;
+      case 0xABAB:
+        bufpush(0x13DB);
+        break;
+      case 0xABAC:
+        bufpush(0x13DC);
+        break;
+      case 0xABAD:
+        bufpush(0x13DD);
+        break;
+      case 0xABAE:
+        bufpush(0x13DE);
+        break;
+      case 0xABAF:
+        bufpush(0x13DF);
+        break;
+      case 0xABB0:
+        bufpush(0x13E0);
+        break;
+      case 0xABB1:
+        bufpush(0x13E1);
+        break;
+      case 0xABB2:
+        bufpush(0x13E2);
+        break;
+      case 0xABB3:
+        bufpush(0x13E3);
+        break;
+      case 0xABB4:
+        bufpush(0x13E4);
+        break;
+      case 0xABB5:
+        bufpush(0x13E5);
+        break;
+      case 0xABB6:
+        bufpush(0x13E6);
+        break;
+      case 0xABB7:
+        bufpush(0x13E7);
+        break;
+      case 0xABB8:
+        bufpush(0x13E8);
+        break;
+      case 0xABB9:
+        bufpush(0x13E9);
+        break;
+      case 0xABBA:
+        bufpush(0x13EA);
+        break;
+      case 0xABBB:
+        bufpush(0x13EB);
+        break;
+      case 0xABBC:
+        bufpush(0x13EC);
+        break;
+      case 0xABBD:
+        bufpush(0x13ED);
+        break;
+      case 0xABBE:
+        bufpush(0x13EE);
+        break;
+      case 0xABBF:
+        bufpush(0x13EF);
+        break;
+      case 0xFB00:
+        bufpush(0x0066);
+        bufpush(0x0066);
+        break;
+      case 0xFB01:
+        bufpush(0x0066);
+        bufpush(0x0069);
+        break;
+      case 0xFB02:
+        bufpush(0x0066);
+        bufpush(0x006C);
+        break;
+      case 0xFB03:
+        bufpush(0x0066);
+        bufpush(0x0066);
+        bufpush(0x0069);
+        break;
+      case 0xFB04:
+        bufpush(0x0066);
+        bufpush(0x0066);
+        bufpush(0x006C);
+        break;
+      case 0xFB05:
+        bufpush(0x0073);
+        bufpush(0x0074);
+        break;
+      case 0xFB06:
+        bufpush(0x0073);
+        bufpush(0x0074);
+        break;
+      case 0xFB13:
+        bufpush(0x0574);
+        bufpush(0x0576);
+        break;
+      case 0xFB14:
+        bufpush(0x0574);
+        bufpush(0x0565);
+        break;
+      case 0xFB15:
+        bufpush(0x0574);
+        bufpush(0x056B);
+        break;
+      case 0xFB16:
+        bufpush(0x057E);
+        bufpush(0x0576);
+        break;
+      case 0xFB17:
+        bufpush(0x0574);
+        bufpush(0x056D);
+        break;
+      case 0xFF21:
+        bufpush(0xFF41);
+        break;
+      case 0xFF22:
+        bufpush(0xFF42);
+        break;
+      case 0xFF23:
+        bufpush(0xFF43);
+        break;
+      case 0xFF24:
+        bufpush(0xFF44);
+        break;
+      case 0xFF25:
+        bufpush(0xFF45);
+        break;
+      case 0xFF26:
+        bufpush(0xFF46);
+        break;
+      case 0xFF27:
+        bufpush(0xFF47);
+        break;
+      case 0xFF28:
+        bufpush(0xFF48);
+        break;
+      case 0xFF29:
+        bufpush(0xFF49);
+        break;
+      case 0xFF2A:
+        bufpush(0xFF4A);
+        break;
+      case 0xFF2B:
+        bufpush(0xFF4B);
+        break;
+      case 0xFF2C:
+        bufpush(0xFF4C);
+        break;
+      case 0xFF2D:
+        bufpush(0xFF4D);
+        break;
+      case 0xFF2E:
+        bufpush(0xFF4E);
+        break;
+      case 0xFF2F:
+        bufpush(0xFF4F);
+        break;
+      case 0xFF30:
+        bufpush(0xFF50);
+        break;
+      case 0xFF31:
+        bufpush(0xFF51);
+        break;
+      case 0xFF32:
+        bufpush(0xFF52);
+        break;
+      case 0xFF33:
+        bufpush(0xFF53);
+        break;
+      case 0xFF34:
+        bufpush(0xFF54);
+        break;
+      case 0xFF35:
+        bufpush(0xFF55);
+        break;
+      case 0xFF36:
+        bufpush(0xFF56);
+        break;
+      case 0xFF37:
+        bufpush(0xFF57);
+        break;
+      case 0xFF38:
+        bufpush(0xFF58);
+        break;
+      case 0xFF39:
+        bufpush(0xFF59);
+        break;
+      case 0xFF3A:
+        bufpush(0xFF5A);
+        break;
+      case 0x10400:
+        bufpush(0x10428);
+        break;
+      case 0x10401:
+        bufpush(0x10429);
+        break;
+      case 0x10402:
+        bufpush(0x1042A);
+        break;
+      case 0x10403:
+        bufpush(0x1042B);
+        break;
+      case 0x10404:
+        bufpush(0x1042C);
+        break;
+      case 0x10405:
+        bufpush(0x1042D);
+        break;
+      case 0x10406:
+        bufpush(0x1042E);
+        break;
+      case 0x10407:
+        bufpush(0x1042F);
+        break;
+      case 0x10408:
+        bufpush(0x10430);
+        break;
+      case 0x10409:
+        bufpush(0x10431);
+        break;
+      case 0x1040A:
+        bufpush(0x10432);
+        break;
+      case 0x1040B:
+        bufpush(0x10433);
+        break;
+      case 0x1040C:
+        bufpush(0x10434);
+        break;
+      case 0x1040D:
+        bufpush(0x10435);
+        break;
+      case 0x1040E:
+        bufpush(0x10436);
+        break;
+      case 0x1040F:
+        bufpush(0x10437);
+        break;
+      case 0x10410:
+        bufpush(0x10438);
+        break;
+      case 0x10411:
+        bufpush(0x10439);
+        break;
+      case 0x10412:
+        bufpush(0x1043A);
+        break;
+      case 0x10413:
+        bufpush(0x1043B);
+        break;
+      case 0x10414:
+        bufpush(0x1043C);
+        break;
+      case 0x10415:
+        bufpush(0x1043D);
+        break;
+      case 0x10416:
+        bufpush(0x1043E);
+        break;
+      case 0x10417:
+        bufpush(0x1043F);
+        break;
+      case 0x10418:
+        bufpush(0x10440);
+        break;
+      case 0x10419:
+        bufpush(0x10441);
+        break;
+      case 0x1041A:
+        bufpush(0x10442);
+        break;
+      case 0x1041B:
+        bufpush(0x10443);
+        break;
+      case 0x1041C:
+        bufpush(0x10444);
+        break;
+      case 0x1041D:
+        bufpush(0x10445);
+        break;
+      case 0x1041E:
+        bufpush(0x10446);
+        break;
+      case 0x1041F:
+        bufpush(0x10447);
+        break;
+      case 0x10420:
+        bufpush(0x10448);
+        break;
+      case 0x10421:
+        bufpush(0x10449);
+        break;
+      case 0x10422:
+        bufpush(0x1044A);
+        break;
+      case 0x10423:
+        bufpush(0x1044B);
+        break;
+      case 0x10424:
+        bufpush(0x1044C);
+        break;
+      case 0x10425:
+        bufpush(0x1044D);
+        break;
+      case 0x10426:
+        bufpush(0x1044E);
+        break;
+      case 0x10427:
+        bufpush(0x1044F);
+        break;
+      case 0x104B0:
+        bufpush(0x104D8);
+        break;
+      case 0x104B1:
+        bufpush(0x104D9);
+        break;
+      case 0x104B2:
+        bufpush(0x104DA);
+        break;
+      case 0x104B3:
+        bufpush(0x104DB);
+        break;
+      case 0x104B4:
+        bufpush(0x104DC);
+        break;
+      case 0x104B5:
+        bufpush(0x104DD);
+        break;
+      case 0x104B6:
+        bufpush(0x104DE);
+        break;
+      case 0x104B7:
+        bufpush(0x104DF);
+        break;
+      case 0x104B8:
+        bufpush(0x104E0);
+        break;
+      case 0x104B9:
+        bufpush(0x104E1);
+        break;
+      case 0x104BA:
+        bufpush(0x104E2);
+        break;
+      case 0x104BB:
+        bufpush(0x104E3);
+        break;
+      case 0x104BC:
+        bufpush(0x104E4);
+        break;
+      case 0x104BD:
+        bufpush(0x104E5);
+        break;
+      case 0x104BE:
+        bufpush(0x104E6);
+        break;
+      case 0x104BF:
+        bufpush(0x104E7);
+        break;
+      case 0x104C0:
+        bufpush(0x104E8);
+        break;
+      case 0x104C1:
+        bufpush(0x104E9);
+        break;
+      case 0x104C2:
+        bufpush(0x104EA);
+        break;
+      case 0x104C3:
+        bufpush(0x104EB);
+        break;
+      case 0x104C4:
+        bufpush(0x104EC);
+        break;
+      case 0x104C5:
+        bufpush(0x104ED);
+        break;
+      case 0x104C6:
+        bufpush(0x104EE);
+        break;
+      case 0x104C7:
+        bufpush(0x104EF);
+        break;
+      case 0x104C8:
+        bufpush(0x104F0);
+        break;
+      case 0x104C9:
+        bufpush(0x104F1);
+        break;
+      case 0x104CA:
+        bufpush(0x104F2);
+        break;
+      case 0x104CB:
+        bufpush(0x104F3);
+        break;
+      case 0x104CC:
+        bufpush(0x104F4);
+        break;
+      case 0x104CD:
+        bufpush(0x104F5);
+        break;
+      case 0x104CE:
+        bufpush(0x104F6);
+        break;
+      case 0x104CF:
+        bufpush(0x104F7);
+        break;
+      case 0x104D0:
+        bufpush(0x104F8);
+        break;
+      case 0x104D1:
+        bufpush(0x104F9);
+        break;
+      case 0x104D2:
+        bufpush(0x104FA);
+        break;
+      case 0x104D3:
+        bufpush(0x104FB);
+        break;
+      case 0x10C80:
+        bufpush(0x10CC0);
+        break;
+      case 0x10C81:
+        bufpush(0x10CC1);
+        break;
+      case 0x10C82:
+        bufpush(0x10CC2);
+        break;
+      case 0x10C83:
+        bufpush(0x10CC3);
+        break;
+      case 0x10C84:
+        bufpush(0x10CC4);
+        break;
+      case 0x10C85:
+        bufpush(0x10CC5);
+        break;
+      case 0x10C86:
+        bufpush(0x10CC6);
+        break;
+      case 0x10C87:
+        bufpush(0x10CC7);
+        break;
+      case 0x10C88:
+        bufpush(0x10CC8);
+        break;
+      case 0x10C89:
+        bufpush(0x10CC9);
+        break;
+      case 0x10C8A:
+        bufpush(0x10CCA);
+        break;
+      case 0x10C8B:
+        bufpush(0x10CCB);
+        break;
+      case 0x10C8C:
+        bufpush(0x10CCC);
+        break;
+      case 0x10C8D:
+        bufpush(0x10CCD);
+        break;
+      case 0x10C8E:
+        bufpush(0x10CCE);
+        break;
+      case 0x10C8F:
+        bufpush(0x10CCF);
+        break;
+      case 0x10C90:
+        bufpush(0x10CD0);
+        break;
+      case 0x10C91:
+        bufpush(0x10CD1);
+        break;
+      case 0x10C92:
+        bufpush(0x10CD2);
+        break;
+      case 0x10C93:
+        bufpush(0x10CD3);
+        break;
+      case 0x10C94:
+        bufpush(0x10CD4);
+        break;
+      case 0x10C95:
+        bufpush(0x10CD5);
+        break;
+      case 0x10C96:
+        bufpush(0x10CD6);
+        break;
+      case 0x10C97:
+        bufpush(0x10CD7);
+        break;
+      case 0x10C98:
+        bufpush(0x10CD8);
+        break;
+      case 0x10C99:
+        bufpush(0x10CD9);
+        break;
+      case 0x10C9A:
+        bufpush(0x10CDA);
+        break;
+      case 0x10C9B:
+        bufpush(0x10CDB);
+        break;
+      case 0x10C9C:
+        bufpush(0x10CDC);
+        break;
+      case 0x10C9D:
+        bufpush(0x10CDD);
+        break;
+      case 0x10C9E:
+        bufpush(0x10CDE);
+        break;
+      case 0x10C9F:
+        bufpush(0x10CDF);
+        break;
+      case 0x10CA0:
+        bufpush(0x10CE0);
+        break;
+      case 0x10CA1:
+        bufpush(0x10CE1);
+        break;
+      case 0x10CA2:
+        bufpush(0x10CE2);
+        break;
+      case 0x10CA3:
+        bufpush(0x10CE3);
+        break;
+      case 0x10CA4:
+        bufpush(0x10CE4);
+        break;
+      case 0x10CA5:
+        bufpush(0x10CE5);
+        break;
+      case 0x10CA6:
+        bufpush(0x10CE6);
+        break;
+      case 0x10CA7:
+        bufpush(0x10CE7);
+        break;
+      case 0x10CA8:
+        bufpush(0x10CE8);
+        break;
+      case 0x10CA9:
+        bufpush(0x10CE9);
+        break;
+      case 0x10CAA:
+        bufpush(0x10CEA);
+        break;
+      case 0x10CAB:
+        bufpush(0x10CEB);
+        break;
+      case 0x10CAC:
+        bufpush(0x10CEC);
+        break;
+      case 0x10CAD:
+        bufpush(0x10CED);
+        break;
+      case 0x10CAE:
+        bufpush(0x10CEE);
+        break;
+      case 0x10CAF:
+        bufpush(0x10CEF);
+        break;
+      case 0x10CB0:
+        bufpush(0x10CF0);
+        break;
+      case 0x10CB1:
+        bufpush(0x10CF1);
+        break;
+      case 0x10CB2:
+        bufpush(0x10CF2);
+        break;
+      case 0x118A0:
+        bufpush(0x118C0);
+        break;
+      case 0x118A1:
+        bufpush(0x118C1);
+        break;
+      case 0x118A2:
+        bufpush(0x118C2);
+        break;
+      case 0x118A3:
+        bufpush(0x118C3);
+        break;
+      case 0x118A4:
+        bufpush(0x118C4);
+        break;
+      case 0x118A5:
+        bufpush(0x118C5);
+        break;
+      case 0x118A6:
+        bufpush(0x118C6);
+        break;
+      case 0x118A7:
+        bufpush(0x118C7);
+        break;
+      case 0x118A8:
+        bufpush(0x118C8);
+        break;
+      case 0x118A9:
+        bufpush(0x118C9);
+        break;
+      case 0x118AA:
+        bufpush(0x118CA);
+        break;
+      case 0x118AB:
+        bufpush(0x118CB);
+        break;
+      case 0x118AC:
+        bufpush(0x118CC);
+        break;
+      case 0x118AD:
+        bufpush(0x118CD);
+        break;
+      case 0x118AE:
+        bufpush(0x118CE);
+        break;
+      case 0x118AF:
+        bufpush(0x118CF);
+        break;
+      case 0x118B0:
+        bufpush(0x118D0);
+        break;
+      case 0x118B1:
+        bufpush(0x118D1);
+        break;
+      case 0x118B2:
+        bufpush(0x118D2);
+        break;
+      case 0x118B3:
+        bufpush(0x118D3);
+        break;
+      case 0x118B4:
+        bufpush(0x118D4);
+        break;
+      case 0x118B5:
+        bufpush(0x118D5);
+        break;
+      case 0x118B6:
+        bufpush(0x118D6);
+        break;
+      case 0x118B7:
+        bufpush(0x118D7);
+        break;
+      case 0x118B8:
+        bufpush(0x118D8);
+        break;
+      case 0x118B9:
+        bufpush(0x118D9);
+        break;
+      case 0x118BA:
+        bufpush(0x118DA);
+        break;
+      case 0x118BB:
+        bufpush(0x118DB);
+        break;
+      case 0x118BC:
+        bufpush(0x118DC);
+        break;
+      case 0x118BD:
+        bufpush(0x118DD);
+        break;
+      case 0x118BE:
+        bufpush(0x118DE);
+        break;
+      case 0x118BF:
+        bufpush(0x118DF);
+        break;
+      case 0x16E40:
+        bufpush(0x16E60);
+        break;
+      case 0x16E41:
+        bufpush(0x16E61);
+        break;
+      case 0x16E42:
+        bufpush(0x16E62);
+        break;
+      case 0x16E43:
+        bufpush(0x16E63);
+        break;
+      case 0x16E44:
+        bufpush(0x16E64);
+        break;
+      case 0x16E45:
+        bufpush(0x16E65);
+        break;
+      case 0x16E46:
+        bufpush(0x16E66);
+        break;
+      case 0x16E47:
+        bufpush(0x16E67);
+        break;
+      case 0x16E48:
+        bufpush(0x16E68);
+        break;
+      case 0x16E49:
+        bufpush(0x16E69);
+        break;
+      case 0x16E4A:
+        bufpush(0x16E6A);
+        break;
+      case 0x16E4B:
+        bufpush(0x16E6B);
+        break;
+      case 0x16E4C:
+        bufpush(0x16E6C);
+        break;
+      case 0x16E4D:
+        bufpush(0x16E6D);
+        break;
+      case 0x16E4E:
+        bufpush(0x16E6E);
+        break;
+      case 0x16E4F:
+        bufpush(0x16E6F);
+        break;
+      case 0x16E50:
+        bufpush(0x16E70);
+        break;
+      case 0x16E51:
+        bufpush(0x16E71);
+        break;
+      case 0x16E52:
+        bufpush(0x16E72);
+        break;
+      case 0x16E53:
+        bufpush(0x16E73);
+        break;
+      case 0x16E54:
+        bufpush(0x16E74);
+        break;
+      case 0x16E55:
+        bufpush(0x16E75);
+        break;
+      case 0x16E56:
+        bufpush(0x16E76);
+        break;
+      case 0x16E57:
+        bufpush(0x16E77);
+        break;
+      case 0x16E58:
+        bufpush(0x16E78);
+        break;
+      case 0x16E59:
+        bufpush(0x16E79);
+        break;
+      case 0x16E5A:
+        bufpush(0x16E7A);
+        break;
+      case 0x16E5B:
+        bufpush(0x16E7B);
+        break;
+      case 0x16E5C:
+        bufpush(0x16E7C);
+        break;
+      case 0x16E5D:
+        bufpush(0x16E7D);
+        break;
+      case 0x16E5E:
+        bufpush(0x16E7E);
+        break;
+      case 0x16E5F:
+        bufpush(0x16E7F);
+        break;
+      case 0x1E900:
+        bufpush(0x1E922);
+        break;
+      case 0x1E901:
+        bufpush(0x1E923);
+        break;
+      case 0x1E902:
+        bufpush(0x1E924);
+        break;
+      case 0x1E903:
+        bufpush(0x1E925);
+        break;
+      case 0x1E904:
+        bufpush(0x1E926);
+        break;
+      case 0x1E905:
+        bufpush(0x1E927);
+        break;
+      case 0x1E906:
+        bufpush(0x1E928);
+        break;
+      case 0x1E907:
+        bufpush(0x1E929);
+        break;
+      case 0x1E908:
+        bufpush(0x1E92A);
+        break;
+      case 0x1E909:
+        bufpush(0x1E92B);
+        break;
+      case 0x1E90A:
+        bufpush(0x1E92C);
+        break;
+      case 0x1E90B:
+        bufpush(0x1E92D);
+        break;
+      case 0x1E90C:
+        bufpush(0x1E92E);
+        break;
+      case 0x1E90D:
+        bufpush(0x1E92F);
+        break;
+      case 0x1E90E:
+        bufpush(0x1E930);
+        break;
+      case 0x1E90F:
+        bufpush(0x1E931);
+        break;
+      case 0x1E910:
+        bufpush(0x1E932);
+        break;
+      case 0x1E911:
+        bufpush(0x1E933);
+        break;
+      case 0x1E912:
+        bufpush(0x1E934);
+        break;
+      case 0x1E913:
+        bufpush(0x1E935);
+        break;
+      case 0x1E914:
+        bufpush(0x1E936);
+        break;
+      case 0x1E915:
+        bufpush(0x1E937);
+        break;
+      case 0x1E916:
+        bufpush(0x1E938);
+        break;
+      case 0x1E917:
+        bufpush(0x1E939);
+        break;
+      case 0x1E918:
+        bufpush(0x1E93A);
+        break;
+      case 0x1E919:
+        bufpush(0x1E93B);
+        break;
+      case 0x1E91A:
+        bufpush(0x1E93C);
+        break;
+      case 0x1E91B:
+        bufpush(0x1E93D);
+        break;
+      case 0x1E91C:
+        bufpush(0x1E93E);
+        break;
+      case 0x1E91D:
+        bufpush(0x1E93F);
+        break;
+      case 0x1E91E:
+        bufpush(0x1E940);
+        break;
+      case 0x1E91F:
+        bufpush(0x1E941);
+        break;
+      case 0x1E920:
+        bufpush(0x1E942);
+        break;
+      case 0x1E921:
+        bufpush(0x1E943);
+        break;
+      default:
+        bufpush(c);
+    }
diff --git a/lib/cmark/src/chunk.h b/lib/cmark/src/chunk.h
new file mode 100644
index 0000000..bf3c42e
--- /dev/null
+++ b/lib/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 CMARK_INLINE void cmark_chunk_free(cmark_chunk *c) {
+  c->data = NULL;
+  c->len = 0;
+}
+
+static CMARK_INLINE void cmark_chunk_ltrim(cmark_chunk *c) {
+  while (c->len && cmark_isspace(c->data[0])) {
+    c->data++;
+    c->len--;
+  }
+}
+
+static CMARK_INLINE void cmark_chunk_rtrim(cmark_chunk *c) {
+  while (c->len > 0) {
+    if (!cmark_isspace(c->data[c->len - 1]))
+      break;
+
+    c->len--;
+  }
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static CMARK_INLINE void cmark_chunk_trim(cmark_chunk *c) {
+  cmark_chunk_ltrim(c);
+  cmark_chunk_rtrim(c);
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static CMARK_INLINE bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c,
+                                                 bufsize_t offset) {
+  const unsigned char *p =
+      (unsigned char *)memchr(ch->data + offset, c, ch->len - offset);
+  return p ? (bufsize_t)(p - ch->data) : ch->len;
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static CMARK_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 CMARK_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/lib/cmark/src/cmark.c b/lib/cmark/src/cmark.c
new file mode 100644
index 0000000..8bbca03
--- /dev/null
+++ b/lib/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() { return CMARK_VERSION; }
+
+const char *cmark_version_string() { return CMARK_VERSION_STRING; }
+
+static void *xcalloc(size_t nmem, size_t size) {
+  void *ptr = calloc(nmem, size);
+  if (!ptr) {
+    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() {
+  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/lib/cmark/src/cmark.h b/lib/cmark/src/cmark.h
new file mode 100644
index 0000000..a37c185
--- /dev/null
+++ b/lib/cmark/src/cmark.h
@@ -0,0 +1,654 @@
+#ifndef CMARK_H
+#define CMARK_H
+
+#include <stdio.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();
+
+/**
+ * ## 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
+ */
+CMARK_EXPORT
+cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem);
+
+/** 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/lib/cmark/src/cmarkConfig.cmake.in b/lib/cmark/src/cmarkConfig.cmake.in
new file mode 100644
index 0000000..37884c0
--- /dev/null
+++ b/lib/cmark/src/cmarkConfig.cmake.in
@@ -0,0 +1,7 @@
+set(HAVE_LIBCMARK_STATIC @CMARK_STATIC@)
+set(HAVE_LIBCMARK_SHARED @CMARK_SHARED@)
+
+if((HAVE_LIBCMARK_STATIC AND NOT TARGET libcmark_static) OR
+   (HAVE_LIBCMARK_SHARED AND NOT TARGET libcmark))
+   include(@CMARK_TARGETS_FILE@)
+endif()
diff --git a/lib/cmark/src/cmark_ctype.c b/lib/cmark/src/cmark_ctype.c
new file mode 100644
index 0000000..c0c4d5b
--- /dev/null
+++ b/lib/cmark/src/cmark_ctype.c
@@ -0,0 +1,44 @@
+#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, 0, 0, 1, 0, 0,
+    /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 2 */ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    /* 3 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2,
+    /* 4 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    /* 5 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2,
+    /* 6 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    /* 7 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0,
+    /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* c */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* d */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* e */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+/**
+ * Returns 1 if c is a "whitespace" character as defined by the spec.
+ */
+int cmark_isspace(char c) { return cmark_ctype_class[(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_isalnum(char c) {
+  uint8_t result;
+  result = cmark_ctype_class[(uint8_t)c];
+  return (result == 3 || result == 4);
+}
+
+int cmark_isdigit(char c) { return cmark_ctype_class[(uint8_t)c] == 3; }
+
+int cmark_isalpha(char c) { return cmark_ctype_class[(uint8_t)c] == 4; }
diff --git a/lib/cmark/src/cmark_ctype.h b/lib/cmark/src/cmark_ctype.h
new file mode 100644
index 0000000..9a07618
--- /dev/null
+++ b/lib/cmark/src/cmark_ctype.h
@@ -0,0 +1,26 @@
+#ifndef CMARK_CMARK_CTYPE_H
+#define CMARK_CMARK_CTYPE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Locale-independent versions of functions from ctype.h.
+ * We want cmark to behave the same no matter what the system locale.
+ */
+
+int cmark_isspace(char c);
+
+int cmark_ispunct(char c);
+
+int cmark_isalnum(char c);
+
+int cmark_isdigit(char c);
+
+int cmark_isalpha(char c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/cmark/src/cmark_version.h.in b/lib/cmark/src/cmark_version.h.in
new file mode 100644
index 0000000..41de3ac
--- /dev/null
+++ b/lib/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/lib/cmark/src/commonmark.c b/lib/cmark/src/commonmark.c
new file mode 100644
index 0000000..8f5bd8f
--- /dev/null
+++ b/lib/cmark/src/commonmark.c
@@ -0,0 +1,480 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <assert.h>
+
+#include "config.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 CMARK_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 == '!' ||
+         (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 += 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;
+}
+
+// if node is a block node, returns node.
+// otherwise returns first block-level node that is an ancestor of node.
+// if there is no block-level ancestor, returns NULL.
+static cmark_node *get_containing_block(cmark_node *node) {
+  while (node) {
+    if (node->type >= CMARK_NODE_FIRST_BLOCK &&
+        node->type <= CMARK_NODE_LAST_BLOCK) {
+      return node;
+    } else {
+      node = node->parent;
+    }
+  }
+  return NULL;
+}
+
+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 loose the blank line between a paragraph and
+  // a following list.
+  if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && entering)) {
+    tmp = get_containing_block(node);
+    renderer->in_tight_list_item =
+        tmp && // tmp might be NULL if there is no containing block
+        ((tmp->type == CMARK_NODE_ITEM &&
+          cmark_node_get_list_tight(tmp->parent)) ||
+         (tmp && tmp->parent && tmp->parent->type == CMARK_NODE_ITEM &&
+          cmark_node_get_list_tight(tmp->parent->parent)));
+  }
+
+  switch (node->type) {
+  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 = 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;
+      }
+      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/lib/cmark/src/config.h.in b/lib/cmark/src/config.h.in
new file mode 100644
index 0000000..de1a4dd
--- /dev/null
+++ b/lib/cmark/src/config.h.in
@@ -0,0 +1,76 @@
+#ifndef CMARK_CONFIG_H
+#define CMARK_CONFIG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#cmakedefine HAVE_STDBOOL_H
+
+#ifdef HAVE_STDBOOL_H
+  #include <stdbool.h>
+#elif !defined(__cplusplus)
+  typedef char bool;
+#endif
+
+#cmakedefine HAVE___BUILTIN_EXPECT
+
+#cmakedefine HAVE___ATTRIBUTE__
+
+#ifdef HAVE___ATTRIBUTE__
+  #define CMARK_ATTRIBUTE(list) __attribute__ (list)
+#else
+  #define CMARK_ATTRIBUTE(list)
+#endif
+
+#ifndef CMARK_INLINE
+  #if defined(_MSC_VER) && !defined(__cplusplus)
+    #define CMARK_INLINE __inline
+  #else
+    #define CMARK_INLINE inline
+  #endif
+#endif
+
+/* snprintf and vsnprintf fallbacks for MSVC before 2015,
+   due to Valentin Milea http://stackoverflow.com/questions/2915672/
+*/
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#define snprintf c99_snprintf
+#define vsnprintf c99_vsnprintf
+
+CMARK_INLINE int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap)
+{
+    int count = -1;
+
+    if (size != 0)
+        count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
+    if (count == -1)
+        count = _vscprintf(format, ap);
+
+    return count;
+}
+
+CMARK_INLINE int c99_snprintf(char *outBuf, size_t size, const char *format, ...)
+{
+    int count;
+    va_list ap;
+
+    va_start(ap, format);
+    count = c99_vsnprintf(outBuf, size, format, ap);
+    va_end(ap);
+
+    return count;
+}
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/cmark/src/entities.inc b/lib/cmark/src/entities.inc
new file mode 100644
index 0000000..a7c36e2
--- /dev/null
+++ b/lib/cmark/src/entities.inc
@@ -0,0 +1,2138 @@
+/* Autogenerated by tools/make_headers_inc.py */
+
+struct cmark_entity_node {
+	unsigned char *entity;
+        unsigned char bytes[8];
+};
+
+#define CMARK_ENTITY_MIN_LENGTH 2
+#define CMARK_ENTITY_MAX_LENGTH 32
+#define CMARK_NUM_ENTITIES 2125
+
+static const struct cmark_entity_node cmark_entities[] = {
+{(unsigned char*)"AElig", {195, 134, 0}},
+{(unsigned char*)"AMP", {38, 0}},
+{(unsigned char*)"Aacute", {195, 129, 0}},
+{(unsigned char*)"Abreve", {196, 130, 0}},
+{(unsigned char*)"Acirc", {195, 130, 0}},
+{(unsigned char*)"Acy", {208, 144, 0}},
+{(unsigned char*)"Afr", {240, 157, 148, 132, 0}},
+{(unsigned char*)"Agrave", {195, 128, 0}},
+{(unsigned char*)"Alpha", {206, 145, 0}},
+{(unsigned char*)"Amacr", {196, 128, 0}},
+{(unsigned char*)"And", {226, 169, 147, 0}},
+{(unsigned char*)"Aogon", {196, 132, 0}},
+{(unsigned char*)"Aopf", {240, 157, 148, 184, 0}},
+{(unsigned char*)"ApplyFunction", {226, 129, 161, 0}},
+{(unsigned char*)"Aring", {195, 133, 0}},
+{(unsigned char*)"Ascr", {240, 157, 146, 156, 0}},
+{(unsigned char*)"Assign", {226, 137, 148, 0}},
+{(unsigned char*)"Atilde", {195, 131, 0}},
+{(unsigned char*)"Auml", {195, 132, 0}},
+{(unsigned char*)"Backslash", {226, 136, 150, 0}},
+{(unsigned char*)"Barv", {226, 171, 167, 0}},
+{(unsigned char*)"Barwed", {226, 140, 134, 0}},
+{(unsigned char*)"Bcy", {208, 145, 0}},
+{(unsigned char*)"Because", {226, 136, 181, 0}},
+{(unsigned char*)"Bernoullis", {226, 132, 172, 0}},
+{(unsigned char*)"Beta", {206, 146, 0}},
+{(unsigned char*)"Bfr", {240, 157, 148, 133, 0}},
+{(unsigned char*)"Bopf", {240, 157, 148, 185, 0}},
+{(unsigned char*)"Breve", {203, 152, 0}},
+{(unsigned char*)"Bscr", {226, 132, 172, 0}},
+{(unsigned char*)"Bumpeq", {226, 137, 142, 0}},
+{(unsigned char*)"CHcy", {208, 167, 0}},
+{(unsigned char*)"COPY", {194, 169, 0}},
+{(unsigned char*)"Cacute", {196, 134, 0}},
+{(unsigned char*)"Cap", {226, 139, 146, 0}},
+{(unsigned char*)"CapitalDifferentialD", {226, 133, 133, 0}},
+{(unsigned char*)"Cayleys", {226, 132, 173, 0}},
+{(unsigned char*)"Ccaron", {196, 140, 0}},
+{(unsigned char*)"Ccedil", {195, 135, 0}},
+{(unsigned char*)"Ccirc", {196, 136, 0}},
+{(unsigned char*)"Cconint", {226, 136, 176, 0}},
+{(unsigned char*)"Cdot", {196, 138, 0}},
+{(unsigned char*)"Cedilla", {194, 184, 0}},
+{(unsigned char*)"CenterDot", {194, 183, 0}},
+{(unsigned char*)"Cfr", {226, 132, 173, 0}},
+{(unsigned char*)"Chi", {206, 167, 0}},
+{(unsigned char*)"CircleDot", {226, 138, 153, 0}},
+{(unsigned char*)"CircleMinus", {226, 138, 150, 0}},
+{(unsigned char*)"CirclePlus", {226, 138, 149, 0}},
+{(unsigned char*)"CircleTimes", {226, 138, 151, 0}},
+{(unsigned char*)"ClockwiseContourIntegral", {226, 136, 178, 0}},
+{(unsigned char*)"CloseCurlyDoubleQuote", {226, 128, 157, 0}},
+{(unsigned char*)"CloseCurlyQuote", {226, 128, 153, 0}},
+{(unsigned char*)"Colon", {226, 136, 183, 0}},
+{(unsigned char*)"Colone", {226, 169, 180, 0}},
+{(unsigned char*)"Congruent", {226, 137, 161, 0}},
+{(unsigned char*)"Conint", {226, 136, 175, 0}},
+{(unsigned char*)"ContourIntegral", {226, 136, 174, 0}},
+{(unsigned char*)"Copf", {226, 132, 130, 0}},
+{(unsigned char*)"Coproduct", {226, 136, 144, 0}},
+{(unsigned char*)"CounterClockwiseContourIntegral", {226, 136, 179, 0}},
+{(unsigned char*)"Cross", {226, 168, 175, 0}},
+{(unsigned char*)"Cscr", {240, 157, 146, 158, 0}},
+{(unsigned char*)"Cup", {226, 139, 147, 0}},
+{(unsigned char*)"CupCap", {226, 137, 141, 0}},
+{(unsigned char*)"DD", {226, 133, 133, 0}},
+{(unsigned char*)"DDotrahd", {226, 164, 145, 0}},
+{(unsigned char*)"DJcy", {208, 130, 0}},
+{(unsigned char*)"DScy", {208, 133, 0}},
+{(unsigned char*)"DZcy", {208, 143, 0}},
+{(unsigned char*)"Dagger", {226, 128, 161, 0}},
+{(unsigned char*)"Darr", {226, 134, 161, 0}},
+{(unsigned char*)"Dashv", {226, 171, 164, 0}},
+{(unsigned char*)"Dcaron", {196, 142, 0}},
+{(unsigned char*)"Dcy", {208, 148, 0}},
+{(unsigned char*)"Del", {226, 136, 135, 0}},
+{(unsigned char*)"Delta", {206, 148, 0}},
+{(unsigned char*)"Dfr", {240, 157, 148, 135, 0}},
+{(unsigned char*)"DiacriticalAcute", {194, 180, 0}},
+{(unsigned char*)"DiacriticalDot", {203, 153, 0}},
+{(unsigned char*)"DiacriticalDoubleAcute", {203, 157, 0}},
+{(unsigned char*)"DiacriticalGrave", {96, 0}},
+{(unsigned char*)"DiacriticalTilde", {203, 156, 0}},
+{(unsigned char*)"Diamond", {226, 139, 132, 0}},
+{(unsigned char*)"DifferentialD", {226, 133, 134, 0}},
+{(unsigned char*)"Dopf", {240, 157, 148, 187, 0}},
+{(unsigned char*)"Dot", {194, 168, 0}},
+{(unsigned char*)"DotDot", {226, 131, 156, 0}},
+{(unsigned char*)"DotEqual", {226, 137, 144, 0}},
+{(unsigned char*)"DoubleContourIntegral", {226, 136, 175, 0}},
+{(unsigned char*)"DoubleDot", {194, 168, 0}},
+{(unsigned char*)"DoubleDownArrow", {226, 135, 147, 0}},
+{(unsigned char*)"DoubleLeftArrow", {226, 135, 144, 0}},
+{(unsigned char*)"DoubleLeftRightArrow", {226, 135, 148, 0}},
+{(unsigned char*)"DoubleLeftTee", {226, 171, 164, 0}},
+{(unsigned char*)"DoubleLongLeftArrow", {226, 159, 184, 0}},
+{(unsigned char*)"DoubleLongLeftRightArrow", {226, 159, 186, 0}},
+{(unsigned char*)"DoubleLongRightArrow", {226, 159, 185, 0}},
+{(unsigned char*)"DoubleRightArrow", {226, 135, 146, 0}},
+{(unsigned char*)"DoubleRightTee", {226, 138, 168, 0}},
+{(unsigned char*)"DoubleUpArrow", {226, 135, 145, 0}},
+{(unsigned char*)"DoubleUpDownArrow", {226, 135, 149, 0}},
+{(unsigned char*)"DoubleVerticalBar", {226, 136, 165, 0}},
+{(unsigned char*)"DownArrow", {226, 134, 147, 0}},
+{(unsigned char*)"DownArrowBar", {226, 164, 147, 0}},
+{(unsigned char*)"DownArrowUpArrow", {226, 135, 181, 0}},
+{(unsigned char*)"DownBreve", {204, 145, 0}},
+{(unsigned char*)"DownLeftRightVector", {226, 165, 144, 0}},
+{(unsigned char*)"DownLeftTeeVector", {226, 165, 158, 0}},
+{(unsigned char*)"DownLeftVector", {226, 134, 189, 0}},
+{(unsigned char*)"DownLeftVectorBar", {226, 165, 150, 0}},
+{(unsigned char*)"DownRightTeeVector", {226, 165, 159, 0}},
+{(unsigned char*)"DownRightVector", {226, 135, 129, 0}},
+{(unsigned char*)"DownRightVectorBar", {226, 165, 151, 0}},
+{(unsigned char*)"DownTee", {226, 138, 164, 0}},
+{(unsigned char*)"DownTeeArrow", {226, 134, 167, 0}},
+{(unsigned char*)"Downarrow", {226, 135, 147, 0}},
+{(unsigned char*)"Dscr", {240, 157, 146, 159, 0}},
+{(unsigned char*)"Dstrok", {196, 144, 0}},
+{(unsigned char*)"ENG", {197, 138, 0}},
+{(unsigned char*)"ETH", {195, 144, 0}},
+{(unsigned char*)"Eacute", {195, 137, 0}},
+{(unsigned char*)"Ecaron", {196, 154, 0}},
+{(unsigned char*)"Ecirc", {195, 138, 0}},
+{(unsigned char*)"Ecy", {208, 173, 0}},
+{(unsigned char*)"Edot", {196, 150, 0}},
+{(unsigned char*)"Efr", {240, 157, 148, 136, 0}},
+{(unsigned char*)"Egrave", {195, 136, 0}},
+{(unsigned char*)"Element", {226, 136, 136, 0}},
+{(unsigned char*)"Emacr", {196, 146, 0}},
+{(unsigned char*)"EmptySmallSquare", {226, 151, 187, 0}},
+{(unsigned char*)"EmptyVerySmallSquare", {226, 150, 171, 0}},
+{(unsigned char*)"Eogon", {196, 152, 0}},
+{(unsigned char*)"Eopf", {240, 157, 148, 188, 0}},
+{(unsigned char*)"Epsilon", {206, 149, 0}},
+{(unsigned char*)"Equal", {226, 169, 181, 0}},
+{(unsigned char*)"EqualTilde", {226, 137, 130, 0}},
+{(unsigned char*)"Equilibrium", {226, 135, 140, 0}},
+{(unsigned char*)"Escr", {226, 132, 176, 0}},
+{(unsigned char*)"Esim", {226, 169, 179, 0}},
+{(unsigned char*)"Eta", {206, 151, 0}},
+{(unsigned char*)"Euml", {195, 139, 0}},
+{(unsigned char*)"Exists", {226, 136, 131, 0}},
+{(unsigned char*)"ExponentialE", {226, 133, 135, 0}},
+{(unsigned char*)"Fcy", {208, 164, 0}},
+{(unsigned char*)"Ffr", {240, 157, 148, 137, 0}},
+{(unsigned char*)"FilledSmallSquare", {226, 151, 188, 0}},
+{(unsigned char*)"FilledVerySmallSquare", {226, 150, 170, 0}},
+{(unsigned char*)"Fopf", {240, 157, 148, 189, 0}},
+{(unsigned char*)"ForAll", {226, 136, 128, 0}},
+{(unsigned char*)"Fouriertrf", {226, 132, 177, 0}},
+{(unsigned char*)"Fscr", {226, 132, 177, 0}},
+{(unsigned char*)"GJcy", {208, 131, 0}},
+{(unsigned char*)"GT", {62, 0}},
+{(unsigned char*)"Gamma", {206, 147, 0}},
+{(unsigned char*)"Gammad", {207, 156, 0}},
+{(unsigned char*)"Gbreve", {196, 158, 0}},
+{(unsigned char*)"Gcedil", {196, 162, 0}},
+{(unsigned char*)"Gcirc", {196, 156, 0}},
+{(unsigned char*)"Gcy", {208, 147, 0}},
+{(unsigned char*)"Gdot", {196, 160, 0}},
+{(unsigned char*)"Gfr", {240, 157, 148, 138, 0}},
+{(unsigned char*)"Gg", {226, 139, 153, 0}},
+{(unsigned char*)"Gopf", {240, 157, 148, 190, 0}},
+{(unsigned char*)"GreaterEqual", {226, 137, 165, 0}},
+{(unsigned char*)"GreaterEqualLess", {226, 139, 155, 0}},
+{(unsigned char*)"GreaterFullEqual", {226, 137, 167, 0}},
+{(unsigned char*)"GreaterGreater", {226, 170, 162, 0}},
+{(unsigned char*)"GreaterLess", {226, 137, 183, 0}},
+{(unsigned char*)"GreaterSlantEqual", {226, 169, 190, 0}},
+{(unsigned char*)"GreaterTilde", {226, 137, 179, 0}},
+{(unsigned char*)"Gscr", {240, 157, 146, 162, 0}},
+{(unsigned char*)"Gt", {226, 137, 171, 0}},
+{(unsigned char*)"HARDcy", {208, 170, 0}},
+{(unsigned char*)"Hacek", {203, 135, 0}},
+{(unsigned char*)"Hat", {94, 0}},
+{(unsigned char*)"Hcirc", {196, 164, 0}},
+{(unsigned char*)"Hfr", {226, 132, 140, 0}},
+{(unsigned char*)"HilbertSpace", {226, 132, 139, 0}},
+{(unsigned char*)"Hopf", {226, 132, 141, 0}},
+{(unsigned char*)"HorizontalLine", {226, 148, 128, 0}},
+{(unsigned char*)"Hscr", {226, 132, 139, 0}},
+{(unsigned char*)"Hstrok", {196, 166, 0}},
+{(unsigned char*)"HumpDownHump", {226, 137, 142, 0}},
+{(unsigned char*)"HumpEqual", {226, 137, 143, 0}},
+{(unsigned char*)"IEcy", {208, 149, 0}},
+{(unsigned char*)"IJlig", {196, 178, 0}},
+{(unsigned char*)"IOcy", {208, 129, 0}},
+{(unsigned char*)"Iacute", {195, 141, 0}},
+{(unsigned char*)"Icirc", {195, 142, 0}},
+{(unsigned char*)"Icy", {208, 152, 0}},
+{(unsigned char*)"Idot", {196, 176, 0}},
+{(unsigned char*)"Ifr", {226, 132, 145, 0}},
+{(unsigned char*)"Igrave", {195, 140, 0}},
+{(unsigned char*)"Im", {226, 132, 145, 0}},
+{(unsigned char*)"Imacr", {196, 170, 0}},
+{(unsigned char*)"ImaginaryI", {226, 133, 136, 0}},
+{(unsigned char*)"Implies", {226, 135, 146, 0}},
+{(unsigned char*)"Int", {226, 136, 172, 0}},
+{(unsigned char*)"Integral", {226, 136, 171, 0}},
+{(unsigned char*)"Intersection", {226, 139, 130, 0}},
+{(unsigned char*)"InvisibleComma", {226, 129, 163, 0}},
+{(unsigned char*)"InvisibleTimes", {226, 129, 162, 0}},
+{(unsigned char*)"Iogon", {196, 174, 0}},
+{(unsigned char*)"Iopf", {240, 157, 149, 128, 0}},
+{(unsigned char*)"Iota", {206, 153, 0}},
+{(unsigned char*)"Iscr", {226, 132, 144, 0}},
+{(unsigned char*)"Itilde", {196, 168, 0}},
+{(unsigned char*)"Iukcy", {208, 134, 0}},
+{(unsigned char*)"Iuml", {195, 143, 0}},
+{(unsigned char*)"Jcirc", {196, 180, 0}},
+{(unsigned char*)"Jcy", {208, 153, 0}},
+{(unsigned char*)"Jfr", {240, 157, 148, 141, 0}},
+{(unsigned char*)"Jopf", {240, 157, 149, 129, 0}},
+{(unsigned char*)"Jscr", {240, 157, 146, 165, 0}},
+{(unsigned char*)"Jsercy", {208, 136, 0}},
+{(unsigned char*)"Jukcy", {208, 132, 0}},
+{(unsigned char*)"KHcy", {208, 165, 0}},
+{(unsigned char*)"KJcy", {208, 140, 0}},
+{(unsigned char*)"Kappa", {206, 154, 0}},
+{(unsigned char*)"Kcedil", {196, 182, 0}},
+{(unsigned char*)"Kcy", {208, 154, 0}},
+{(unsigned char*)"Kfr", {240, 157, 148, 142, 0}},
+{(unsigned char*)"Kopf", {240, 157, 149, 130, 0}},
+{(unsigned char*)"Kscr", {240, 157, 146, 166, 0}},
+{(unsigned char*)"LJcy", {208, 137, 0}},
+{(unsigned char*)"LT", {60, 0}},
+{(unsigned char*)"Lacute", {196, 185, 0}},
+{(unsigned char*)"Lambda", {206, 155, 0}},
+{(unsigned char*)"Lang", {226, 159, 170, 0}},
+{(unsigned char*)"Laplacetrf", {226, 132, 146, 0}},
+{(unsigned char*)"Larr", {226, 134, 158, 0}},
+{(unsigned char*)"Lcaron", {196, 189, 0}},
+{(unsigned char*)"Lcedil", {196, 187, 0}},
+{(unsigned char*)"Lcy", {208, 155, 0}},
+{(unsigned char*)"LeftAngleBracket", {226, 159, 168, 0}},
+{(unsigned char*)"LeftArrow", {226, 134, 144, 0}},
+{(unsigned char*)"LeftArrowBar", {226, 135, 164, 0}},
+{(unsigned char*)"LeftArrowRightArrow", {226, 135, 134, 0}},
+{(unsigned char*)"LeftCeiling", {226, 140, 136, 0}},
+{(unsigned char*)"LeftDoubleBracket", {226, 159, 166, 0}},
+{(unsigned char*)"LeftDownTeeVector", {226, 165, 161, 0}},
+{(unsigned char*)"LeftDownVector", {226, 135, 131, 0}},
+{(unsigned char*)"LeftDownVectorBar", {226, 165, 153, 0}},
+{(unsigned char*)"LeftFloor", {226, 140, 138, 0}},
+{(unsigned char*)"LeftRightArrow", {226, 134, 148, 0}},
+{(unsigned char*)"LeftRightVector", {226, 165, 142, 0}},
+{(unsigned char*)"LeftTee", {226, 138, 163, 0}},
+{(unsigned char*)"LeftTeeArrow", {226, 134, 164, 0}},
+{(unsigned char*)"LeftTeeVector", {226, 165, 154, 0}},
+{(unsigned char*)"LeftTriangle", {226, 138, 178, 0}},
+{(unsigned char*)"LeftTriangleBar", {226, 167, 143, 0}},
+{(unsigned char*)"LeftTriangleEqual", {226, 138, 180, 0}},
+{(unsigned char*)"LeftUpDownVector", {226, 165, 145, 0}},
+{(unsigned char*)"LeftUpTeeVector", {226, 165, 160, 0}},
+{(unsigned char*)"LeftUpVector", {226, 134, 191, 0}},
+{(unsigned char*)"LeftUpVectorBar", {226, 165, 152, 0}},
+{(unsigned char*)"LeftVector", {226, 134, 188, 0}},
+{(unsigned char*)"LeftVectorBar", {226, 165, 146, 0}},
+{(unsigned char*)"Leftarrow", {226, 135, 144, 0}},
+{(unsigned char*)"Leftrightarrow", {226, 135, 148, 0}},
+{(unsigned char*)"LessEqualGreater", {226, 139, 154, 0}},
+{(unsigned char*)"LessFullEqual", {226, 137, 166, 0}},
+{(unsigned char*)"LessGreater", {226, 137, 182, 0}},
+{(unsigned char*)"LessLess", {226, 170, 161, 0}},
+{(unsigned char*)"LessSlantEqual", {226, 169, 189, 0}},
+{(unsigned char*)"LessTilde", {226, 137, 178, 0}},
+{(unsigned char*)"Lfr", {240, 157, 148, 143, 0}},
+{(unsigned char*)"Ll", {226, 139, 152, 0}},
+{(unsigned char*)"Lleftarrow", {226, 135, 154, 0}},
+{(unsigned char*)"Lmidot", {196, 191, 0}},
+{(unsigned char*)"LongLeftArrow", {226, 159, 181, 0}},
+{(unsigned char*)"LongLeftRightArrow", {226, 159, 183, 0}},
+{(unsigned char*)"LongRightArrow", {226, 159, 182, 0}},
+{(unsigned char*)"Longleftarrow", {226, 159, 184, 0}},
+{(unsigned char*)"Longleftrightarrow", {226, 159, 186, 0}},
+{(unsigned char*)"Longrightarrow", {226, 159, 185, 0}},
+{(unsigned char*)"Lopf", {240, 157, 149, 131, 0}},
+{(unsigned char*)"LowerLeftArrow", {226, 134, 153, 0}},
+{(unsigned char*)"LowerRightArrow", {226, 134, 152, 0}},
+{(unsigned char*)"Lscr", {226, 132, 146, 0}},
+{(unsigned char*)"Lsh", {226, 134, 176, 0}},
+{(unsigned char*)"Lstrok", {197, 129, 0}},
+{(unsigned char*)"Lt", {226, 137, 170, 0}},
+{(unsigned char*)"Map", {226, 164, 133, 0}},
+{(unsigned char*)"Mcy", {208, 156, 0}},
+{(unsigned char*)"MediumSpace", {226, 129, 159, 0}},
+{(unsigned char*)"Mellintrf", {226, 132, 179, 0}},
+{(unsigned char*)"Mfr", {240, 157, 148, 144, 0}},
+{(unsigned char*)"MinusPlus", {226, 136, 147, 0}},
+{(unsigned char*)"Mopf", {240, 157, 149, 132, 0}},
+{(unsigned char*)"Mscr", {226, 132, 179, 0}},
+{(unsigned char*)"Mu", {206, 156, 0}},
+{(unsigned char*)"NJcy", {208, 138, 0}},
+{(unsigned char*)"Nacute", {197, 131, 0}},
+{(unsigned char*)"Ncaron", {197, 135, 0}},
+{(unsigned char*)"Ncedil", {197, 133, 0}},
+{(unsigned char*)"Ncy", {208, 157, 0}},
+{(unsigned char*)"NegativeMediumSpace", {226, 128, 139, 0}},
+{(unsigned char*)"NegativeThickSpace", {226, 128, 139, 0}},
+{(unsigned char*)"NegativeThinSpace", {226, 128, 139, 0}},
+{(unsigned char*)"NegativeVeryThinSpace", {226, 128, 139, 0}},
+{(unsigned char*)"NestedGreaterGreater", {226, 137, 171, 0}},
+{(unsigned char*)"NestedLessLess", {226, 137, 170, 0}},
+{(unsigned char*)"NewLine", {10, 0}},
+{(unsigned char*)"Nfr", {240, 157, 148, 145, 0}},
+{(unsigned char*)"NoBreak", {226, 129, 160, 0}},
+{(unsigned char*)"NonBreakingSpace", {194, 160, 0}},
+{(unsigned char*)"Nopf", {226, 132, 149, 0}},
+{(unsigned char*)"Not", {226, 171, 172, 0}},
+{(unsigned char*)"NotCongruent", {226, 137, 162, 0}},
+{(unsigned char*)"NotCupCap", {226, 137, 173, 0}},
+{(unsigned char*)"NotDoubleVerticalBar", {226, 136, 166, 0}},
+{(unsigned char*)"NotElement", {226, 136, 137, 0}},
+{(unsigned char*)"NotEqual", {226, 137, 160, 0}},
+{(unsigned char*)"NotEqualTilde", {226, 137, 130, 204, 184, 0}},
+{(unsigned char*)"NotExists", {226, 136, 132, 0}},
+{(unsigned char*)"NotGreater", {226, 137, 175, 0}},
+{(unsigned char*)"NotGreaterEqual", {226, 137, 177, 0}},
+{(unsigned char*)"NotGreaterFullEqual", {226, 137, 167, 204, 184, 0}},
+{(unsigned char*)"NotGreaterGreater", {226, 137, 171, 204, 184, 0}},
+{(unsigned char*)"NotGreaterLess", {226, 137, 185, 0}},
+{(unsigned char*)"NotGreaterSlantEqual", {226, 169, 190, 204, 184, 0}},
+{(unsigned char*)"NotGreaterTilde", {226, 137, 181, 0}},
+{(unsigned char*)"NotHumpDownHump", {226, 137, 142, 204, 184, 0}},
+{(unsigned char*)"NotHumpEqual", {226, 137, 143, 204, 184, 0}},
+{(unsigned char*)"NotLeftTriangle", {226, 139, 170, 0}},
+{(unsigned char*)"NotLeftTriangleBar", {226, 167, 143, 204, 184, 0}},
+{(unsigned char*)"NotLeftTriangleEqual", {226, 139, 172, 0}},
+{(unsigned char*)"NotLess", {226, 137, 174, 0}},
+{(unsigned char*)"NotLessEqual", {226, 137, 176, 0}},
+{(unsigned char*)"NotLessGreater", {226, 137, 184, 0}},
+{(unsigned char*)"NotLessLess", {226, 137, 170, 204, 184, 0}},
+{(unsigned char*)"NotLessSlantEqual", {226, 169, 189, 204, 184, 0}},
+{(unsigned char*)"NotLessTilde", {226, 137, 180, 0}},
+{(unsigned char*)"NotNestedGreaterGreater", {226, 170, 162, 204, 184, 0}},
+{(unsigned char*)"NotNestedLessLess", {226, 170, 161, 204, 184, 0}},
+{(unsigned char*)"NotPrecedes", {226, 138, 128, 0}},
+{(unsigned char*)"NotPrecedesEqual", {226, 170, 175, 204, 184, 0}},
+{(unsigned char*)"NotPrecedesSlantEqual", {226, 139, 160, 0}},
+{(unsigned char*)"NotReverseElement", {226, 136, 140, 0}},
+{(unsigned char*)"NotRightTriangle", {226, 139, 171, 0}},
+{(unsigned char*)"NotRightTriangleBar", {226, 167, 144, 204, 184, 0}},
+{(unsigned char*)"NotRightTriangleEqual", {226, 139, 173, 0}},
+{(unsigned char*)"NotSquareSubset", {226, 138, 143, 204, 184, 0}},
+{(unsigned char*)"NotSquareSubsetEqual", {226, 139, 162, 0}},
+{(unsigned char*)"NotSquareSuperset", {226, 138, 144, 204, 184, 0}},
+{(unsigned char*)"NotSquareSupersetEqual", {226, 139, 163, 0}},
+{(unsigned char*)"NotSubset", {226, 138, 130, 226, 131, 146, 0}},
+{(unsigned char*)"NotSubsetEqual", {226, 138, 136, 0}},
+{(unsigned char*)"NotSucceeds", {226, 138, 129, 0}},
+{(unsigned char*)"NotSucceedsEqual", {226, 170, 176, 204, 184, 0}},
+{(unsigned char*)"NotSucceedsSlantEqual", {226, 139, 161, 0}},
+{(unsigned char*)"NotSucceedsTilde", {226, 137, 191, 204, 184, 0}},
+{(unsigned char*)"NotSuperset", {226, 138, 131, 226, 131, 146, 0}},
+{(unsigned char*)"NotSupersetEqual", {226, 138, 137, 0}},
+{(unsigned char*)"NotTilde", {226, 137, 129, 0}},
+{(unsigned char*)"NotTildeEqual", {226, 137, 132, 0}},
+{(unsigned char*)"NotTildeFullEqual", {226, 137, 135, 0}},
+{(unsigned char*)"NotTildeTilde", {226, 137, 137, 0}},
+{(unsigned char*)"NotVerticalBar", {226, 136, 164, 0}},
+{(unsigned char*)"Nscr", {240, 157, 146, 169, 0}},
+{(unsigned char*)"Ntilde", {195, 145, 0}},
+{(unsigned char*)"Nu", {206, 157, 0}},
+{(unsigned char*)"OElig", {197, 146, 0}},
+{(unsigned char*)"Oacute", {195, 147, 0}},
+{(unsigned char*)"Ocirc", {195, 148, 0}},
+{(unsigned char*)"Ocy", {208, 158, 0}},
+{(unsigned char*)"Odblac", {197, 144, 0}},
+{(unsigned char*)"Ofr", {240, 157, 148, 146, 0}},
+{(unsigned char*)"Ograve", {195, 146, 0}},
+{(unsigned char*)"Omacr", {197, 140, 0}},
+{(unsigned char*)"Omega", {206, 169, 0}},
+{(unsigned char*)"Omicron", {206, 159, 0}},
+{(unsigned char*)"Oopf", {240, 157, 149, 134, 0}},
+{(unsigned char*)"OpenCurlyDoubleQuote", {226, 128, 156, 0}},
+{(unsigned char*)"OpenCurlyQuote", {226, 128, 152, 0}},
+{(unsigned char*)"Or", {226, 169, 148, 0}},
+{(unsigned char*)"Oscr", {240, 157, 146, 170, 0}},
+{(unsigned char*)"Oslash", {195, 152, 0}},
+{(unsigned char*)"Otilde", {195, 149, 0}},
+{(unsigned char*)"Otimes", {226, 168, 183, 0}},
+{(unsigned char*)"Ouml", {195, 150, 0}},
+{(unsigned char*)"OverBar", {226, 128, 190, 0}},
+{(unsigned char*)"OverBrace", {226, 143, 158, 0}},
+{(unsigned char*)"OverBracket", {226, 142, 180, 0}},
+{(unsigned char*)"OverParenthesis", {226, 143, 156, 0}},
+{(unsigned char*)"PartialD", {226, 136, 130, 0}},
+{(unsigned char*)"Pcy", {208, 159, 0}},
+{(unsigned char*)"Pfr", {240, 157, 148, 147, 0}},
+{(unsigned char*)"Phi", {206, 166, 0}},
+{(unsigned char*)"Pi", {206, 160, 0}},
+{(unsigned char*)"PlusMinus", {194, 177, 0}},
+{(unsigned char*)"Poincareplane", {226, 132, 140, 0}},
+{(unsigned char*)"Popf", {226, 132, 153, 0}},
+{(unsigned char*)"Pr", {226, 170, 187, 0}},
+{(unsigned char*)"Precedes", {226, 137, 186, 0}},
+{(unsigned char*)"PrecedesEqual", {226, 170, 175, 0}},
+{(unsigned char*)"PrecedesSlantEqual", {226, 137, 188, 0}},
+{(unsigned char*)"PrecedesTilde", {226, 137, 190, 0}},
+{(unsigned char*)"Prime", {226, 128, 179, 0}},
+{(unsigned char*)"Product", {226, 136, 143, 0}},
+{(unsigned char*)"Proportion", {226, 136, 183, 0}},
+{(unsigned char*)"Proportional", {226, 136, 157, 0}},
+{(unsigned char*)"Pscr", {240, 157, 146, 171, 0}},
+{(unsigned char*)"Psi", {206, 168, 0}},
+{(unsigned char*)"QUOT", {34, 0}},
+{(unsigned char*)"Qfr", {240, 157, 148, 148, 0}},
+{(unsigned char*)"Qopf", {226, 132, 154, 0}},
+{(unsigned char*)"Qscr", {240, 157, 146, 172, 0}},
+{(unsigned char*)"RBarr", {226, 164, 144, 0}},
+{(unsigned char*)"REG", {194, 174, 0}},
+{(unsigned char*)"Racute", {197, 148, 0}},
+{(unsigned char*)"Rang", {226, 159, 171, 0}},
+{(unsigned char*)"Rarr", {226, 134, 160, 0}},
+{(unsigned char*)"Rarrtl", {226, 164, 150, 0}},
+{(unsigned char*)"Rcaron", {197, 152, 0}},
+{(unsigned char*)"Rcedil", {197, 150, 0}},
+{(unsigned char*)"Rcy", {208, 160, 0}},
+{(unsigned char*)"Re", {226, 132, 156, 0}},
+{(unsigned char*)"ReverseElement", {226, 136, 139, 0}},
+{(unsigned char*)"ReverseEquilibrium", {226, 135, 139, 0}},
+{(unsigned char*)"ReverseUpEquilibrium", {226, 165, 175, 0}},
+{(unsigned char*)"Rfr", {226, 132, 156, 0}},
+{(unsigned char*)"Rho", {206, 161, 0}},
+{(unsigned char*)"RightAngleBracket", {226, 159, 169, 0}},
+{(unsigned char*)"RightArrow", {226, 134, 146, 0}},
+{(unsigned char*)"RightArrowBar", {226, 135, 165, 0}},
+{(unsigned char*)"RightArrowLeftArrow", {226, 135, 132, 0}},
+{(unsigned char*)"RightCeiling", {226, 140, 137, 0}},
+{(unsigned char*)"RightDoubleBracket", {226, 159, 167, 0}},
+{(unsigned char*)"RightDownTeeVector", {226, 165, 157, 0}},
+{(unsigned char*)"RightDownVector", {226, 135, 130, 0}},
+{(unsigned char*)"RightDownVectorBar", {226, 165, 149, 0}},
+{(unsigned char*)"RightFloor", {226, 140, 139, 0}},
+{(unsigned char*)"RightTee", {226, 138, 162, 0}},
+{(unsigned char*)"RightTeeArrow", {226, 134, 166, 0}},
+{(unsigned char*)"RightTeeVector", {226, 165, 155, 0}},
+{(unsigned char*)"RightTriangle", {226, 138, 179, 0}},
+{(unsigned char*)"RightTriangleBar", {226, 167, 144, 0}},
+{(unsigned char*)"RightTriangleEqual", {226, 138, 181, 0}},
+{(unsigned char*)"RightUpDownVector", {226, 165, 143, 0}},
+{(unsigned char*)"RightUpTeeVector", {226, 165, 156, 0}},
+{(unsigned char*)"RightUpVector", {226, 134, 190, 0}},
+{(unsigned char*)"RightUpVectorBar", {226, 165, 148, 0}},
+{(unsigned char*)"RightVector", {226, 135, 128, 0}},
+{(unsigned char*)"RightVectorBar", {226, 165, 147, 0}},
+{(unsigned char*)"Rightarrow", {226, 135, 146, 0}},
+{(unsigned char*)"Ropf", {226, 132, 157, 0}},
+{(unsigned char*)"RoundImplies", {226, 165, 176, 0}},
+{(unsigned char*)"Rrightarrow", {226, 135, 155, 0}},
+{(unsigned char*)"Rscr", {226, 132, 155, 0}},
+{(unsigned char*)"Rsh", {226, 134, 177, 0}},
+{(unsigned char*)"RuleDelayed", {226, 167, 180, 0}},
+{(unsigned char*)"SHCHcy", {208, 169, 0}},
+{(unsigned char*)"SHcy", {208, 168, 0}},
+{(unsigned char*)"SOFTcy", {208, 172, 0}},
+{(unsigned char*)"Sacute", {197, 154, 0}},
+{(unsigned char*)"Sc", {226, 170, 188, 0}},
+{(unsigned char*)"Scaron", {197, 160, 0}},
+{(unsigned char*)"Scedil", {197, 158, 0}},
+{(unsigned char*)"Scirc", {197, 156, 0}},
+{(unsigned char*)"Scy", {208, 161, 0}},
+{(unsigned char*)"Sfr", {240, 157, 148, 150, 0}},
+{(unsigned char*)"ShortDownArrow", {226, 134, 147, 0}},
+{(unsigned char*)"ShortLeftArrow", {226, 134, 144, 0}},
+{(unsigned char*)"ShortRightArrow", {226, 134, 146, 0}},
+{(unsigned char*)"ShortUpArrow", {226, 134, 145, 0}},
+{(unsigned char*)"Sigma", {206, 163, 0}},
+{(unsigned char*)"SmallCircle", {226, 136, 152, 0}},
+{(unsigned char*)"Sopf", {240, 157, 149, 138, 0}},
+{(unsigned char*)"Sqrt", {226, 136, 154, 0}},
+{(unsigned char*)"Square", {226, 150, 161, 0}},
+{(unsigned char*)"SquareIntersection", {226, 138, 147, 0}},
+{(unsigned char*)"SquareSubset", {226, 138, 143, 0}},
+{(unsigned char*)"SquareSubsetEqual", {226, 138, 145, 0}},
+{(unsigned char*)"SquareSuperset", {226, 138, 144, 0}},
+{(unsigned char*)"SquareSupersetEqual", {226, 138, 146, 0}},
+{(unsigned char*)"SquareUnion", {226, 138, 148, 0}},
+{(unsigned char*)"Sscr", {240, 157, 146, 174, 0}},
+{(unsigned char*)"Star", {226, 139, 134, 0}},
+{(unsigned char*)"Sub", {226, 139, 144, 0}},
+{(unsigned char*)"Subset", {226, 139, 144, 0}},
+{(unsigned char*)"SubsetEqual", {226, 138, 134, 0}},
+{(unsigned char*)"Succeeds", {226, 137, 187, 0}},
+{(unsigned char*)"SucceedsEqual", {226, 170, 176, 0}},
+{(unsigned char*)"SucceedsSlantEqual", {226, 137, 189, 0}},
+{(unsigned char*)"SucceedsTilde", {226, 137, 191, 0}},
+{(unsigned char*)"SuchThat", {226, 136, 139, 0}},
+{(unsigned char*)"Sum", {226, 136, 145, 0}},
+{(unsigned char*)"Sup", {226, 139, 145, 0}},
+{(unsigned char*)"Superset", {226, 138, 131, 0}},
+{(unsigned char*)"SupersetEqual", {226, 138, 135, 0}},
+{(unsigned char*)"Supset", {226, 139, 145, 0}},
+{(unsigned char*)"THORN", {195, 158, 0}},
+{(unsigned char*)"TRADE", {226, 132, 162, 0}},
+{(unsigned char*)"TSHcy", {208, 139, 0}},
+{(unsigned char*)"TScy", {208, 166, 0}},
+{(unsigned char*)"Tab", {9, 0}},
+{(unsigned char*)"Tau", {206, 164, 0}},
+{(unsigned char*)"Tcaron", {197, 164, 0}},
+{(unsigned char*)"Tcedil", {197, 162, 0}},
+{(unsigned char*)"Tcy", {208, 162, 0}},
+{(unsigned char*)"Tfr", {240, 157, 148, 151, 0}},
+{(unsigned char*)"Therefore", {226, 136, 180, 0}},
+{(unsigned char*)"Theta", {206, 152, 0}},
+{(unsigned char*)"ThickSpace", {226, 129, 159, 226, 128, 138, 0}},
+{(unsigned char*)"ThinSpace", {226, 128, 137, 0}},
+{(unsigned char*)"Tilde", {226, 136, 188, 0}},
+{(unsigned char*)"TildeEqual", {226, 137, 131, 0}},
+{(unsigned char*)"TildeFullEqual", {226, 137, 133, 0}},
+{(unsigned char*)"TildeTilde", {226, 137, 136, 0}},
+{(unsigned char*)"Topf", {240, 157, 149, 139, 0}},
+{(unsigned char*)"TripleDot", {226, 131, 155, 0}},
+{(unsigned char*)"Tscr", {240, 157, 146, 175, 0}},
+{(unsigned char*)"Tstrok", {197, 166, 0}},
+{(unsigned char*)"Uacute", {195, 154, 0}},
+{(unsigned char*)"Uarr", {226, 134, 159, 0}},
+{(unsigned char*)"Uarrocir", {226, 165, 137, 0}},
+{(unsigned char*)"Ubrcy", {208, 142, 0}},
+{(unsigned char*)"Ubreve", {197, 172, 0}},
+{(unsigned char*)"Ucirc", {195, 155, 0}},
+{(unsigned char*)"Ucy", {208, 163, 0}},
+{(unsigned char*)"Udblac", {197, 176, 0}},
+{(unsigned char*)"Ufr", {240, 157, 148, 152, 0}},
+{(unsigned char*)"Ugrave", {195, 153, 0}},
+{(unsigned char*)"Umacr", {197, 170, 0}},
+{(unsigned char*)"UnderBar", {95, 0}},
+{(unsigned char*)"UnderBrace", {226, 143, 159, 0}},
+{(unsigned char*)"UnderBracket", {226, 142, 181, 0}},
+{(unsigned char*)"UnderParenthesis", {226, 143, 157, 0}},
+{(unsigned char*)"Union", {226, 139, 131, 0}},
+{(unsigned char*)"UnionPlus", {226, 138, 142, 0}},
+{(unsigned char*)"Uogon", {197, 178, 0}},
+{(unsigned char*)"Uopf", {240, 157, 149, 140, 0}},
+{(unsigned char*)"UpArrow", {226, 134, 145, 0}},
+{(unsigned char*)"UpArrowBar", {226, 164, 146, 0}},
+{(unsigned char*)"UpArrowDownArrow", {226, 135, 133, 0}},
+{(unsigned char*)"UpDownArrow", {226, 134, 149, 0}},
+{(unsigned char*)"UpEquilibrium", {226, 165, 174, 0}},
+{(unsigned char*)"UpTee", {226, 138, 165, 0}},
+{(unsigned char*)"UpTeeArrow", {226, 134, 165, 0}},
+{(unsigned char*)"Uparrow", {226, 135, 145, 0}},
+{(unsigned char*)"Updownarrow", {226, 135, 149, 0}},
+{(unsigned char*)"UpperLeftArrow", {226, 134, 150, 0}},
+{(unsigned char*)"UpperRightArrow", {226, 134, 151, 0}},
+{(unsigned char*)"Upsi", {207, 146, 0}},
+{(unsigned char*)"Upsilon", {206, 165, 0}},
+{(unsigned char*)"Uring", {197, 174, 0}},
+{(unsigned char*)"Uscr", {240, 157, 146, 176, 0}},
+{(unsigned char*)"Utilde", {197, 168, 0}},
+{(unsigned char*)"Uuml", {195, 156, 0}},
+{(unsigned char*)"VDash", {226, 138, 171, 0}},
+{(unsigned char*)"Vbar", {226, 171, 171, 0}},
+{(unsigned char*)"Vcy", {208, 146, 0}},
+{(unsigned char*)"Vdash", {226, 138, 169, 0}},
+{(unsigned char*)"Vdashl", {226, 171, 166, 0}},
+{(unsigned char*)"Vee", {226, 139, 129, 0}},
+{(unsigned char*)"Verbar", {226, 128, 150, 0}},
+{(unsigned char*)"Vert", {226, 128, 150, 0}},
+{(unsigned char*)"VerticalBar", {226, 136, 163, 0}},
+{(unsigned char*)"VerticalLine", {124, 0}},
+{(unsigned char*)"VerticalSeparator", {226, 157, 152, 0}},
+{(unsigned char*)"VerticalTilde", {226, 137, 128, 0}},
+{(unsigned char*)"VeryThinSpace", {226, 128, 138, 0}},
+{(unsigned char*)"Vfr", {240, 157, 148, 153, 0}},
+{(unsigned char*)"Vopf", {240, 157, 149, 141, 0}},
+{(unsigned char*)"Vscr", {240, 157, 146, 177, 0}},
+{(unsigned char*)"Vvdash", {226, 138, 170, 0}},
+{(unsigned char*)"Wcirc", {197, 180, 0}},
+{(unsigned char*)"Wedge", {226, 139, 128, 0}},
+{(unsigned char*)"Wfr", {240, 157, 148, 154, 0}},
+{(unsigned char*)"Wopf", {240, 157, 149, 142, 0}},
+{(unsigned char*)"Wscr", {240, 157, 146, 178, 0}},
+{(unsigned char*)"Xfr", {240, 157, 148, 155, 0}},
+{(unsigned char*)"Xi", {206, 158, 0}},
+{(unsigned char*)"Xopf", {240, 157, 149, 143, 0}},
+{(unsigned char*)"Xscr", {240, 157, 146, 179, 0}},
+{(unsigned char*)"YAcy", {208, 175, 0}},
+{(unsigned char*)"YIcy", {208, 135, 0}},
+{(unsigned char*)"YUcy", {208, 174, 0}},
+{(unsigned char*)"Yacute", {195, 157, 0}},
+{(unsigned char*)"Ycirc", {197, 182, 0}},
+{(unsigned char*)"Ycy", {208, 171, 0}},
+{(unsigned char*)"Yfr", {240, 157, 148, 156, 0}},
+{(unsigned char*)"Yopf", {240, 157, 149, 144, 0}},
+{(unsigned char*)"Yscr", {240, 157, 146, 180, 0}},
+{(unsigned char*)"Yuml", {197, 184, 0}},
+{(unsigned char*)"ZHcy", {208, 150, 0}},
+{(unsigned char*)"Zacute", {197, 185, 0}},
+{(unsigned char*)"Zcaron", {197, 189, 0}},
+{(unsigned char*)"Zcy", {208, 151, 0}},
+{(unsigned char*)"Zdot", {197, 187, 0}},
+{(unsigned char*)"ZeroWidthSpace", {226, 128, 139, 0}},
+{(unsigned char*)"Zeta", {206, 150, 0}},
+{(unsigned char*)"Zfr", {226, 132, 168, 0}},
+{(unsigned char*)"Zopf", {226, 132, 164, 0}},
+{(unsigned char*)"Zscr", {240, 157, 146, 181, 0}},
+{(unsigned char*)"aacute", {195, 161, 0}},
+{(unsigned char*)"abreve", {196, 131, 0}},
+{(unsigned char*)"ac", {226, 136, 190, 0}},
+{(unsigned char*)"acE", {226, 136, 190, 204, 179, 0}},
+{(unsigned char*)"acd", {226, 136, 191, 0}},
+{(unsigned char*)"acirc", {195, 162, 0}},
+{(unsigned char*)"acute", {194, 180, 0}},
+{(unsigned char*)"acy", {208, 176, 0}},
+{(unsigned char*)"aelig", {195, 166, 0}},
+{(unsigned char*)"af", {226, 129, 161, 0}},
+{(unsigned char*)"afr", {240, 157, 148, 158, 0}},
+{(unsigned char*)"agrave", {195, 160, 0}},
+{(unsigned char*)"alefsym", {226, 132, 181, 0}},
+{(unsigned char*)"aleph", {226, 132, 181, 0}},
+{(unsigned char*)"alpha", {206, 177, 0}},
+{(unsigned char*)"amacr", {196, 129, 0}},
+{(unsigned char*)"amalg", {226, 168, 191, 0}},
+{(unsigned char*)"amp", {38, 0}},
+{(unsigned char*)"and", {226, 136, 167, 0}},
+{(unsigned char*)"andand", {226, 169, 149, 0}},
+{(unsigned char*)"andd", {226, 169, 156, 0}},
+{(unsigned char*)"andslope", {226, 169, 152, 0}},
+{(unsigned char*)"andv", {226, 169, 154, 0}},
+{(unsigned char*)"ang", {226, 136, 160, 0}},
+{(unsigned char*)"ange", {226, 166, 164, 0}},
+{(unsigned char*)"angle", {226, 136, 160, 0}},
+{(unsigned char*)"angmsd", {226, 136, 161, 0}},
+{(unsigned char*)"angmsdaa", {226, 166, 168, 0}},
+{(unsigned char*)"angmsdab", {226, 166, 169, 0}},
+{(unsigned char*)"angmsdac", {226, 166, 170, 0}},
+{(unsigned char*)"angmsdad", {226, 166, 171, 0}},
+{(unsigned char*)"angmsdae", {226, 166, 172, 0}},
+{(unsigned char*)"angmsdaf", {226, 166, 173, 0}},
+{(unsigned char*)"angmsdag", {226, 166, 174, 0}},
+{(unsigned char*)"angmsdah", {226, 166, 175, 0}},
+{(unsigned char*)"angrt", {226, 136, 159, 0}},
+{(unsigned char*)"angrtvb", {226, 138, 190, 0}},
+{(unsigned char*)"angrtvbd", {226, 166, 157, 0}},
+{(unsigned char*)"angsph", {226, 136, 162, 0}},
+{(unsigned char*)"angst", {195, 133, 0}},
+{(unsigned char*)"angzarr", {226, 141, 188, 0}},
+{(unsigned char*)"aogon", {196, 133, 0}},
+{(unsigned char*)"aopf", {240, 157, 149, 146, 0}},
+{(unsigned char*)"ap", {226, 137, 136, 0}},
+{(unsigned char*)"apE", {226, 169, 176, 0}},
+{(unsigned char*)"apacir", {226, 169, 175, 0}},
+{(unsigned char*)"ape", {226, 137, 138, 0}},
+{(unsigned char*)"apid", {226, 137, 139, 0}},
+{(unsigned char*)"apos", {39, 0}},
+{(unsigned char*)"approx", {226, 137, 136, 0}},
+{(unsigned char*)"approxeq", {226, 137, 138, 0}},
+{(unsigned char*)"aring", {195, 165, 0}},
+{(unsigned char*)"ascr", {240, 157, 146, 182, 0}},
+{(unsigned char*)"ast", {42, 0}},
+{(unsigned char*)"asymp", {226, 137, 136, 0}},
+{(unsigned char*)"asympeq", {226, 137, 141, 0}},
+{(unsigned char*)"atilde", {195, 163, 0}},
+{(unsigned char*)"auml", {195, 164, 0}},
+{(unsigned char*)"awconint", {226, 136, 179, 0}},
+{(unsigned char*)"awint", {226, 168, 145, 0}},
+{(unsigned char*)"bNot", {226, 171, 173, 0}},
+{(unsigned char*)"backcong", {226, 137, 140, 0}},
+{(unsigned char*)"backepsilon", {207, 182, 0}},
+{(unsigned char*)"backprime", {226, 128, 181, 0}},
+{(unsigned char*)"backsim", {226, 136, 189, 0}},
+{(unsigned char*)"backsimeq", {226, 139, 141, 0}},
+{(unsigned char*)"barvee", {226, 138, 189, 0}},
+{(unsigned char*)"barwed", {226, 140, 133, 0}},
+{(unsigned char*)"barwedge", {226, 140, 133, 0}},
+{(unsigned char*)"bbrk", {226, 142, 181, 0}},
+{(unsigned char*)"bbrktbrk", {226, 142, 182, 0}},
+{(unsigned char*)"bcong", {226, 137, 140, 0}},
+{(unsigned char*)"bcy", {208, 177, 0}},
+{(unsigned char*)"bdquo", {226, 128, 158, 0}},
+{(unsigned char*)"becaus", {226, 136, 181, 0}},
+{(unsigned char*)"because", {226, 136, 181, 0}},
+{(unsigned char*)"bemptyv", {226, 166, 176, 0}},
+{(unsigned char*)"bepsi", {207, 182, 0}},
+{(unsigned char*)"bernou", {226, 132, 172, 0}},
+{(unsigned char*)"beta", {206, 178, 0}},
+{(unsigned char*)"beth", {226, 132, 182, 0}},
+{(unsigned char*)"between", {226, 137, 172, 0}},
+{(unsigned char*)"bfr", {240, 157, 148, 159, 0}},
+{(unsigned char*)"bigcap", {226, 139, 130, 0}},
+{(unsigned char*)"bigcirc", {226, 151, 175, 0}},
+{(unsigned char*)"bigcup", {226, 139, 131, 0}},
+{(unsigned char*)"bigodot", {226, 168, 128, 0}},
+{(unsigned char*)"bigoplus", {226, 168, 129, 0}},
+{(unsigned char*)"bigotimes", {226, 168, 130, 0}},
+{(unsigned char*)"bigsqcup", {226, 168, 134, 0}},
+{(unsigned char*)"bigstar", {226, 152, 133, 0}},
+{(unsigned char*)"bigtriangledown", {226, 150, 189, 0}},
+{(unsigned char*)"bigtriangleup", {226, 150, 179, 0}},
+{(unsigned char*)"biguplus", {226, 168, 132, 0}},
+{(unsigned char*)"bigvee", {226, 139, 129, 0}},
+{(unsigned char*)"bigwedge", {226, 139, 128, 0}},
+{(unsigned char*)"bkarow", {226, 164, 141, 0}},
+{(unsigned char*)"blacklozenge", {226, 167, 171, 0}},
+{(unsigned char*)"blacksquare", {226, 150, 170, 0}},
+{(unsigned char*)"blacktriangle", {226, 150, 180, 0}},
+{(unsigned char*)"blacktriangledown", {226, 150, 190, 0}},
+{(unsigned char*)"blacktriangleleft", {226, 151, 130, 0}},
+{(unsigned char*)"blacktriangleright", {226, 150, 184, 0}},
+{(unsigned char*)"blank", {226, 144, 163, 0}},
+{(unsigned char*)"blk12", {226, 150, 146, 0}},
+{(unsigned char*)"blk14", {226, 150, 145, 0}},
+{(unsigned char*)"blk34", {226, 150, 147, 0}},
+{(unsigned char*)"block", {226, 150, 136, 0}},
+{(unsigned char*)"bne", {61, 226, 131, 165, 0}},
+{(unsigned char*)"bnequiv", {226, 137, 161, 226, 131, 165, 0}},
+{(unsigned char*)"bnot", {226, 140, 144, 0}},
+{(unsigned char*)"bopf", {240, 157, 149, 147, 0}},
+{(unsigned char*)"bot", {226, 138, 165, 0}},
+{(unsigned char*)"bottom", {226, 138, 165, 0}},
+{(unsigned char*)"bowtie", {226, 139, 136, 0}},
+{(unsigned char*)"boxDL", {226, 149, 151, 0}},
+{(unsigned char*)"boxDR", {226, 149, 148, 0}},
+{(unsigned char*)"boxDl", {226, 149, 150, 0}},
+{(unsigned char*)"boxDr", {226, 149, 147, 0}},
+{(unsigned char*)"boxH", {226, 149, 144, 0}},
+{(unsigned char*)"boxHD", {226, 149, 166, 0}},
+{(unsigned char*)"boxHU", {226, 149, 169, 0}},
+{(unsigned char*)"boxHd", {226, 149, 164, 0}},
+{(unsigned char*)"boxHu", {226, 149, 167, 0}},
+{(unsigned char*)"boxUL", {226, 149, 157, 0}},
+{(unsigned char*)"boxUR", {226, 149, 154, 0}},
+{(unsigned char*)"boxUl", {226, 149, 156, 0}},
+{(unsigned char*)"boxUr", {226, 149, 153, 0}},
+{(unsigned char*)"boxV", {226, 149, 145, 0}},
+{(unsigned char*)"boxVH", {226, 149, 172, 0}},
+{(unsigned char*)"boxVL", {226, 149, 163, 0}},
+{(unsigned char*)"boxVR", {226, 149, 160, 0}},
+{(unsigned char*)"boxVh", {226, 149, 171, 0}},
+{(unsigned char*)"boxVl", {226, 149, 162, 0}},
+{(unsigned char*)"boxVr", {226, 149, 159, 0}},
+{(unsigned char*)"boxbox", {226, 167, 137, 0}},
+{(unsigned char*)"boxdL", {226, 149, 149, 0}},
+{(unsigned char*)"boxdR", {226, 149, 146, 0}},
+{(unsigned char*)"boxdl", {226, 148, 144, 0}},
+{(unsigned char*)"boxdr", {226, 148, 140, 0}},
+{(unsigned char*)"boxh", {226, 148, 128, 0}},
+{(unsigned char*)"boxhD", {226, 149, 165, 0}},
+{(unsigned char*)"boxhU", {226, 149, 168, 0}},
+{(unsigned char*)"boxhd", {226, 148, 172, 0}},
+{(unsigned char*)"boxhu", {226, 148, 180, 0}},
+{(unsigned char*)"boxminus", {226, 138, 159, 0}},
+{(unsigned char*)"boxplus", {226, 138, 158, 0}},
+{(unsigned char*)"boxtimes", {226, 138, 160, 0}},
+{(unsigned char*)"boxuL", {226, 149, 155, 0}},
+{(unsigned char*)"boxuR", {226, 149, 152, 0}},
+{(unsigned char*)"boxul", {226, 148, 152, 0}},
+{(unsigned char*)"boxur", {226, 148, 148, 0}},
+{(unsigned char*)"boxv", {226, 148, 130, 0}},
+{(unsigned char*)"boxvH", {226, 149, 170, 0}},
+{(unsigned char*)"boxvL", {226, 149, 161, 0}},
+{(unsigned char*)"boxvR", {226, 149, 158, 0}},
+{(unsigned char*)"boxvh", {226, 148, 188, 0}},
+{(unsigned char*)"boxvl", {226, 148, 164, 0}},
+{(unsigned char*)"boxvr", {226, 148, 156, 0}},
+{(unsigned char*)"bprime", {226, 128, 181, 0}},
+{(unsigned char*)"breve", {203, 152, 0}},
+{(unsigned char*)"brvbar", {194, 166, 0}},
+{(unsigned char*)"bscr", {240, 157, 146, 183, 0}},
+{(unsigned char*)"bsemi", {226, 129, 143, 0}},
+{(unsigned char*)"bsim", {226, 136, 189, 0}},
+{(unsigned char*)"bsime", {226, 139, 141, 0}},
+{(unsigned char*)"bsol", {92, 0}},
+{(unsigned char*)"bsolb", {226, 167, 133, 0}},
+{(unsigned char*)"bsolhsub", {226, 159, 136, 0}},
+{(unsigned char*)"bull", {226, 128, 162, 0}},
+{(unsigned char*)"bullet", {226, 128, 162, 0}},
+{(unsigned char*)"bump", {226, 137, 142, 0}},
+{(unsigned char*)"bumpE", {226, 170, 174, 0}},
+{(unsigned char*)"bumpe", {226, 137, 143, 0}},
+{(unsigned char*)"bumpeq", {226, 137, 143, 0}},
+{(unsigned char*)"cacute", {196, 135, 0}},
+{(unsigned char*)"cap", {226, 136, 169, 0}},
+{(unsigned char*)"capand", {226, 169, 132, 0}},
+{(unsigned char*)"capbrcup", {226, 169, 137, 0}},
+{(unsigned char*)"capcap", {226, 169, 139, 0}},
+{(unsigned char*)"capcup", {226, 169, 135, 0}},
+{(unsigned char*)"capdot", {226, 169, 128, 0}},
+{(unsigned char*)"caps", {226, 136, 169, 239, 184, 128, 0}},
+{(unsigned char*)"caret", {226, 129, 129, 0}},
+{(unsigned char*)"caron", {203, 135, 0}},
+{(unsigned char*)"ccaps", {226, 169, 141, 0}},
+{(unsigned char*)"ccaron", {196, 141, 0}},
+{(unsigned char*)"ccedil", {195, 167, 0}},
+{(unsigned char*)"ccirc", {196, 137, 0}},
+{(unsigned char*)"ccups", {226, 169, 140, 0}},
+{(unsigned char*)"ccupssm", {226, 169, 144, 0}},
+{(unsigned char*)"cdot", {196, 139, 0}},
+{(unsigned char*)"cedil", {194, 184, 0}},
+{(unsigned char*)"cemptyv", {226, 166, 178, 0}},
+{(unsigned char*)"cent", {194, 162, 0}},
+{(unsigned char*)"centerdot", {194, 183, 0}},
+{(unsigned char*)"cfr", {240, 157, 148, 160, 0}},
+{(unsigned char*)"chcy", {209, 135, 0}},
+{(unsigned char*)"check", {226, 156, 147, 0}},
+{(unsigned char*)"checkmark", {226, 156, 147, 0}},
+{(unsigned char*)"chi", {207, 135, 0}},
+{(unsigned char*)"cir", {226, 151, 139, 0}},
+{(unsigned char*)"cirE", {226, 167, 131, 0}},
+{(unsigned char*)"circ", {203, 134, 0}},
+{(unsigned char*)"circeq", {226, 137, 151, 0}},
+{(unsigned char*)"circlearrowleft", {226, 134, 186, 0}},
+{(unsigned char*)"circlearrowright", {226, 134, 187, 0}},
+{(unsigned char*)"circledR", {194, 174, 0}},
+{(unsigned char*)"circledS", {226, 147, 136, 0}},
+{(unsigned char*)"circledast", {226, 138, 155, 0}},
+{(unsigned char*)"circledcirc", {226, 138, 154, 0}},
+{(unsigned char*)"circleddash", {226, 138, 157, 0}},
+{(unsigned char*)"cire", {226, 137, 151, 0}},
+{(unsigned char*)"cirfnint", {226, 168, 144, 0}},
+{(unsigned char*)"cirmid", {226, 171, 175, 0}},
+{(unsigned char*)"cirscir", {226, 167, 130, 0}},
+{(unsigned char*)"clubs", {226, 153, 163, 0}},
+{(unsigned char*)"clubsuit", {226, 153, 163, 0}},
+{(unsigned char*)"colon", {58, 0}},
+{(unsigned char*)"colone", {226, 137, 148, 0}},
+{(unsigned char*)"coloneq", {226, 137, 148, 0}},
+{(unsigned char*)"comma", {44, 0}},
+{(unsigned char*)"commat", {64, 0}},
+{(unsigned char*)"comp", {226, 136, 129, 0}},
+{(unsigned char*)"compfn", {226, 136, 152, 0}},
+{(unsigned char*)"complement", {226, 136, 129, 0}},
+{(unsigned char*)"complexes", {226, 132, 130, 0}},
+{(unsigned char*)"cong", {226, 137, 133, 0}},
+{(unsigned char*)"congdot", {226, 169, 173, 0}},
+{(unsigned char*)"conint", {226, 136, 174, 0}},
+{(unsigned char*)"copf", {240, 157, 149, 148, 0}},
+{(unsigned char*)"coprod", {226, 136, 144, 0}},
+{(unsigned char*)"copy", {194, 169, 0}},
+{(unsigned char*)"copysr", {226, 132, 151, 0}},
+{(unsigned char*)"crarr", {226, 134, 181, 0}},
+{(unsigned char*)"cross", {226, 156, 151, 0}},
+{(unsigned char*)"cscr", {240, 157, 146, 184, 0}},
+{(unsigned char*)"csub", {226, 171, 143, 0}},
+{(unsigned char*)"csube", {226, 171, 145, 0}},
+{(unsigned char*)"csup", {226, 171, 144, 0}},
+{(unsigned char*)"csupe", {226, 171, 146, 0}},
+{(unsigned char*)"ctdot", {226, 139, 175, 0}},
+{(unsigned char*)"cudarrl", {226, 164, 184, 0}},
+{(unsigned char*)"cudarrr", {226, 164, 181, 0}},
+{(unsigned char*)"cuepr", {226, 139, 158, 0}},
+{(unsigned char*)"cuesc", {226, 139, 159, 0}},
+{(unsigned char*)"cularr", {226, 134, 182, 0}},
+{(unsigned char*)"cularrp", {226, 164, 189, 0}},
+{(unsigned char*)"cup", {226, 136, 170, 0}},
+{(unsigned char*)"cupbrcap", {226, 169, 136, 0}},
+{(unsigned char*)"cupcap", {226, 169, 134, 0}},
+{(unsigned char*)"cupcup", {226, 169, 138, 0}},
+{(unsigned char*)"cupdot", {226, 138, 141, 0}},
+{(unsigned char*)"cupor", {226, 169, 133, 0}},
+{(unsigned char*)"cups", {226, 136, 170, 239, 184, 128, 0}},
+{(unsigned char*)"curarr", {226, 134, 183, 0}},
+{(unsigned char*)"curarrm", {226, 164, 188, 0}},
+{(unsigned char*)"curlyeqprec", {226, 139, 158, 0}},
+{(unsigned char*)"curlyeqsucc", {226, 139, 159, 0}},
+{(unsigned char*)"curlyvee", {226, 139, 142, 0}},
+{(unsigned char*)"curlywedge", {226, 139, 143, 0}},
+{(unsigned char*)"curren", {194, 164, 0}},
+{(unsigned char*)"curvearrowleft", {226, 134, 182, 0}},
+{(unsigned char*)"curvearrowright", {226, 134, 183, 0}},
+{(unsigned char*)"cuvee", {226, 139, 142, 0}},
+{(unsigned char*)"cuwed", {226, 139, 143, 0}},
+{(unsigned char*)"cwconint", {226, 136, 178, 0}},
+{(unsigned char*)"cwint", {226, 136, 177, 0}},
+{(unsigned char*)"cylcty", {226, 140, 173, 0}},
+{(unsigned char*)"dArr", {226, 135, 147, 0}},
+{(unsigned char*)"dHar", {226, 165, 165, 0}},
+{(unsigned char*)"dagger", {226, 128, 160, 0}},
+{(unsigned char*)"daleth", {226, 132, 184, 0}},
+{(unsigned char*)"darr", {226, 134, 147, 0}},
+{(unsigned char*)"dash", {226, 128, 144, 0}},
+{(unsigned char*)"dashv", {226, 138, 163, 0}},
+{(unsigned char*)"dbkarow", {226, 164, 143, 0}},
+{(unsigned char*)"dblac", {203, 157, 0}},
+{(unsigned char*)"dcaron", {196, 143, 0}},
+{(unsigned char*)"dcy", {208, 180, 0}},
+{(unsigned char*)"dd", {226, 133, 134, 0}},
+{(unsigned char*)"ddagger", {226, 128, 161, 0}},
+{(unsigned char*)"ddarr", {226, 135, 138, 0}},
+{(unsigned char*)"ddotseq", {226, 169, 183, 0}},
+{(unsigned char*)"deg", {194, 176, 0}},
+{(unsigned char*)"delta", {206, 180, 0}},
+{(unsigned char*)"demptyv", {226, 166, 177, 0}},
+{(unsigned char*)"dfisht", {226, 165, 191, 0}},
+{(unsigned char*)"dfr", {240, 157, 148, 161, 0}},
+{(unsigned char*)"dharl", {226, 135, 131, 0}},
+{(unsigned char*)"dharr", {226, 135, 130, 0}},
+{(unsigned char*)"diam", {226, 139, 132, 0}},
+{(unsigned char*)"diamond", {226, 139, 132, 0}},
+{(unsigned char*)"diamondsuit", {226, 153, 166, 0}},
+{(unsigned char*)"diams", {226, 153, 166, 0}},
+{(unsigned char*)"die", {194, 168, 0}},
+{(unsigned char*)"digamma", {207, 157, 0}},
+{(unsigned char*)"disin", {226, 139, 178, 0}},
+{(unsigned char*)"div", {195, 183, 0}},
+{(unsigned char*)"divide", {195, 183, 0}},
+{(unsigned char*)"divideontimes", {226, 139, 135, 0}},
+{(unsigned char*)"divonx", {226, 139, 135, 0}},
+{(unsigned char*)"djcy", {209, 146, 0}},
+{(unsigned char*)"dlcorn", {226, 140, 158, 0}},
+{(unsigned char*)"dlcrop", {226, 140, 141, 0}},
+{(unsigned char*)"dollar", {36, 0}},
+{(unsigned char*)"dopf", {240, 157, 149, 149, 0}},
+{(unsigned char*)"dot", {203, 153, 0}},
+{(unsigned char*)"doteq", {226, 137, 144, 0}},
+{(unsigned char*)"doteqdot", {226, 137, 145, 0}},
+{(unsigned char*)"dotminus", {226, 136, 184, 0}},
+{(unsigned char*)"dotplus", {226, 136, 148, 0}},
+{(unsigned char*)"dotsquare", {226, 138, 161, 0}},
+{(unsigned char*)"doublebarwedge", {226, 140, 134, 0}},
+{(unsigned char*)"downarrow", {226, 134, 147, 0}},
+{(unsigned char*)"downdownarrows", {226, 135, 138, 0}},
+{(unsigned char*)"downharpoonleft", {226, 135, 131, 0}},
+{(unsigned char*)"downharpoonright", {226, 135, 130, 0}},
+{(unsigned char*)"drbkarow", {226, 164, 144, 0}},
+{(unsigned char*)"drcorn", {226, 140, 159, 0}},
+{(unsigned char*)"drcrop", {226, 140, 140, 0}},
+{(unsigned char*)"dscr", {240, 157, 146, 185, 0}},
+{(unsigned char*)"dscy", {209, 149, 0}},
+{(unsigned char*)"dsol", {226, 167, 182, 0}},
+{(unsigned char*)"dstrok", {196, 145, 0}},
+{(unsigned char*)"dtdot", {226, 139, 177, 0}},
+{(unsigned char*)"dtri", {226, 150, 191, 0}},
+{(unsigned char*)"dtrif", {226, 150, 190, 0}},
+{(unsigned char*)"duarr", {226, 135, 181, 0}},
+{(unsigned char*)"duhar", {226, 165, 175, 0}},
+{(unsigned char*)"dwangle", {226, 166, 166, 0}},
+{(unsigned char*)"dzcy", {209, 159, 0}},
+{(unsigned char*)"dzigrarr", {226, 159, 191, 0}},
+{(unsigned char*)"eDDot", {226, 169, 183, 0}},
+{(unsigned char*)"eDot", {226, 137, 145, 0}},
+{(unsigned char*)"eacute", {195, 169, 0}},
+{(unsigned char*)"easter", {226, 169, 174, 0}},
+{(unsigned char*)"ecaron", {196, 155, 0}},
+{(unsigned char*)"ecir", {226, 137, 150, 0}},
+{(unsigned char*)"ecirc", {195, 170, 0}},
+{(unsigned char*)"ecolon", {226, 137, 149, 0}},
+{(unsigned char*)"ecy", {209, 141, 0}},
+{(unsigned char*)"edot", {196, 151, 0}},
+{(unsigned char*)"ee", {226, 133, 135, 0}},
+{(unsigned char*)"efDot", {226, 137, 146, 0}},
+{(unsigned char*)"efr", {240, 157, 148, 162, 0}},
+{(unsigned char*)"eg", {226, 170, 154, 0}},
+{(unsigned char*)"egrave", {195, 168, 0}},
+{(unsigned char*)"egs", {226, 170, 150, 0}},
+{(unsigned char*)"egsdot", {226, 170, 152, 0}},
+{(unsigned char*)"el", {226, 170, 153, 0}},
+{(unsigned char*)"elinters", {226, 143, 167, 0}},
+{(unsigned char*)"ell", {226, 132, 147, 0}},
+{(unsigned char*)"els", {226, 170, 149, 0}},
+{(unsigned char*)"elsdot", {226, 170, 151, 0}},
+{(unsigned char*)"emacr", {196, 147, 0}},
+{(unsigned char*)"empty", {226, 136, 133, 0}},
+{(unsigned char*)"emptyset", {226, 136, 133, 0}},
+{(unsigned char*)"emptyv", {226, 136, 133, 0}},
+{(unsigned char*)"emsp", {226, 128, 131, 0}},
+{(unsigned char*)"emsp13", {226, 128, 132, 0}},
+{(unsigned char*)"emsp14", {226, 128, 133, 0}},
+{(unsigned char*)"eng", {197, 139, 0}},
+{(unsigned char*)"ensp", {226, 128, 130, 0}},
+{(unsigned char*)"eogon", {196, 153, 0}},
+{(unsigned char*)"eopf", {240, 157, 149, 150, 0}},
+{(unsigned char*)"epar", {226, 139, 149, 0}},
+{(unsigned char*)"eparsl", {226, 167, 163, 0}},
+{(unsigned char*)"eplus", {226, 169, 177, 0}},
+{(unsigned char*)"epsi", {206, 181, 0}},
+{(unsigned char*)"epsilon", {206, 181, 0}},
+{(unsigned char*)"epsiv", {207, 181, 0}},
+{(unsigned char*)"eqcirc", {226, 137, 150, 0}},
+{(unsigned char*)"eqcolon", {226, 137, 149, 0}},
+{(unsigned char*)"eqsim", {226, 137, 130, 0}},
+{(unsigned char*)"eqslantgtr", {226, 170, 150, 0}},
+{(unsigned char*)"eqslantless", {226, 170, 149, 0}},
+{(unsigned char*)"equals", {61, 0}},
+{(unsigned char*)"equest", {226, 137, 159, 0}},
+{(unsigned char*)"equiv", {226, 137, 161, 0}},
+{(unsigned char*)"equivDD", {226, 169, 184, 0}},
+{(unsigned char*)"eqvparsl", {226, 167, 165, 0}},
+{(unsigned char*)"erDot", {226, 137, 147, 0}},
+{(unsigned char*)"erarr", {226, 165, 177, 0}},
+{(unsigned char*)"escr", {226, 132, 175, 0}},
+{(unsigned char*)"esdot", {226, 137, 144, 0}},
+{(unsigned char*)"esim", {226, 137, 130, 0}},
+{(unsigned char*)"eta", {206, 183, 0}},
+{(unsigned char*)"eth", {195, 176, 0}},
+{(unsigned char*)"euml", {195, 171, 0}},
+{(unsigned char*)"euro", {226, 130, 172, 0}},
+{(unsigned char*)"excl", {33, 0}},
+{(unsigned char*)"exist", {226, 136, 131, 0}},
+{(unsigned char*)"expectation", {226, 132, 176, 0}},
+{(unsigned char*)"exponentiale", {226, 133, 135, 0}},
+{(unsigned char*)"fallingdotseq", {226, 137, 146, 0}},
+{(unsigned char*)"fcy", {209, 132, 0}},
+{(unsigned char*)"female", {226, 153, 128, 0}},
+{(unsigned char*)"ffilig", {239, 172, 131, 0}},
+{(unsigned char*)"fflig", {239, 172, 128, 0}},
+{(unsigned char*)"ffllig", {239, 172, 132, 0}},
+{(unsigned char*)"ffr", {240, 157, 148, 163, 0}},
+{(unsigned char*)"filig", {239, 172, 129, 0}},
+{(unsigned char*)"fjlig", {102, 106, 0}},
+{(unsigned char*)"flat", {226, 153, 173, 0}},
+{(unsigned char*)"fllig", {239, 172, 130, 0}},
+{(unsigned char*)"fltns", {226, 150, 177, 0}},
+{(unsigned char*)"fnof", {198, 146, 0}},
+{(unsigned char*)"fopf", {240, 157, 149, 151, 0}},
+{(unsigned char*)"forall", {226, 136, 128, 0}},
+{(unsigned char*)"fork", {226, 139, 148, 0}},
+{(unsigned char*)"forkv", {226, 171, 153, 0}},
+{(unsigned char*)"fpartint", {226, 168, 141, 0}},
+{(unsigned char*)"frac12", {194, 189, 0}},
+{(unsigned char*)"frac13", {226, 133, 147, 0}},
+{(unsigned char*)"frac14", {194, 188, 0}},
+{(unsigned char*)"frac15", {226, 133, 149, 0}},
+{(unsigned char*)"frac16", {226, 133, 153, 0}},
+{(unsigned char*)"frac18", {226, 133, 155, 0}},
+{(unsigned char*)"frac23", {226, 133, 148, 0}},
+{(unsigned char*)"frac25", {226, 133, 150, 0}},
+{(unsigned char*)"frac34", {194, 190, 0}},
+{(unsigned char*)"frac35", {226, 133, 151, 0}},
+{(unsigned char*)"frac38", {226, 133, 156, 0}},
+{(unsigned char*)"frac45", {226, 133, 152, 0}},
+{(unsigned char*)"frac56", {226, 133, 154, 0}},
+{(unsigned char*)"frac58", {226, 133, 157, 0}},
+{(unsigned char*)"frac78", {226, 133, 158, 0}},
+{(unsigned char*)"frasl", {226, 129, 132, 0}},
+{(unsigned char*)"frown", {226, 140, 162, 0}},
+{(unsigned char*)"fscr", {240, 157, 146, 187, 0}},
+{(unsigned char*)"gE", {226, 137, 167, 0}},
+{(unsigned char*)"gEl", {226, 170, 140, 0}},
+{(unsigned char*)"gacute", {199, 181, 0}},
+{(unsigned char*)"gamma", {206, 179, 0}},
+{(unsigned char*)"gammad", {207, 157, 0}},
+{(unsigned char*)"gap", {226, 170, 134, 0}},
+{(unsigned char*)"gbreve", {196, 159, 0}},
+{(unsigned char*)"gcirc", {196, 157, 0}},
+{(unsigned char*)"gcy", {208, 179, 0}},
+{(unsigned char*)"gdot", {196, 161, 0}},
+{(unsigned char*)"ge", {226, 137, 165, 0}},
+{(unsigned char*)"gel", {226, 139, 155, 0}},
+{(unsigned char*)"geq", {226, 137, 165, 0}},
+{(unsigned char*)"geqq", {226, 137, 167, 0}},
+{(unsigned char*)"geqslant", {226, 169, 190, 0}},
+{(unsigned char*)"ges", {226, 169, 190, 0}},
+{(unsigned char*)"gescc", {226, 170, 169, 0}},
+{(unsigned char*)"gesdot", {226, 170, 128, 0}},
+{(unsigned char*)"gesdoto", {226, 170, 130, 0}},
+{(unsigned char*)"gesdotol", {226, 170, 132, 0}},
+{(unsigned char*)"gesl", {226, 139, 155, 239, 184, 128, 0}},
+{(unsigned char*)"gesles", {226, 170, 148, 0}},
+{(unsigned char*)"gfr", {240, 157, 148, 164, 0}},
+{(unsigned char*)"gg", {226, 137, 171, 0}},
+{(unsigned char*)"ggg", {226, 139, 153, 0}},
+{(unsigned char*)"gimel", {226, 132, 183, 0}},
+{(unsigned char*)"gjcy", {209, 147, 0}},
+{(unsigned char*)"gl", {226, 137, 183, 0}},
+{(unsigned char*)"glE", {226, 170, 146, 0}},
+{(unsigned char*)"gla", {226, 170, 165, 0}},
+{(unsigned char*)"glj", {226, 170, 164, 0}},
+{(unsigned char*)"gnE", {226, 137, 169, 0}},
+{(unsigned char*)"gnap", {226, 170, 138, 0}},
+{(unsigned char*)"gnapprox", {226, 170, 138, 0}},
+{(unsigned char*)"gne", {226, 170, 136, 0}},
+{(unsigned char*)"gneq", {226, 170, 136, 0}},
+{(unsigned char*)"gneqq", {226, 137, 169, 0}},
+{(unsigned char*)"gnsim", {226, 139, 167, 0}},
+{(unsigned char*)"gopf", {240, 157, 149, 152, 0}},
+{(unsigned char*)"grave", {96, 0}},
+{(unsigned char*)"gscr", {226, 132, 138, 0}},
+{(unsigned char*)"gsim", {226, 137, 179, 0}},
+{(unsigned char*)"gsime", {226, 170, 142, 0}},
+{(unsigned char*)"gsiml", {226, 170, 144, 0}},
+{(unsigned char*)"gt", {62, 0}},
+{(unsigned char*)"gtcc", {226, 170, 167, 0}},
+{(unsigned char*)"gtcir", {226, 169, 186, 0}},
+{(unsigned char*)"gtdot", {226, 139, 151, 0}},
+{(unsigned char*)"gtlPar", {226, 166, 149, 0}},
+{(unsigned char*)"gtquest", {226, 169, 188, 0}},
+{(unsigned char*)"gtrapprox", {226, 170, 134, 0}},
+{(unsigned char*)"gtrarr", {226, 165, 184, 0}},
+{(unsigned char*)"gtrdot", {226, 139, 151, 0}},
+{(unsigned char*)"gtreqless", {226, 139, 155, 0}},
+{(unsigned char*)"gtreqqless", {226, 170, 140, 0}},
+{(unsigned char*)"gtrless", {226, 137, 183, 0}},
+{(unsigned char*)"gtrsim", {226, 137, 179, 0}},
+{(unsigned char*)"gvertneqq", {226, 137, 169, 239, 184, 128, 0}},
+{(unsigned char*)"gvnE", {226, 137, 169, 239, 184, 128, 0}},
+{(unsigned char*)"hArr", {226, 135, 148, 0}},
+{(unsigned char*)"hairsp", {226, 128, 138, 0}},
+{(unsigned char*)"half", {194, 189, 0}},
+{(unsigned char*)"hamilt", {226, 132, 139, 0}},
+{(unsigned char*)"hardcy", {209, 138, 0}},
+{(unsigned char*)"harr", {226, 134, 148, 0}},
+{(unsigned char*)"harrcir", {226, 165, 136, 0}},
+{(unsigned char*)"harrw", {226, 134, 173, 0}},
+{(unsigned char*)"hbar", {226, 132, 143, 0}},
+{(unsigned char*)"hcirc", {196, 165, 0}},
+{(unsigned char*)"hearts", {226, 153, 165, 0}},
+{(unsigned char*)"heartsuit", {226, 153, 165, 0}},
+{(unsigned char*)"hellip", {226, 128, 166, 0}},
+{(unsigned char*)"hercon", {226, 138, 185, 0}},
+{(unsigned char*)"hfr", {240, 157, 148, 165, 0}},
+{(unsigned char*)"hksearow", {226, 164, 165, 0}},
+{(unsigned char*)"hkswarow", {226, 164, 166, 0}},
+{(unsigned char*)"hoarr", {226, 135, 191, 0}},
+{(unsigned char*)"homtht", {226, 136, 187, 0}},
+{(unsigned char*)"hookleftarrow", {226, 134, 169, 0}},
+{(unsigned char*)"hookrightarrow", {226, 134, 170, 0}},
+{(unsigned char*)"hopf", {240, 157, 149, 153, 0}},
+{(unsigned char*)"horbar", {226, 128, 149, 0}},
+{(unsigned char*)"hscr", {240, 157, 146, 189, 0}},
+{(unsigned char*)"hslash", {226, 132, 143, 0}},
+{(unsigned char*)"hstrok", {196, 167, 0}},
+{(unsigned char*)"hybull", {226, 129, 131, 0}},
+{(unsigned char*)"hyphen", {226, 128, 144, 0}},
+{(unsigned char*)"iacute", {195, 173, 0}},
+{(unsigned char*)"ic", {226, 129, 163, 0}},
+{(unsigned char*)"icirc", {195, 174, 0}},
+{(unsigned char*)"icy", {208, 184, 0}},
+{(unsigned char*)"iecy", {208, 181, 0}},
+{(unsigned char*)"iexcl", {194, 161, 0}},
+{(unsigned char*)"iff", {226, 135, 148, 0}},
+{(unsigned char*)"ifr", {240, 157, 148, 166, 0}},
+{(unsigned char*)"igrave", {195, 172, 0}},
+{(unsigned char*)"ii", {226, 133, 136, 0}},
+{(unsigned char*)"iiiint", {226, 168, 140, 0}},
+{(unsigned char*)"iiint", {226, 136, 173, 0}},
+{(unsigned char*)"iinfin", {226, 167, 156, 0}},
+{(unsigned char*)"iiota", {226, 132, 169, 0}},
+{(unsigned char*)"ijlig", {196, 179, 0}},
+{(unsigned char*)"imacr", {196, 171, 0}},
+{(unsigned char*)"image", {226, 132, 145, 0}},
+{(unsigned char*)"imagline", {226, 132, 144, 0}},
+{(unsigned char*)"imagpart", {226, 132, 145, 0}},
+{(unsigned char*)"imath", {196, 177, 0}},
+{(unsigned char*)"imof", {226, 138, 183, 0}},
+{(unsigned char*)"imped", {198, 181, 0}},
+{(unsigned char*)"in", {226, 136, 136, 0}},
+{(unsigned char*)"incare", {226, 132, 133, 0}},
+{(unsigned char*)"infin", {226, 136, 158, 0}},
+{(unsigned char*)"infintie", {226, 167, 157, 0}},
+{(unsigned char*)"inodot", {196, 177, 0}},
+{(unsigned char*)"int", {226, 136, 171, 0}},
+{(unsigned char*)"intcal", {226, 138, 186, 0}},
+{(unsigned char*)"integers", {226, 132, 164, 0}},
+{(unsigned char*)"intercal", {226, 138, 186, 0}},
+{(unsigned char*)"intlarhk", {226, 168, 151, 0}},
+{(unsigned char*)"intprod", {226, 168, 188, 0}},
+{(unsigned char*)"iocy", {209, 145, 0}},
+{(unsigned char*)"iogon", {196, 175, 0}},
+{(unsigned char*)"iopf", {240, 157, 149, 154, 0}},
+{(unsigned char*)"iota", {206, 185, 0}},
+{(unsigned char*)"iprod", {226, 168, 188, 0}},
+{(unsigned char*)"iquest", {194, 191, 0}},
+{(unsigned char*)"iscr", {240, 157, 146, 190, 0}},
+{(unsigned char*)"isin", {226, 136, 136, 0}},
+{(unsigned char*)"isinE", {226, 139, 185, 0}},
+{(unsigned char*)"isindot", {226, 139, 181, 0}},
+{(unsigned char*)"isins", {226, 139, 180, 0}},
+{(unsigned char*)"isinsv", {226, 139, 179, 0}},
+{(unsigned char*)"isinv", {226, 136, 136, 0}},
+{(unsigned char*)"it", {226, 129, 162, 0}},
+{(unsigned char*)"itilde", {196, 169, 0}},
+{(unsigned char*)"iukcy", {209, 150, 0}},
+{(unsigned char*)"iuml", {195, 175, 0}},
+{(unsigned char*)"jcirc", {196, 181, 0}},
+{(unsigned char*)"jcy", {208, 185, 0}},
+{(unsigned char*)"jfr", {240, 157, 148, 167, 0}},
+{(unsigned char*)"jmath", {200, 183, 0}},
+{(unsigned char*)"jopf", {240, 157, 149, 155, 0}},
+{(unsigned char*)"jscr", {240, 157, 146, 191, 0}},
+{(unsigned char*)"jsercy", {209, 152, 0}},
+{(unsigned char*)"jukcy", {209, 148, 0}},
+{(unsigned char*)"kappa", {206, 186, 0}},
+{(unsigned char*)"kappav", {207, 176, 0}},
+{(unsigned char*)"kcedil", {196, 183, 0}},
+{(unsigned char*)"kcy", {208, 186, 0}},
+{(unsigned char*)"kfr", {240, 157, 148, 168, 0}},
+{(unsigned char*)"kgreen", {196, 184, 0}},
+{(unsigned char*)"khcy", {209, 133, 0}},
+{(unsigned char*)"kjcy", {209, 156, 0}},
+{(unsigned char*)"kopf", {240, 157, 149, 156, 0}},
+{(unsigned char*)"kscr", {240, 157, 147, 128, 0}},
+{(unsigned char*)"lAarr", {226, 135, 154, 0}},
+{(unsigned char*)"lArr", {226, 135, 144, 0}},
+{(unsigned char*)"lAtail", {226, 164, 155, 0}},
+{(unsigned char*)"lBarr", {226, 164, 142, 0}},
+{(unsigned char*)"lE", {226, 137, 166, 0}},
+{(unsigned char*)"lEg", {226, 170, 139, 0}},
+{(unsigned char*)"lHar", {226, 165, 162, 0}},
+{(unsigned char*)"lacute", {196, 186, 0}},
+{(unsigned char*)"laemptyv", {226, 166, 180, 0}},
+{(unsigned char*)"lagran", {226, 132, 146, 0}},
+{(unsigned char*)"lambda", {206, 187, 0}},
+{(unsigned char*)"lang", {226, 159, 168, 0}},
+{(unsigned char*)"langd", {226, 166, 145, 0}},
+{(unsigned char*)"langle", {226, 159, 168, 0}},
+{(unsigned char*)"lap", {226, 170, 133, 0}},
+{(unsigned char*)"laquo", {194, 171, 0}},
+{(unsigned char*)"larr", {226, 134, 144, 0}},
+{(unsigned char*)"larrb", {226, 135, 164, 0}},
+{(unsigned char*)"larrbfs", {226, 164, 159, 0}},
+{(unsigned char*)"larrfs", {226, 164, 157, 0}},
+{(unsigned char*)"larrhk", {226, 134, 169, 0}},
+{(unsigned char*)"larrlp", {226, 134, 171, 0}},
+{(unsigned char*)"larrpl", {226, 164, 185, 0}},
+{(unsigned char*)"larrsim", {226, 165, 179, 0}},
+{(unsigned char*)"larrtl", {226, 134, 162, 0}},
+{(unsigned char*)"lat", {226, 170, 171, 0}},
+{(unsigned char*)"latail", {226, 164, 153, 0}},
+{(unsigned char*)"late", {226, 170, 173, 0}},
+{(unsigned char*)"lates", {226, 170, 173, 239, 184, 128, 0}},
+{(unsigned char*)"lbarr", {226, 164, 140, 0}},
+{(unsigned char*)"lbbrk", {226, 157, 178, 0}},
+{(unsigned char*)"lbrace", {123, 0}},
+{(unsigned char*)"lbrack", {91, 0}},
+{(unsigned char*)"lbrke", {226, 166, 139, 0}},
+{(unsigned char*)"lbrksld", {226, 166, 143, 0}},
+{(unsigned char*)"lbrkslu", {226, 166, 141, 0}},
+{(unsigned char*)"lcaron", {196, 190, 0}},
+{(unsigned char*)"lcedil", {196, 188, 0}},
+{(unsigned char*)"lceil", {226, 140, 136, 0}},
+{(unsigned char*)"lcub", {123, 0}},
+{(unsigned char*)"lcy", {208, 187, 0}},
+{(unsigned char*)"ldca", {226, 164, 182, 0}},
+{(unsigned char*)"ldquo", {226, 128, 156, 0}},
+{(unsigned char*)"ldquor", {226, 128, 158, 0}},
+{(unsigned char*)"ldrdhar", {226, 165, 167, 0}},
+{(unsigned char*)"ldrushar", {226, 165, 139, 0}},
+{(unsigned char*)"ldsh", {226, 134, 178, 0}},
+{(unsigned char*)"le", {226, 137, 164, 0}},
+{(unsigned char*)"leftarrow", {226, 134, 144, 0}},
+{(unsigned char*)"leftarrowtail", {226, 134, 162, 0}},
+{(unsigned char*)"leftharpoondown", {226, 134, 189, 0}},
+{(unsigned char*)"leftharpoonup", {226, 134, 188, 0}},
+{(unsigned char*)"leftleftarrows", {226, 135, 135, 0}},
+{(unsigned char*)"leftrightarrow", {226, 134, 148, 0}},
+{(unsigned char*)"leftrightarrows", {226, 135, 134, 0}},
+{(unsigned char*)"leftrightharpoons", {226, 135, 139, 0}},
+{(unsigned char*)"leftrightsquigarrow", {226, 134, 173, 0}},
+{(unsigned char*)"leftthreetimes", {226, 139, 139, 0}},
+{(unsigned char*)"leg", {226, 139, 154, 0}},
+{(unsigned char*)"leq", {226, 137, 164, 0}},
+{(unsigned char*)"leqq", {226, 137, 166, 0}},
+{(unsigned char*)"leqslant", {226, 169, 189, 0}},
+{(unsigned char*)"les", {226, 169, 189, 0}},
+{(unsigned char*)"lescc", {226, 170, 168, 0}},
+{(unsigned char*)"lesdot", {226, 169, 191, 0}},
+{(unsigned char*)"lesdoto", {226, 170, 129, 0}},
+{(unsigned char*)"lesdotor", {226, 170, 131, 0}},
+{(unsigned char*)"lesg", {226, 139, 154, 239, 184, 128, 0}},
+{(unsigned char*)"lesges", {226, 170, 147, 0}},
+{(unsigned char*)"lessapprox", {226, 170, 133, 0}},
+{(unsigned char*)"lessdot", {226, 139, 150, 0}},
+{(unsigned char*)"lesseqgtr", {226, 139, 154, 0}},
+{(unsigned char*)"lesseqqgtr", {226, 170, 139, 0}},
+{(unsigned char*)"lessgtr", {226, 137, 182, 0}},
+{(unsigned char*)"lesssim", {226, 137, 178, 0}},
+{(unsigned char*)"lfisht", {226, 165, 188, 0}},
+{(unsigned char*)"lfloor", {226, 140, 138, 0}},
+{(unsigned char*)"lfr", {240, 157, 148, 169, 0}},
+{(unsigned char*)"lg", {226, 137, 182, 0}},
+{(unsigned char*)"lgE", {226, 170, 145, 0}},
+{(unsigned char*)"lhard", {226, 134, 189, 0}},
+{(unsigned char*)"lharu", {226, 134, 188, 0}},
+{(unsigned char*)"lharul", {226, 165, 170, 0}},
+{(unsigned char*)"lhblk", {226, 150, 132, 0}},
+{(unsigned char*)"ljcy", {209, 153, 0}},
+{(unsigned char*)"ll", {226, 137, 170, 0}},
+{(unsigned char*)"llarr", {226, 135, 135, 0}},
+{(unsigned char*)"llcorner", {226, 140, 158, 0}},
+{(unsigned char*)"llhard", {226, 165, 171, 0}},
+{(unsigned char*)"lltri", {226, 151, 186, 0}},
+{(unsigned char*)"lmidot", {197, 128, 0}},
+{(unsigned char*)"lmoust", {226, 142, 176, 0}},
+{(unsigned char*)"lmoustache", {226, 142, 176, 0}},
+{(unsigned char*)"lnE", {226, 137, 168, 0}},
+{(unsigned char*)"lnap", {226, 170, 137, 0}},
+{(unsigned char*)"lnapprox", {226, 170, 137, 0}},
+{(unsigned char*)"lne", {226, 170, 135, 0}},
+{(unsigned char*)"lneq", {226, 170, 135, 0}},
+{(unsigned char*)"lneqq", {226, 137, 168, 0}},
+{(unsigned char*)"lnsim", {226, 139, 166, 0}},
+{(unsigned char*)"loang", {226, 159, 172, 0}},
+{(unsigned char*)"loarr", {226, 135, 189, 0}},
+{(unsigned char*)"lobrk", {226, 159, 166, 0}},
+{(unsigned char*)"longleftarrow", {226, 159, 181, 0}},
+{(unsigned char*)"longleftrightarrow", {226, 159, 183, 0}},
+{(unsigned char*)"longmapsto", {226, 159, 188, 0}},
+{(unsigned char*)"longrightarrow", {226, 159, 182, 0}},
+{(unsigned char*)"looparrowleft", {226, 134, 171, 0}},
+{(unsigned char*)"looparrowright", {226, 134, 172, 0}},
+{(unsigned char*)"lopar", {226, 166, 133, 0}},
+{(unsigned char*)"lopf", {240, 157, 149, 157, 0}},
+{(unsigned char*)"loplus", {226, 168, 173, 0}},
+{(unsigned char*)"lotimes", {226, 168, 180, 0}},
+{(unsigned char*)"lowast", {226, 136, 151, 0}},
+{(unsigned char*)"lowbar", {95, 0}},
+{(unsigned char*)"loz", {226, 151, 138, 0}},
+{(unsigned char*)"lozenge", {226, 151, 138, 0}},
+{(unsigned char*)"lozf", {226, 167, 171, 0}},
+{(unsigned char*)"lpar", {40, 0}},
+{(unsigned char*)"lparlt", {226, 166, 147, 0}},
+{(unsigned char*)"lrarr", {226, 135, 134, 0}},
+{(unsigned char*)"lrcorner", {226, 140, 159, 0}},
+{(unsigned char*)"lrhar", {226, 135, 139, 0}},
+{(unsigned char*)"lrhard", {226, 165, 173, 0}},
+{(unsigned char*)"lrm", {226, 128, 142, 0}},
+{(unsigned char*)"lrtri", {226, 138, 191, 0}},
+{(unsigned char*)"lsaquo", {226, 128, 185, 0}},
+{(unsigned char*)"lscr", {240, 157, 147, 129, 0}},
+{(unsigned char*)"lsh", {226, 134, 176, 0}},
+{(unsigned char*)"lsim", {226, 137, 178, 0}},
+{(unsigned char*)"lsime", {226, 170, 141, 0}},
+{(unsigned char*)"lsimg", {226, 170, 143, 0}},
+{(unsigned char*)"lsqb", {91, 0}},
+{(unsigned char*)"lsquo", {226, 128, 152, 0}},
+{(unsigned char*)"lsquor", {226, 128, 154, 0}},
+{(unsigned char*)"lstrok", {197, 130, 0}},
+{(unsigned char*)"lt", {60, 0}},
+{(unsigned char*)"ltcc", {226, 170, 166, 0}},
+{(unsigned char*)"ltcir", {226, 169, 185, 0}},
+{(unsigned char*)"ltdot", {226, 139, 150, 0}},
+{(unsigned char*)"lthree", {226, 139, 139, 0}},
+{(unsigned char*)"ltimes", {226, 139, 137, 0}},
+{(unsigned char*)"ltlarr", {226, 165, 182, 0}},
+{(unsigned char*)"ltquest", {226, 169, 187, 0}},
+{(unsigned char*)"ltrPar", {226, 166, 150, 0}},
+{(unsigned char*)"ltri", {226, 151, 131, 0}},
+{(unsigned char*)"ltrie", {226, 138, 180, 0}},
+{(unsigned char*)"ltrif", {226, 151, 130, 0}},
+{(unsigned char*)"lurdshar", {226, 165, 138, 0}},
+{(unsigned char*)"luruhar", {226, 165, 166, 0}},
+{(unsigned char*)"lvertneqq", {226, 137, 168, 239, 184, 128, 0}},
+{(unsigned char*)"lvnE", {226, 137, 168, 239, 184, 128, 0}},
+{(unsigned char*)"mDDot", {226, 136, 186, 0}},
+{(unsigned char*)"macr", {194, 175, 0}},
+{(unsigned char*)"male", {226, 153, 130, 0}},
+{(unsigned char*)"malt", {226, 156, 160, 0}},
+{(unsigned char*)"maltese", {226, 156, 160, 0}},
+{(unsigned char*)"map", {226, 134, 166, 0}},
+{(unsigned char*)"mapsto", {226, 134, 166, 0}},
+{(unsigned char*)"mapstodown", {226, 134, 167, 0}},
+{(unsigned char*)"mapstoleft", {226, 134, 164, 0}},
+{(unsigned char*)"mapstoup", {226, 134, 165, 0}},
+{(unsigned char*)"marker", {226, 150, 174, 0}},
+{(unsigned char*)"mcomma", {226, 168, 169, 0}},
+{(unsigned char*)"mcy", {208, 188, 0}},
+{(unsigned char*)"mdash", {226, 128, 148, 0}},
+{(unsigned char*)"measuredangle", {226, 136, 161, 0}},
+{(unsigned char*)"mfr", {240, 157, 148, 170, 0}},
+{(unsigned char*)"mho", {226, 132, 167, 0}},
+{(unsigned char*)"micro", {194, 181, 0}},
+{(unsigned char*)"mid", {226, 136, 163, 0}},
+{(unsigned char*)"midast", {42, 0}},
+{(unsigned char*)"midcir", {226, 171, 176, 0}},
+{(unsigned char*)"middot", {194, 183, 0}},
+{(unsigned char*)"minus", {226, 136, 146, 0}},
+{(unsigned char*)"minusb", {226, 138, 159, 0}},
+{(unsigned char*)"minusd", {226, 136, 184, 0}},
+{(unsigned char*)"minusdu", {226, 168, 170, 0}},
+{(unsigned char*)"mlcp", {226, 171, 155, 0}},
+{(unsigned char*)"mldr", {226, 128, 166, 0}},
+{(unsigned char*)"mnplus", {226, 136, 147, 0}},
+{(unsigned char*)"models", {226, 138, 167, 0}},
+{(unsigned char*)"mopf", {240, 157, 149, 158, 0}},
+{(unsigned char*)"mp", {226, 136, 147, 0}},
+{(unsigned char*)"mscr", {240, 157, 147, 130, 0}},
+{(unsigned char*)"mstpos", {226, 136, 190, 0}},
+{(unsigned char*)"mu", {206, 188, 0}},
+{(unsigned char*)"multimap", {226, 138, 184, 0}},
+{(unsigned char*)"mumap", {226, 138, 184, 0}},
+{(unsigned char*)"nGg", {226, 139, 153, 204, 184, 0}},
+{(unsigned char*)"nGt", {226, 137, 171, 226, 131, 146, 0}},
+{(unsigned char*)"nGtv", {226, 137, 171, 204, 184, 0}},
+{(unsigned char*)"nLeftarrow", {226, 135, 141, 0}},
+{(unsigned char*)"nLeftrightarrow", {226, 135, 142, 0}},
+{(unsigned char*)"nLl", {226, 139, 152, 204, 184, 0}},
+{(unsigned char*)"nLt", {226, 137, 170, 226, 131, 146, 0}},
+{(unsigned char*)"nLtv", {226, 137, 170, 204, 184, 0}},
+{(unsigned char*)"nRightarrow", {226, 135, 143, 0}},
+{(unsigned char*)"nVDash", {226, 138, 175, 0}},
+{(unsigned char*)"nVdash", {226, 138, 174, 0}},
+{(unsigned char*)"nabla", {226, 136, 135, 0}},
+{(unsigned char*)"nacute", {197, 132, 0}},
+{(unsigned char*)"nang", {226, 136, 160, 226, 131, 146, 0}},
+{(unsigned char*)"nap", {226, 137, 137, 0}},
+{(unsigned char*)"napE", {226, 169, 176, 204, 184, 0}},
+{(unsigned char*)"napid", {226, 137, 139, 204, 184, 0}},
+{(unsigned char*)"napos", {197, 137, 0}},
+{(unsigned char*)"napprox", {226, 137, 137, 0}},
+{(unsigned char*)"natur", {226, 153, 174, 0}},
+{(unsigned char*)"natural", {226, 153, 174, 0}},
+{(unsigned char*)"naturals", {226, 132, 149, 0}},
+{(unsigned char*)"nbsp", {194, 160, 0}},
+{(unsigned char*)"nbump", {226, 137, 142, 204, 184, 0}},
+{(unsigned char*)"nbumpe", {226, 137, 143, 204, 184, 0}},
+{(unsigned char*)"ncap", {226, 169, 131, 0}},
+{(unsigned char*)"ncaron", {197, 136, 0}},
+{(unsigned char*)"ncedil", {197, 134, 0}},
+{(unsigned char*)"ncong", {226, 137, 135, 0}},
+{(unsigned char*)"ncongdot", {226, 169, 173, 204, 184, 0}},
+{(unsigned char*)"ncup", {226, 169, 130, 0}},
+{(unsigned char*)"ncy", {208, 189, 0}},
+{(unsigned char*)"ndash", {226, 128, 147, 0}},
+{(unsigned char*)"ne", {226, 137, 160, 0}},
+{(unsigned char*)"neArr", {226, 135, 151, 0}},
+{(unsigned char*)"nearhk", {226, 164, 164, 0}},
+{(unsigned char*)"nearr", {226, 134, 151, 0}},
+{(unsigned char*)"nearrow", {226, 134, 151, 0}},
+{(unsigned char*)"nedot", {226, 137, 144, 204, 184, 0}},
+{(unsigned char*)"nequiv", {226, 137, 162, 0}},
+{(unsigned char*)"nesear", {226, 164, 168, 0}},
+{(unsigned char*)"nesim", {226, 137, 130, 204, 184, 0}},
+{(unsigned char*)"nexist", {226, 136, 132, 0}},
+{(unsigned char*)"nexists", {226, 136, 132, 0}},
+{(unsigned char*)"nfr", {240, 157, 148, 171, 0}},
+{(unsigned char*)"ngE", {226, 137, 167, 204, 184, 0}},
+{(unsigned char*)"nge", {226, 137, 177, 0}},
+{(unsigned char*)"ngeq", {226, 137, 177, 0}},
+{(unsigned char*)"ngeqq", {226, 137, 167, 204, 184, 0}},
+{(unsigned char*)"ngeqslant", {226, 169, 190, 204, 184, 0}},
+{(unsigned char*)"nges", {226, 169, 190, 204, 184, 0}},
+{(unsigned char*)"ngsim", {226, 137, 181, 0}},
+{(unsigned char*)"ngt", {226, 137, 175, 0}},
+{(unsigned char*)"ngtr", {226, 137, 175, 0}},
+{(unsigned char*)"nhArr", {226, 135, 142, 0}},
+{(unsigned char*)"nharr", {226, 134, 174, 0}},
+{(unsigned char*)"nhpar", {226, 171, 178, 0}},
+{(unsigned char*)"ni", {226, 136, 139, 0}},
+{(unsigned char*)"nis", {226, 139, 188, 0}},
+{(unsigned char*)"nisd", {226, 139, 186, 0}},
+{(unsigned char*)"niv", {226, 136, 139, 0}},
+{(unsigned char*)"njcy", {209, 154, 0}},
+{(unsigned char*)"nlArr", {226, 135, 141, 0}},
+{(unsigned char*)"nlE", {226, 137, 166, 204, 184, 0}},
+{(unsigned char*)"nlarr", {226, 134, 154, 0}},
+{(unsigned char*)"nldr", {226, 128, 165, 0}},
+{(unsigned char*)"nle", {226, 137, 176, 0}},
+{(unsigned char*)"nleftarrow", {226, 134, 154, 0}},
+{(unsigned char*)"nleftrightarrow", {226, 134, 174, 0}},
+{(unsigned char*)"nleq", {226, 137, 176, 0}},
+{(unsigned char*)"nleqq", {226, 137, 166, 204, 184, 0}},
+{(unsigned char*)"nleqslant", {226, 169, 189, 204, 184, 0}},
+{(unsigned char*)"nles", {226, 169, 189, 204, 184, 0}},
+{(unsigned char*)"nless", {226, 137, 174, 0}},
+{(unsigned char*)"nlsim", {226, 137, 180, 0}},
+{(unsigned char*)"nlt", {226, 137, 174, 0}},
+{(unsigned char*)"nltri", {226, 139, 170, 0}},
+{(unsigned char*)"nltrie", {226, 139, 172, 0}},
+{(unsigned char*)"nmid", {226, 136, 164, 0}},
+{(unsigned char*)"nopf", {240, 157, 149, 159, 0}},
+{(unsigned char*)"not", {194, 172, 0}},
+{(unsigned char*)"notin", {226, 136, 137, 0}},
+{(unsigned char*)"notinE", {226, 139, 185, 204, 184, 0}},
+{(unsigned char*)"notindot", {226, 139, 181, 204, 184, 0}},
+{(unsigned char*)"notinva", {226, 136, 137, 0}},
+{(unsigned char*)"notinvb", {226, 139, 183, 0}},
+{(unsigned char*)"notinvc", {226, 139, 182, 0}},
+{(unsigned char*)"notni", {226, 136, 140, 0}},
+{(unsigned char*)"notniva", {226, 136, 140, 0}},
+{(unsigned char*)"notnivb", {226, 139, 190, 0}},
+{(unsigned char*)"notnivc", {226, 139, 189, 0}},
+{(unsigned char*)"npar", {226, 136, 166, 0}},
+{(unsigned char*)"nparallel", {226, 136, 166, 0}},
+{(unsigned char*)"nparsl", {226, 171, 189, 226, 131, 165, 0}},
+{(unsigned char*)"npart", {226, 136, 130, 204, 184, 0}},
+{(unsigned char*)"npolint", {226, 168, 148, 0}},
+{(unsigned char*)"npr", {226, 138, 128, 0}},
+{(unsigned char*)"nprcue", {226, 139, 160, 0}},
+{(unsigned char*)"npre", {226, 170, 175, 204, 184, 0}},
+{(unsigned char*)"nprec", {226, 138, 128, 0}},
+{(unsigned char*)"npreceq", {226, 170, 175, 204, 184, 0}},
+{(unsigned char*)"nrArr", {226, 135, 143, 0}},
+{(unsigned char*)"nrarr", {226, 134, 155, 0}},
+{(unsigned char*)"nrarrc", {226, 164, 179, 204, 184, 0}},
+{(unsigned char*)"nrarrw", {226, 134, 157, 204, 184, 0}},
+{(unsigned char*)"nrightarrow", {226, 134, 155, 0}},
+{(unsigned char*)"nrtri", {226, 139, 171, 0}},
+{(unsigned char*)"nrtrie", {226, 139, 173, 0}},
+{(unsigned char*)"nsc", {226, 138, 129, 0}},
+{(unsigned char*)"nsccue", {226, 139, 161, 0}},
+{(unsigned char*)"nsce", {226, 170, 176, 204, 184, 0}},
+{(unsigned char*)"nscr", {240, 157, 147, 131, 0}},
+{(unsigned char*)"nshortmid", {226, 136, 164, 0}},
+{(unsigned char*)"nshortparallel", {226, 136, 166, 0}},
+{(unsigned char*)"nsim", {226, 137, 129, 0}},
+{(unsigned char*)"nsime", {226, 137, 132, 0}},
+{(unsigned char*)"nsimeq", {226, 137, 132, 0}},
+{(unsigned char*)"nsmid", {226, 136, 164, 0}},
+{(unsigned char*)"nspar", {226, 136, 166, 0}},
+{(unsigned char*)"nsqsube", {226, 139, 162, 0}},
+{(unsigned char*)"nsqsupe", {226, 139, 163, 0}},
+{(unsigned char*)"nsub", {226, 138, 132, 0}},
+{(unsigned char*)"nsubE", {226, 171, 133, 204, 184, 0}},
+{(unsigned char*)"nsube", {226, 138, 136, 0}},
+{(unsigned char*)"nsubset", {226, 138, 130, 226, 131, 146, 0}},
+{(unsigned char*)"nsubseteq", {226, 138, 136, 0}},
+{(unsigned char*)"nsubseteqq", {226, 171, 133, 204, 184, 0}},
+{(unsigned char*)"nsucc", {226, 138, 129, 0}},
+{(unsigned char*)"nsucceq", {226, 170, 176, 204, 184, 0}},
+{(unsigned char*)"nsup", {226, 138, 133, 0}},
+{(unsigned char*)"nsupE", {226, 171, 134, 204, 184, 0}},
+{(unsigned char*)"nsupe", {226, 138, 137, 0}},
+{(unsigned char*)"nsupset", {226, 138, 131, 226, 131, 146, 0}},
+{(unsigned char*)"nsupseteq", {226, 138, 137, 0}},
+{(unsigned char*)"nsupseteqq", {226, 171, 134, 204, 184, 0}},
+{(unsigned char*)"ntgl", {226, 137, 185, 0}},
+{(unsigned char*)"ntilde", {195, 177, 0}},
+{(unsigned char*)"ntlg", {226, 137, 184, 0}},
+{(unsigned char*)"ntriangleleft", {226, 139, 170, 0}},
+{(unsigned char*)"ntrianglelefteq", {226, 139, 172, 0}},
+{(unsigned char*)"ntriangleright", {226, 139, 171, 0}},
+{(unsigned char*)"ntrianglerighteq", {226, 139, 173, 0}},
+{(unsigned char*)"nu", {206, 189, 0}},
+{(unsigned char*)"num", {35, 0}},
+{(unsigned char*)"numero", {226, 132, 150, 0}},
+{(unsigned char*)"numsp", {226, 128, 135, 0}},
+{(unsigned char*)"nvDash", {226, 138, 173, 0}},
+{(unsigned char*)"nvHarr", {226, 164, 132, 0}},
+{(unsigned char*)"nvap", {226, 137, 141, 226, 131, 146, 0}},
+{(unsigned char*)"nvdash", {226, 138, 172, 0}},
+{(unsigned char*)"nvge", {226, 137, 165, 226, 131, 146, 0}},
+{(unsigned char*)"nvgt", {62, 226, 131, 146, 0}},
+{(unsigned char*)"nvinfin", {226, 167, 158, 0}},
+{(unsigned char*)"nvlArr", {226, 164, 130, 0}},
+{(unsigned char*)"nvle", {226, 137, 164, 226, 131, 146, 0}},
+{(unsigned char*)"nvlt", {60, 226, 131, 146, 0}},
+{(unsigned char*)"nvltrie", {226, 138, 180, 226, 131, 146, 0}},
+{(unsigned char*)"nvrArr", {226, 164, 131, 0}},
+{(unsigned char*)"nvrtrie", {226, 138, 181, 226, 131, 146, 0}},
+{(unsigned char*)"nvsim", {226, 136, 188, 226, 131, 146, 0}},
+{(unsigned char*)"nwArr", {226, 135, 150, 0}},
+{(unsigned char*)"nwarhk", {226, 164, 163, 0}},
+{(unsigned char*)"nwarr", {226, 134, 150, 0}},
+{(unsigned char*)"nwarrow", {226, 134, 150, 0}},
+{(unsigned char*)"nwnear", {226, 164, 167, 0}},
+{(unsigned char*)"oS", {226, 147, 136, 0}},
+{(unsigned char*)"oacute", {195, 179, 0}},
+{(unsigned char*)"oast", {226, 138, 155, 0}},
+{(unsigned char*)"ocir", {226, 138, 154, 0}},
+{(unsigned char*)"ocirc", {195, 180, 0}},
+{(unsigned char*)"ocy", {208, 190, 0}},
+{(unsigned char*)"odash", {226, 138, 157, 0}},
+{(unsigned char*)"odblac", {197, 145, 0}},
+{(unsigned char*)"odiv", {226, 168, 184, 0}},
+{(unsigned char*)"odot", {226, 138, 153, 0}},
+{(unsigned char*)"odsold", {226, 166, 188, 0}},
+{(unsigned char*)"oelig", {197, 147, 0}},
+{(unsigned char*)"ofcir", {226, 166, 191, 0}},
+{(unsigned char*)"ofr", {240, 157, 148, 172, 0}},
+{(unsigned char*)"ogon", {203, 155, 0}},
+{(unsigned char*)"ograve", {195, 178, 0}},
+{(unsigned char*)"ogt", {226, 167, 129, 0}},
+{(unsigned char*)"ohbar", {226, 166, 181, 0}},
+{(unsigned char*)"ohm", {206, 169, 0}},
+{(unsigned char*)"oint", {226, 136, 174, 0}},
+{(unsigned char*)"olarr", {226, 134, 186, 0}},
+{(unsigned char*)"olcir", {226, 166, 190, 0}},
+{(unsigned char*)"olcross", {226, 166, 187, 0}},
+{(unsigned char*)"oline", {226, 128, 190, 0}},
+{(unsigned char*)"olt", {226, 167, 128, 0}},
+{(unsigned char*)"omacr", {197, 141, 0}},
+{(unsigned char*)"omega", {207, 137, 0}},
+{(unsigned char*)"omicron", {206, 191, 0}},
+{(unsigned char*)"omid", {226, 166, 182, 0}},
+{(unsigned char*)"ominus", {226, 138, 150, 0}},
+{(unsigned char*)"oopf", {240, 157, 149, 160, 0}},
+{(unsigned char*)"opar", {226, 166, 183, 0}},
+{(unsigned char*)"operp", {226, 166, 185, 0}},
+{(unsigned char*)"oplus", {226, 138, 149, 0}},
+{(unsigned char*)"or", {226, 136, 168, 0}},
+{(unsigned char*)"orarr", {226, 134, 187, 0}},
+{(unsigned char*)"ord", {226, 169, 157, 0}},
+{(unsigned char*)"order", {226, 132, 180, 0}},
+{(unsigned char*)"orderof", {226, 132, 180, 0}},
+{(unsigned char*)"ordf", {194, 170, 0}},
+{(unsigned char*)"ordm", {194, 186, 0}},
+{(unsigned char*)"origof", {226, 138, 182, 0}},
+{(unsigned char*)"oror", {226, 169, 150, 0}},
+{(unsigned char*)"orslope", {226, 169, 151, 0}},
+{(unsigned char*)"orv", {226, 169, 155, 0}},
+{(unsigned char*)"oscr", {226, 132, 180, 0}},
+{(unsigned char*)"oslash", {195, 184, 0}},
+{(unsigned char*)"osol", {226, 138, 152, 0}},
+{(unsigned char*)"otilde", {195, 181, 0}},
+{(unsigned char*)"otimes", {226, 138, 151, 0}},
+{(unsigned char*)"otimesas", {226, 168, 182, 0}},
+{(unsigned char*)"ouml", {195, 182, 0}},
+{(unsigned char*)"ovbar", {226, 140, 189, 0}},
+{(unsigned char*)"par", {226, 136, 165, 0}},
+{(unsigned char*)"para", {194, 182, 0}},
+{(unsigned char*)"parallel", {226, 136, 165, 0}},
+{(unsigned char*)"parsim", {226, 171, 179, 0}},
+{(unsigned char*)"parsl", {226, 171, 189, 0}},
+{(unsigned char*)"part", {226, 136, 130, 0}},
+{(unsigned char*)"pcy", {208, 191, 0}},
+{(unsigned char*)"percnt", {37, 0}},
+{(unsigned char*)"period", {46, 0}},
+{(unsigned char*)"permil", {226, 128, 176, 0}},
+{(unsigned char*)"perp", {226, 138, 165, 0}},
+{(unsigned char*)"pertenk", {226, 128, 177, 0}},
+{(unsigned char*)"pfr", {240, 157, 148, 173, 0}},
+{(unsigned char*)"phi", {207, 134, 0}},
+{(unsigned char*)"phiv", {207, 149, 0}},
+{(unsigned char*)"phmmat", {226, 132, 179, 0}},
+{(unsigned char*)"phone", {226, 152, 142, 0}},
+{(unsigned char*)"pi", {207, 128, 0}},
+{(unsigned char*)"pitchfork", {226, 139, 148, 0}},
+{(unsigned char*)"piv", {207, 150, 0}},
+{(unsigned char*)"planck", {226, 132, 143, 0}},
+{(unsigned char*)"planckh", {226, 132, 142, 0}},
+{(unsigned char*)"plankv", {226, 132, 143, 0}},
+{(unsigned char*)"plus", {43, 0}},
+{(unsigned char*)"plusacir", {226, 168, 163, 0}},
+{(unsigned char*)"plusb", {226, 138, 158, 0}},
+{(unsigned char*)"pluscir", {226, 168, 162, 0}},
+{(unsigned char*)"plusdo", {226, 136, 148, 0}},
+{(unsigned char*)"plusdu", {226, 168, 165, 0}},
+{(unsigned char*)"pluse", {226, 169, 178, 0}},
+{(unsigned char*)"plusmn", {194, 177, 0}},
+{(unsigned char*)"plussim", {226, 168, 166, 0}},
+{(unsigned char*)"plustwo", {226, 168, 167, 0}},
+{(unsigned char*)"pm", {194, 177, 0}},
+{(unsigned char*)"pointint", {226, 168, 149, 0}},
+{(unsigned char*)"popf", {240, 157, 149, 161, 0}},
+{(unsigned char*)"pound", {194, 163, 0}},
+{(unsigned char*)"pr", {226, 137, 186, 0}},
+{(unsigned char*)"prE", {226, 170, 179, 0}},
+{(unsigned char*)"prap", {226, 170, 183, 0}},
+{(unsigned char*)"prcue", {226, 137, 188, 0}},
+{(unsigned char*)"pre", {226, 170, 175, 0}},
+{(unsigned char*)"prec", {226, 137, 186, 0}},
+{(unsigned char*)"precapprox", {226, 170, 183, 0}},
+{(unsigned char*)"preccurlyeq", {226, 137, 188, 0}},
+{(unsigned char*)"preceq", {226, 170, 175, 0}},
+{(unsigned char*)"precnapprox", {226, 170, 185, 0}},
+{(unsigned char*)"precneqq", {226, 170, 181, 0}},
+{(unsigned char*)"precnsim", {226, 139, 168, 0}},
+{(unsigned char*)"precsim", {226, 137, 190, 0}},
+{(unsigned char*)"prime", {226, 128, 178, 0}},
+{(unsigned char*)"primes", {226, 132, 153, 0}},
+{(unsigned char*)"prnE", {226, 170, 181, 0}},
+{(unsigned char*)"prnap", {226, 170, 185, 0}},
+{(unsigned char*)"prnsim", {226, 139, 168, 0}},
+{(unsigned char*)"prod", {226, 136, 143, 0}},
+{(unsigned char*)"profalar", {226, 140, 174, 0}},
+{(unsigned char*)"profline", {226, 140, 146, 0}},
+{(unsigned char*)"profsurf", {226, 140, 147, 0}},
+{(unsigned char*)"prop", {226, 136, 157, 0}},
+{(unsigned char*)"propto", {226, 136, 157, 0}},
+{(unsigned char*)"prsim", {226, 137, 190, 0}},
+{(unsigned char*)"prurel", {226, 138, 176, 0}},
+{(unsigned char*)"pscr", {240, 157, 147, 133, 0}},
+{(unsigned char*)"psi", {207, 136, 0}},
+{(unsigned char*)"puncsp", {226, 128, 136, 0}},
+{(unsigned char*)"qfr", {240, 157, 148, 174, 0}},
+{(unsigned char*)"qint", {226, 168, 140, 0}},
+{(unsigned char*)"qopf", {240, 157, 149, 162, 0}},
+{(unsigned char*)"qprime", {226, 129, 151, 0}},
+{(unsigned char*)"qscr", {240, 157, 147, 134, 0}},
+{(unsigned char*)"quaternions", {226, 132, 141, 0}},
+{(unsigned char*)"quatint", {226, 168, 150, 0}},
+{(unsigned char*)"quest", {63, 0}},
+{(unsigned char*)"questeq", {226, 137, 159, 0}},
+{(unsigned char*)"quot", {34, 0}},
+{(unsigned char*)"rAarr", {226, 135, 155, 0}},
+{(unsigned char*)"rArr", {226, 135, 146, 0}},
+{(unsigned char*)"rAtail", {226, 164, 156, 0}},
+{(unsigned char*)"rBarr", {226, 164, 143, 0}},
+{(unsigned char*)"rHar", {226, 165, 164, 0}},
+{(unsigned char*)"race", {226, 136, 189, 204, 177, 0}},
+{(unsigned char*)"racute", {197, 149, 0}},
+{(unsigned char*)"radic", {226, 136, 154, 0}},
+{(unsigned char*)"raemptyv", {226, 166, 179, 0}},
+{(unsigned char*)"rang", {226, 159, 169, 0}},
+{(unsigned char*)"rangd", {226, 166, 146, 0}},
+{(unsigned char*)"range", {226, 166, 165, 0}},
+{(unsigned char*)"rangle", {226, 159, 169, 0}},
+{(unsigned char*)"raquo", {194, 187, 0}},
+{(unsigned char*)"rarr", {226, 134, 146, 0}},
+{(unsigned char*)"rarrap", {226, 165, 181, 0}},
+{(unsigned char*)"rarrb", {226, 135, 165, 0}},
+{(unsigned char*)"rarrbfs", {226, 164, 160, 0}},
+{(unsigned char*)"rarrc", {226, 164, 179, 0}},
+{(unsigned char*)"rarrfs", {226, 164, 158, 0}},
+{(unsigned char*)"rarrhk", {226, 134, 170, 0}},
+{(unsigned char*)"rarrlp", {226, 134, 172, 0}},
+{(unsigned char*)"rarrpl", {226, 165, 133, 0}},
+{(unsigned char*)"rarrsim", {226, 165, 180, 0}},
+{(unsigned char*)"rarrtl", {226, 134, 163, 0}},
+{(unsigned char*)"rarrw", {226, 134, 157, 0}},
+{(unsigned char*)"ratail", {226, 164, 154, 0}},
+{(unsigned char*)"ratio", {226, 136, 182, 0}},
+{(unsigned char*)"rationals", {226, 132, 154, 0}},
+{(unsigned char*)"rbarr", {226, 164, 141, 0}},
+{(unsigned char*)"rbbrk", {226, 157, 179, 0}},
+{(unsigned char*)"rbrace", {125, 0}},
+{(unsigned char*)"rbrack", {93, 0}},
+{(unsigned char*)"rbrke", {226, 166, 140, 0}},
+{(unsigned char*)"rbrksld", {226, 166, 142, 0}},
+{(unsigned char*)"rbrkslu", {226, 166, 144, 0}},
+{(unsigned char*)"rcaron", {197, 153, 0}},
+{(unsigned char*)"rcedil", {197, 151, 0}},
+{(unsigned char*)"rceil", {226, 140, 137, 0}},
+{(unsigned char*)"rcub", {125, 0}},
+{(unsigned char*)"rcy", {209, 128, 0}},
+{(unsigned char*)"rdca", {226, 164, 183, 0}},
+{(unsigned char*)"rdldhar", {226, 165, 169, 0}},
+{(unsigned char*)"rdquo", {226, 128, 157, 0}},
+{(unsigned char*)"rdquor", {226, 128, 157, 0}},
+{(unsigned char*)"rdsh", {226, 134, 179, 0}},
+{(unsigned char*)"real", {226, 132, 156, 0}},
+{(unsigned char*)"realine", {226, 132, 155, 0}},
+{(unsigned char*)"realpart", {226, 132, 156, 0}},
+{(unsigned char*)"reals", {226, 132, 157, 0}},
+{(unsigned char*)"rect", {226, 150, 173, 0}},
+{(unsigned char*)"reg", {194, 174, 0}},
+{(unsigned char*)"rfisht", {226, 165, 189, 0}},
+{(unsigned char*)"rfloor", {226, 140, 139, 0}},
+{(unsigned char*)"rfr", {240, 157, 148, 175, 0}},
+{(unsigned char*)"rhard", {226, 135, 129, 0}},
+{(unsigned char*)"rharu", {226, 135, 128, 0}},
+{(unsigned char*)"rharul", {226, 165, 172, 0}},
+{(unsigned char*)"rho", {207, 129, 0}},
+{(unsigned char*)"rhov", {207, 177, 0}},
+{(unsigned char*)"rightarrow", {226, 134, 146, 0}},
+{(unsigned char*)"rightarrowtail", {226, 134, 163, 0}},
+{(unsigned char*)"rightharpoondown", {226, 135, 129, 0}},
+{(unsigned char*)"rightharpoonup", {226, 135, 128, 0}},
+{(unsigned char*)"rightleftarrows", {226, 135, 132, 0}},
+{(unsigned char*)"rightleftharpoons", {226, 135, 140, 0}},
+{(unsigned char*)"rightrightarrows", {226, 135, 137, 0}},
+{(unsigned char*)"rightsquigarrow", {226, 134, 157, 0}},
+{(unsigned char*)"rightthreetimes", {226, 139, 140, 0}},
+{(unsigned char*)"ring", {203, 154, 0}},
+{(unsigned char*)"risingdotseq", {226, 137, 147, 0}},
+{(unsigned char*)"rlarr", {226, 135, 132, 0}},
+{(unsigned char*)"rlhar", {226, 135, 140, 0}},
+{(unsigned char*)"rlm", {226, 128, 143, 0}},
+{(unsigned char*)"rmoust", {226, 142, 177, 0}},
+{(unsigned char*)"rmoustache", {226, 142, 177, 0}},
+{(unsigned char*)"rnmid", {226, 171, 174, 0}},
+{(unsigned char*)"roang", {226, 159, 173, 0}},
+{(unsigned char*)"roarr", {226, 135, 190, 0}},
+{(unsigned char*)"robrk", {226, 159, 167, 0}},
+{(unsigned char*)"ropar", {226, 166, 134, 0}},
+{(unsigned char*)"ropf", {240, 157, 149, 163, 0}},
+{(unsigned char*)"roplus", {226, 168, 174, 0}},
+{(unsigned char*)"rotimes", {226, 168, 181, 0}},
+{(unsigned char*)"rpar", {41, 0}},
+{(unsigned char*)"rpargt", {226, 166, 148, 0}},
+{(unsigned char*)"rppolint", {226, 168, 146, 0}},
+{(unsigned char*)"rrarr", {226, 135, 137, 0}},
+{(unsigned char*)"rsaquo", {226, 128, 186, 0}},
+{(unsigned char*)"rscr", {240, 157, 147, 135, 0}},
+{(unsigned char*)"rsh", {226, 134, 177, 0}},
+{(unsigned char*)"rsqb", {93, 0}},
+{(unsigned char*)"rsquo", {226, 128, 153, 0}},
+{(unsigned char*)"rsquor", {226, 128, 153, 0}},
+{(unsigned char*)"rthree", {226, 139, 140, 0}},
+{(unsigned char*)"rtimes", {226, 139, 138, 0}},
+{(unsigned char*)"rtri", {226, 150, 185, 0}},
+{(unsigned char*)"rtrie", {226, 138, 181, 0}},
+{(unsigned char*)"rtrif", {226, 150, 184, 0}},
+{(unsigned char*)"rtriltri", {226, 167, 142, 0}},
+{(unsigned char*)"ruluhar", {226, 165, 168, 0}},
+{(unsigned char*)"rx", {226, 132, 158, 0}},
+{(unsigned char*)"sacute", {197, 155, 0}},
+{(unsigned char*)"sbquo", {226, 128, 154, 0}},
+{(unsigned char*)"sc", {226, 137, 187, 0}},
+{(unsigned char*)"scE", {226, 170, 180, 0}},
+{(unsigned char*)"scap", {226, 170, 184, 0}},
+{(unsigned char*)"scaron", {197, 161, 0}},
+{(unsigned char*)"sccue", {226, 137, 189, 0}},
+{(unsigned char*)"sce", {226, 170, 176, 0}},
+{(unsigned char*)"scedil", {197, 159, 0}},
+{(unsigned char*)"scirc", {197, 157, 0}},
+{(unsigned char*)"scnE", {226, 170, 182, 0}},
+{(unsigned char*)"scnap", {226, 170, 186, 0}},
+{(unsigned char*)"scnsim", {226, 139, 169, 0}},
+{(unsigned char*)"scpolint", {226, 168, 147, 0}},
+{(unsigned char*)"scsim", {226, 137, 191, 0}},
+{(unsigned char*)"scy", {209, 129, 0}},
+{(unsigned char*)"sdot", {226, 139, 133, 0}},
+{(unsigned char*)"sdotb", {226, 138, 161, 0}},
+{(unsigned char*)"sdote", {226, 169, 166, 0}},
+{(unsigned char*)"seArr", {226, 135, 152, 0}},
+{(unsigned char*)"searhk", {226, 164, 165, 0}},
+{(unsigned char*)"searr", {226, 134, 152, 0}},
+{(unsigned char*)"searrow", {226, 134, 152, 0}},
+{(unsigned char*)"sect", {194, 167, 0}},
+{(unsigned char*)"semi", {59, 0}},
+{(unsigned char*)"seswar", {226, 164, 169, 0}},
+{(unsigned char*)"setminus", {226, 136, 150, 0}},
+{(unsigned char*)"setmn", {226, 136, 150, 0}},
+{(unsigned char*)"sext", {226, 156, 182, 0}},
+{(unsigned char*)"sfr", {240, 157, 148, 176, 0}},
+{(unsigned char*)"sfrown", {226, 140, 162, 0}},
+{(unsigned char*)"sharp", {226, 153, 175, 0}},
+{(unsigned char*)"shchcy", {209, 137, 0}},
+{(unsigned char*)"shcy", {209, 136, 0}},
+{(unsigned char*)"shortmid", {226, 136, 163, 0}},
+{(unsigned char*)"shortparallel", {226, 136, 165, 0}},
+{(unsigned char*)"shy", {194, 173, 0}},
+{(unsigned char*)"sigma", {207, 131, 0}},
+{(unsigned char*)"sigmaf", {207, 130, 0}},
+{(unsigned char*)"sigmav", {207, 130, 0}},
+{(unsigned char*)"sim", {226, 136, 188, 0}},
+{(unsigned char*)"simdot", {226, 169, 170, 0}},
+{(unsigned char*)"sime", {226, 137, 131, 0}},
+{(unsigned char*)"simeq", {226, 137, 131, 0}},
+{(unsigned char*)"simg", {226, 170, 158, 0}},
+{(unsigned char*)"simgE", {226, 170, 160, 0}},
+{(unsigned char*)"siml", {226, 170, 157, 0}},
+{(unsigned char*)"simlE", {226, 170, 159, 0}},
+{(unsigned char*)"simne", {226, 137, 134, 0}},
+{(unsigned char*)"simplus", {226, 168, 164, 0}},
+{(unsigned char*)"simrarr", {226, 165, 178, 0}},
+{(unsigned char*)"slarr", {226, 134, 144, 0}},
+{(unsigned char*)"smallsetminus", {226, 136, 150, 0}},
+{(unsigned char*)"smashp", {226, 168, 179, 0}},
+{(unsigned char*)"smeparsl", {226, 167, 164, 0}},
+{(unsigned char*)"smid", {226, 136, 163, 0}},
+{(unsigned char*)"smile", {226, 140, 163, 0}},
+{(unsigned char*)"smt", {226, 170, 170, 0}},
+{(unsigned char*)"smte", {226, 170, 172, 0}},
+{(unsigned char*)"smtes", {226, 170, 172, 239, 184, 128, 0}},
+{(unsigned char*)"softcy", {209, 140, 0}},
+{(unsigned char*)"sol", {47, 0}},
+{(unsigned char*)"solb", {226, 167, 132, 0}},
+{(unsigned char*)"solbar", {226, 140, 191, 0}},
+{(unsigned char*)"sopf", {240, 157, 149, 164, 0}},
+{(unsigned char*)"spades", {226, 153, 160, 0}},
+{(unsigned char*)"spadesuit", {226, 153, 160, 0}},
+{(unsigned char*)"spar", {226, 136, 165, 0}},
+{(unsigned char*)"sqcap", {226, 138, 147, 0}},
+{(unsigned char*)"sqcaps", {226, 138, 147, 239, 184, 128, 0}},
+{(unsigned char*)"sqcup", {226, 138, 148, 0}},
+{(unsigned char*)"sqcups", {226, 138, 148, 239, 184, 128, 0}},
+{(unsigned char*)"sqsub", {226, 138, 143, 0}},
+{(unsigned char*)"sqsube", {226, 138, 145, 0}},
+{(unsigned char*)"sqsubset", {226, 138, 143, 0}},
+{(unsigned char*)"sqsubseteq", {226, 138, 145, 0}},
+{(unsigned char*)"sqsup", {226, 138, 144, 0}},
+{(unsigned char*)"sqsupe", {226, 138, 146, 0}},
+{(unsigned char*)"sqsupset", {226, 138, 144, 0}},
+{(unsigned char*)"sqsupseteq", {226, 138, 146, 0}},
+{(unsigned char*)"squ", {226, 150, 161, 0}},
+{(unsigned char*)"square", {226, 150, 161, 0}},
+{(unsigned char*)"squarf", {226, 150, 170, 0}},
+{(unsigned char*)"squf", {226, 150, 170, 0}},
+{(unsigned char*)"srarr", {226, 134, 146, 0}},
+{(unsigned char*)"sscr", {240, 157, 147, 136, 0}},
+{(unsigned char*)"ssetmn", {226, 136, 150, 0}},
+{(unsigned char*)"ssmile", {226, 140, 163, 0}},
+{(unsigned char*)"sstarf", {226, 139, 134, 0}},
+{(unsigned char*)"star", {226, 152, 134, 0}},
+{(unsigned char*)"starf", {226, 152, 133, 0}},
+{(unsigned char*)"straightepsilon", {207, 181, 0}},
+{(unsigned char*)"straightphi", {207, 149, 0}},
+{(unsigned char*)"strns", {194, 175, 0}},
+{(unsigned char*)"sub", {226, 138, 130, 0}},
+{(unsigned char*)"subE", {226, 171, 133, 0}},
+{(unsigned char*)"subdot", {226, 170, 189, 0}},
+{(unsigned char*)"sube", {226, 138, 134, 0}},
+{(unsigned char*)"subedot", {226, 171, 131, 0}},
+{(unsigned char*)"submult", {226, 171, 129, 0}},
+{(unsigned char*)"subnE", {226, 171, 139, 0}},
+{(unsigned char*)"subne", {226, 138, 138, 0}},
+{(unsigned char*)"subplus", {226, 170, 191, 0}},
+{(unsigned char*)"subrarr", {226, 165, 185, 0}},
+{(unsigned char*)"subset", {226, 138, 130, 0}},
+{(unsigned char*)"subseteq", {226, 138, 134, 0}},
+{(unsigned char*)"subseteqq", {226, 171, 133, 0}},
+{(unsigned char*)"subsetneq", {226, 138, 138, 0}},
+{(unsigned char*)"subsetneqq", {226, 171, 139, 0}},
+{(unsigned char*)"subsim", {226, 171, 135, 0}},
+{(unsigned char*)"subsub", {226, 171, 149, 0}},
+{(unsigned char*)"subsup", {226, 171, 147, 0}},
+{(unsigned char*)"succ", {226, 137, 187, 0}},
+{(unsigned char*)"succapprox", {226, 170, 184, 0}},
+{(unsigned char*)"succcurlyeq", {226, 137, 189, 0}},
+{(unsigned char*)"succeq", {226, 170, 176, 0}},
+{(unsigned char*)"succnapprox", {226, 170, 186, 0}},
+{(unsigned char*)"succneqq", {226, 170, 182, 0}},
+{(unsigned char*)"succnsim", {226, 139, 169, 0}},
+{(unsigned char*)"succsim", {226, 137, 191, 0}},
+{(unsigned char*)"sum", {226, 136, 145, 0}},
+{(unsigned char*)"sung", {226, 153, 170, 0}},
+{(unsigned char*)"sup", {226, 138, 131, 0}},
+{(unsigned char*)"sup1", {194, 185, 0}},
+{(unsigned char*)"sup2", {194, 178, 0}},
+{(unsigned char*)"sup3", {194, 179, 0}},
+{(unsigned char*)"supE", {226, 171, 134, 0}},
+{(unsigned char*)"supdot", {226, 170, 190, 0}},
+{(unsigned char*)"supdsub", {226, 171, 152, 0}},
+{(unsigned char*)"supe", {226, 138, 135, 0}},
+{(unsigned char*)"supedot", {226, 171, 132, 0}},
+{(unsigned char*)"suphsol", {226, 159, 137, 0}},
+{(unsigned char*)"suphsub", {226, 171, 151, 0}},
+{(unsigned char*)"suplarr", {226, 165, 187, 0}},
+{(unsigned char*)"supmult", {226, 171, 130, 0}},
+{(unsigned char*)"supnE", {226, 171, 140, 0}},
+{(unsigned char*)"supne", {226, 138, 139, 0}},
+{(unsigned char*)"supplus", {226, 171, 128, 0}},
+{(unsigned char*)"supset", {226, 138, 131, 0}},
+{(unsigned char*)"supseteq", {226, 138, 135, 0}},
+{(unsigned char*)"supseteqq", {226, 171, 134, 0}},
+{(unsigned char*)"supsetneq", {226, 138, 139, 0}},
+{(unsigned char*)"supsetneqq", {226, 171, 140, 0}},
+{(unsigned char*)"supsim", {226, 171, 136, 0}},
+{(unsigned char*)"supsub", {226, 171, 148, 0}},
+{(unsigned char*)"supsup", {226, 171, 150, 0}},
+{(unsigned char*)"swArr", {226, 135, 153, 0}},
+{(unsigned char*)"swarhk", {226, 164, 166, 0}},
+{(unsigned char*)"swarr", {226, 134, 153, 0}},
+{(unsigned char*)"swarrow", {226, 134, 153, 0}},
+{(unsigned char*)"swnwar", {226, 164, 170, 0}},
+{(unsigned char*)"szlig", {195, 159, 0}},
+{(unsigned char*)"target", {226, 140, 150, 0}},
+{(unsigned char*)"tau", {207, 132, 0}},
+{(unsigned char*)"tbrk", {226, 142, 180, 0}},
+{(unsigned char*)"tcaron", {197, 165, 0}},
+{(unsigned char*)"tcedil", {197, 163, 0}},
+{(unsigned char*)"tcy", {209, 130, 0}},
+{(unsigned char*)"tdot", {226, 131, 155, 0}},
+{(unsigned char*)"telrec", {226, 140, 149, 0}},
+{(unsigned char*)"tfr", {240, 157, 148, 177, 0}},
+{(unsigned char*)"there4", {226, 136, 180, 0}},
+{(unsigned char*)"therefore", {226, 136, 180, 0}},
+{(unsigned char*)"theta", {206, 184, 0}},
+{(unsigned char*)"thetasym", {207, 145, 0}},
+{(unsigned char*)"thetav", {207, 145, 0}},
+{(unsigned char*)"thickapprox", {226, 137, 136, 0}},
+{(unsigned char*)"thicksim", {226, 136, 188, 0}},
+{(unsigned char*)"thinsp", {226, 128, 137, 0}},
+{(unsigned char*)"thkap", {226, 137, 136, 0}},
+{(unsigned char*)"thksim", {226, 136, 188, 0}},
+{(unsigned char*)"thorn", {195, 190, 0}},
+{(unsigned char*)"tilde", {203, 156, 0}},
+{(unsigned char*)"times", {195, 151, 0}},
+{(unsigned char*)"timesb", {226, 138, 160, 0}},
+{(unsigned char*)"timesbar", {226, 168, 177, 0}},
+{(unsigned char*)"timesd", {226, 168, 176, 0}},
+{(unsigned char*)"tint", {226, 136, 173, 0}},
+{(unsigned char*)"toea", {226, 164, 168, 0}},
+{(unsigned char*)"top", {226, 138, 164, 0}},
+{(unsigned char*)"topbot", {226, 140, 182, 0}},
+{(unsigned char*)"topcir", {226, 171, 177, 0}},
+{(unsigned char*)"topf", {240, 157, 149, 165, 0}},
+{(unsigned char*)"topfork", {226, 171, 154, 0}},
+{(unsigned char*)"tosa", {226, 164, 169, 0}},
+{(unsigned char*)"tprime", {226, 128, 180, 0}},
+{(unsigned char*)"trade", {226, 132, 162, 0}},
+{(unsigned char*)"triangle", {226, 150, 181, 0}},
+{(unsigned char*)"triangledown", {226, 150, 191, 0}},
+{(unsigned char*)"triangleleft", {226, 151, 131, 0}},
+{(unsigned char*)"trianglelefteq", {226, 138, 180, 0}},
+{(unsigned char*)"triangleq", {226, 137, 156, 0}},
+{(unsigned char*)"triangleright", {226, 150, 185, 0}},
+{(unsigned char*)"trianglerighteq", {226, 138, 181, 0}},
+{(unsigned char*)"tridot", {226, 151, 172, 0}},
+{(unsigned char*)"trie", {226, 137, 156, 0}},
+{(unsigned char*)"triminus", {226, 168, 186, 0}},
+{(unsigned char*)"triplus", {226, 168, 185, 0}},
+{(unsigned char*)"trisb", {226, 167, 141, 0}},
+{(unsigned char*)"tritime", {226, 168, 187, 0}},
+{(unsigned char*)"trpezium", {226, 143, 162, 0}},
+{(unsigned char*)"tscr", {240, 157, 147, 137, 0}},
+{(unsigned char*)"tscy", {209, 134, 0}},
+{(unsigned char*)"tshcy", {209, 155, 0}},
+{(unsigned char*)"tstrok", {197, 167, 0}},
+{(unsigned char*)"twixt", {226, 137, 172, 0}},
+{(unsigned char*)"twoheadleftarrow", {226, 134, 158, 0}},
+{(unsigned char*)"twoheadrightarrow", {226, 134, 160, 0}},
+{(unsigned char*)"uArr", {226, 135, 145, 0}},
+{(unsigned char*)"uHar", {226, 165, 163, 0}},
+{(unsigned char*)"uacute", {195, 186, 0}},
+{(unsigned char*)"uarr", {226, 134, 145, 0}},
+{(unsigned char*)"ubrcy", {209, 158, 0}},
+{(unsigned char*)"ubreve", {197, 173, 0}},
+{(unsigned char*)"ucirc", {195, 187, 0}},
+{(unsigned char*)"ucy", {209, 131, 0}},
+{(unsigned char*)"udarr", {226, 135, 133, 0}},
+{(unsigned char*)"udblac", {197, 177, 0}},
+{(unsigned char*)"udhar", {226, 165, 174, 0}},
+{(unsigned char*)"ufisht", {226, 165, 190, 0}},
+{(unsigned char*)"ufr", {240, 157, 148, 178, 0}},
+{(unsigned char*)"ugrave", {195, 185, 0}},
+{(unsigned char*)"uharl", {226, 134, 191, 0}},
+{(unsigned char*)"uharr", {226, 134, 190, 0}},
+{(unsigned char*)"uhblk", {226, 150, 128, 0}},
+{(unsigned char*)"ulcorn", {226, 140, 156, 0}},
+{(unsigned char*)"ulcorner", {226, 140, 156, 0}},
+{(unsigned char*)"ulcrop", {226, 140, 143, 0}},
+{(unsigned char*)"ultri", {226, 151, 184, 0}},
+{(unsigned char*)"umacr", {197, 171, 0}},
+{(unsigned char*)"uml", {194, 168, 0}},
+{(unsigned char*)"uogon", {197, 179, 0}},
+{(unsigned char*)"uopf", {240, 157, 149, 166, 0}},
+{(unsigned char*)"uparrow", {226, 134, 145, 0}},
+{(unsigned char*)"updownarrow", {226, 134, 149, 0}},
+{(unsigned char*)"upharpoonleft", {226, 134, 191, 0}},
+{(unsigned char*)"upharpoonright", {226, 134, 190, 0}},
+{(unsigned char*)"uplus", {226, 138, 142, 0}},
+{(unsigned char*)"upsi", {207, 133, 0}},
+{(unsigned char*)"upsih", {207, 146, 0}},
+{(unsigned char*)"upsilon", {207, 133, 0}},
+{(unsigned char*)"upuparrows", {226, 135, 136, 0}},
+{(unsigned char*)"urcorn", {226, 140, 157, 0}},
+{(unsigned char*)"urcorner", {226, 140, 157, 0}},
+{(unsigned char*)"urcrop", {226, 140, 142, 0}},
+{(unsigned char*)"uring", {197, 175, 0}},
+{(unsigned char*)"urtri", {226, 151, 185, 0}},
+{(unsigned char*)"uscr", {240, 157, 147, 138, 0}},
+{(unsigned char*)"utdot", {226, 139, 176, 0}},
+{(unsigned char*)"utilde", {197, 169, 0}},
+{(unsigned char*)"utri", {226, 150, 181, 0}},
+{(unsigned char*)"utrif", {226, 150, 180, 0}},
+{(unsigned char*)"uuarr", {226, 135, 136, 0}},
+{(unsigned char*)"uuml", {195, 188, 0}},
+{(unsigned char*)"uwangle", {226, 166, 167, 0}},
+{(unsigned char*)"vArr", {226, 135, 149, 0}},
+{(unsigned char*)"vBar", {226, 171, 168, 0}},
+{(unsigned char*)"vBarv", {226, 171, 169, 0}},
+{(unsigned char*)"vDash", {226, 138, 168, 0}},
+{(unsigned char*)"vangrt", {226, 166, 156, 0}},
+{(unsigned char*)"varepsilon", {207, 181, 0}},
+{(unsigned char*)"varkappa", {207, 176, 0}},
+{(unsigned char*)"varnothing", {226, 136, 133, 0}},
+{(unsigned char*)"varphi", {207, 149, 0}},
+{(unsigned char*)"varpi", {207, 150, 0}},
+{(unsigned char*)"varpropto", {226, 136, 157, 0}},
+{(unsigned char*)"varr", {226, 134, 149, 0}},
+{(unsigned char*)"varrho", {207, 177, 0}},
+{(unsigned char*)"varsigma", {207, 130, 0}},
+{(unsigned char*)"varsubsetneq", {226, 138, 138, 239, 184, 128, 0}},
+{(unsigned char*)"varsubsetneqq", {226, 171, 139, 239, 184, 128, 0}},
+{(unsigned char*)"varsupsetneq", {226, 138, 139, 239, 184, 128, 0}},
+{(unsigned char*)"varsupsetneqq", {226, 171, 140, 239, 184, 128, 0}},
+{(unsigned char*)"vartheta", {207, 145, 0}},
+{(unsigned char*)"vartriangleleft", {226, 138, 178, 0}},
+{(unsigned char*)"vartriangleright", {226, 138, 179, 0}},
+{(unsigned char*)"vcy", {208, 178, 0}},
+{(unsigned char*)"vdash", {226, 138, 162, 0}},
+{(unsigned char*)"vee", {226, 136, 168, 0}},
+{(unsigned char*)"veebar", {226, 138, 187, 0}},
+{(unsigned char*)"veeeq", {226, 137, 154, 0}},
+{(unsigned char*)"vellip", {226, 139, 174, 0}},
+{(unsigned char*)"verbar", {124, 0}},
+{(unsigned char*)"vert", {124, 0}},
+{(unsigned char*)"vfr", {240, 157, 148, 179, 0}},
+{(unsigned char*)"vltri", {226, 138, 178, 0}},
+{(unsigned char*)"vnsub", {226, 138, 130, 226, 131, 146, 0}},
+{(unsigned char*)"vnsup", {226, 138, 131, 226, 131, 146, 0}},
+{(unsigned char*)"vopf", {240, 157, 149, 167, 0}},
+{(unsigned char*)"vprop", {226, 136, 157, 0}},
+{(unsigned char*)"vrtri", {226, 138, 179, 0}},
+{(unsigned char*)"vscr", {240, 157, 147, 139, 0}},
+{(unsigned char*)"vsubnE", {226, 171, 139, 239, 184, 128, 0}},
+{(unsigned char*)"vsubne", {226, 138, 138, 239, 184, 128, 0}},
+{(unsigned char*)"vsupnE", {226, 171, 140, 239, 184, 128, 0}},
+{(unsigned char*)"vsupne", {226, 138, 139, 239, 184, 128, 0}},
+{(unsigned char*)"vzigzag", {226, 166, 154, 0}},
+{(unsigned char*)"wcirc", {197, 181, 0}},
+{(unsigned char*)"wedbar", {226, 169, 159, 0}},
+{(unsigned char*)"wedge", {226, 136, 167, 0}},
+{(unsigned char*)"wedgeq", {226, 137, 153, 0}},
+{(unsigned char*)"weierp", {226, 132, 152, 0}},
+{(unsigned char*)"wfr", {240, 157, 148, 180, 0}},
+{(unsigned char*)"wopf", {240, 157, 149, 168, 0}},
+{(unsigned char*)"wp", {226, 132, 152, 0}},
+{(unsigned char*)"wr", {226, 137, 128, 0}},
+{(unsigned char*)"wreath", {226, 137, 128, 0}},
+{(unsigned char*)"wscr", {240, 157, 147, 140, 0}},
+{(unsigned char*)"xcap", {226, 139, 130, 0}},
+{(unsigned char*)"xcirc", {226, 151, 175, 0}},
+{(unsigned char*)"xcup", {226, 139, 131, 0}},
+{(unsigned char*)"xdtri", {226, 150, 189, 0}},
+{(unsigned char*)"xfr", {240, 157, 148, 181, 0}},
+{(unsigned char*)"xhArr", {226, 159, 186, 0}},
+{(unsigned char*)"xharr", {226, 159, 183, 0}},
+{(unsigned char*)"xi", {206, 190, 0}},
+{(unsigned char*)"xlArr", {226, 159, 184, 0}},
+{(unsigned char*)"xlarr", {226, 159, 181, 0}},
+{(unsigned char*)"xmap", {226, 159, 188, 0}},
+{(unsigned char*)"xnis", {226, 139, 187, 0}},
+{(unsigned char*)"xodot", {226, 168, 128, 0}},
+{(unsigned char*)"xopf", {240, 157, 149, 169, 0}},
+{(unsigned char*)"xoplus", {226, 168, 129, 0}},
+{(unsigned char*)"xotime", {226, 168, 130, 0}},
+{(unsigned char*)"xrArr", {226, 159, 185, 0}},
+{(unsigned char*)"xrarr", {226, 159, 182, 0}},
+{(unsigned char*)"xscr", {240, 157, 147, 141, 0}},
+{(unsigned char*)"xsqcup", {226, 168, 134, 0}},
+{(unsigned char*)"xuplus", {226, 168, 132, 0}},
+{(unsigned char*)"xutri", {226, 150, 179, 0}},
+{(unsigned char*)"xvee", {226, 139, 129, 0}},
+{(unsigned char*)"xwedge", {226, 139, 128, 0}},
+{(unsigned char*)"yacute", {195, 189, 0}},
+{(unsigned char*)"yacy", {209, 143, 0}},
+{(unsigned char*)"ycirc", {197, 183, 0}},
+{(unsigned char*)"ycy", {209, 139, 0}},
+{(unsigned char*)"yen", {194, 165, 0}},
+{(unsigned char*)"yfr", {240, 157, 148, 182, 0}},
+{(unsigned char*)"yicy", {209, 151, 0}},
+{(unsigned char*)"yopf", {240, 157, 149, 170, 0}},
+{(unsigned char*)"yscr", {240, 157, 147, 142, 0}},
+{(unsigned char*)"yucy", {209, 142, 0}},
+{(unsigned char*)"yuml", {195, 191, 0}},
+{(unsigned char*)"zacute", {197, 186, 0}},
+{(unsigned char*)"zcaron", {197, 190, 0}},
+{(unsigned char*)"zcy", {208, 183, 0}},
+{(unsigned char*)"zdot", {197, 188, 0}},
+{(unsigned char*)"zeetrf", {226, 132, 168, 0}},
+{(unsigned char*)"zeta", {206, 182, 0}},
+{(unsigned char*)"zfr", {240, 157, 148, 183, 0}},
+{(unsigned char*)"zhcy", {208, 182, 0}},
+{(unsigned char*)"zigrarr", {226, 135, 157, 0}},
+{(unsigned char*)"zopf", {240, 157, 149, 171, 0}},
+{(unsigned char*)"zscr", {240, 157, 147, 143, 0}},
+{(unsigned char*)"zwj", {226, 128, 141, 0}},
+{(unsigned char*)"zwnj", {226, 128, 140, 0}},
+};
diff --git a/lib/cmark/src/houdini.h b/lib/cmark/src/houdini.h
new file mode 100644
index 0000000..f738e82
--- /dev/null
+++ b/lib/cmark/src/houdini.h
@@ -0,0 +1,51 @@
+#ifndef CMARK_HOUDINI_H
+#define CMARK_HOUDINI_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include "config.h"
+#include "buffer.h"
+
+#ifdef HAVE___BUILTIN_EXPECT
+#define likely(x) __builtin_expect((x), 1)
+#define unlikely(x) __builtin_expect((x), 0)
+#else
+#define likely(x) (x)
+#define unlikely(x) (x)
+#endif
+
+#ifdef HOUDINI_USE_LOCALE
+#define _isxdigit(c) isxdigit(c)
+#define _isdigit(c) isdigit(c)
+#else
+/*
+ * Helper _isdigit methods -- do not trust the current locale
+ * */
+#define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL)
+#define _isdigit(c) ((c) >= '0' && (c) <= '9')
+#endif
+
+#define HOUDINI_ESCAPED_SIZE(x) (((x)*12) / 10)
+#define HOUDINI_UNESCAPED_SIZE(x) (x)
+
+extern bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src,
+                                      bufsize_t size);
+extern int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src,
+                               bufsize_t size);
+extern int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src,
+                                bufsize_t size, int secure);
+extern int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src,
+                                 bufsize_t size);
+extern void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src,
+                                    bufsize_t size);
+extern int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src,
+                               bufsize_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/cmark/src/houdini_href_e.c b/lib/cmark/src/houdini_href_e.c
new file mode 100644
index 0000000..bfa9704
--- /dev/null
+++ b/lib/cmark/src/houdini_href_e.c
@@ -0,0 +1,100 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+/*
+ * The following characters will not be escaped:
+ *
+ *		-_.+!*'(),%#@?=;:/,+&$ alphanum
+ *
+ * Note that this character set is the addition of:
+ *
+ *	- The characters which are safe to be in an URL
+ *	- The characters which are *not* safe to be in
+ *	an URL because they are RESERVED characters.
+ *
+ * We 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 chacters & (amp)
+ * and ' (single quote) do not appear in the table.
+ * They are meant to appear in the URL as components,
+ * yet they require special HTML-entity escaping
+ * to generate valid HTML markup.
+ *
+ * All other characters will be escaped to %XX.
+ *
+ */
+static const char HREF_SAFE[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, 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, "&amp;");
+      break;
+
+    /* the single quote is a valid URL character
+     * according to the standard; it needs HTML
+     * entity escaping too */
+    case '\'':
+      cmark_strbuf_puts(ob, "&#x27;");
+      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/lib/cmark/src/houdini_html_e.c b/lib/cmark/src/houdini_html_e.c
new file mode 100644
index 0000000..0e539f0
--- /dev/null
+++ b/lib/cmark/src/houdini_html_e.c
@@ -0,0 +1,66 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+/**
+ * According to the OWASP rules:
+ *
+ * & --> &amp;
+ * < --> &lt;
+ * > --> &gt;
+ * " --> &quot;
+ * ' --> &#x27;     &apos; is not recommended
+ * / --> &#x2F;     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[] = {"",      "&quot;", "&amp;", "&#39;",
+                                     "&#47;", "&lt;",   "&gt;"};
+
+int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, bufsize_t size,
+                         int secure) {
+  bufsize_t i = 0, org, esc = 0;
+
+  while (i < size) {
+    org = i;
+    while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0)
+      i++;
+
+    if (i > org)
+      cmark_strbuf_put(ob, src + org, i - org);
+
+    /* escaping */
+    if (unlikely(i >= size))
+      break;
+
+    /* The forward slash is only escaped in secure mode */
+    if ((src[i] == '/' || src[i] == '\'') && !secure) {
+      cmark_strbuf_putc(ob, src[i]);
+    } else {
+      cmark_strbuf_puts(ob, HTML_ESCAPES[esc]);
+    }
+
+    i++;
+  }
+
+  return 1;
+}
+
+int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) {
+  return houdini_escape_html0(ob, src, size, 1);
+}
diff --git a/lib/cmark/src/houdini_html_u.c b/lib/cmark/src/houdini_html_u.c
new file mode 100644
index 0000000..ce57ea1
--- /dev/null
+++ b/lib/cmark/src/houdini_html_u.c
@@ -0,0 +1,153 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "buffer.h"
+#include "houdini.h"
+#include "utf8.h"
+#include "entities.inc"
+
+/* 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) {
+  int j;
+  int cmp =
+      strncmp((const char *)s, (const char *)cmark_entities[i].entity, len);
+  if (cmp == 0 && cmark_entities[i].entity[len] == 0) {
+    return (const unsigned char *)cmark_entities[i].bytes;
+  } else if (cmp <= 0 && i > low) {
+    j = i - ((i - low) / 2);
+    if (j == i)
+      j -= 1;
+    return S_lookup(j, low, i - 1, s, len);
+  } else if (cmp > 0 && i < hi) {
+    j = i + ((hi - i) / 2);
+    if (j == i)
+      j += 1;
+    return S_lookup(j, i + 1, hi, s, len);
+  } else {
+    return NULL;
+  }
+}
+
+static const unsigned char *S_lookup_entity(const unsigned char *s, int len) {
+  return S_lookup(CMARK_NUM_ENTITIES / 2, 0, CMARK_NUM_ENTITIES - 1, s, len);
+}
+
+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 > CMARK_ENTITY_MAX_LENGTH)
+      size = CMARK_ENTITY_MAX_LENGTH;
+
+    for (i = CMARK_ENTITY_MIN_LENGTH; i < size; ++i) {
+      if (src[i] == ' ')
+        break;
+
+      if (src[i] == ';') {
+        const unsigned char *entity = S_lookup_entity(src, i);
+
+        if (entity != NULL) {
+          cmark_strbuf_puts(ob, (const char *)entity);
+          return i + 1;
+        }
+
+        break;
+      }
+    }
+  }
+
+  return 0;
+}
+
+int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src,
+                          bufsize_t size) {
+  bufsize_t i = 0, org, ent;
+
+  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/lib/cmark/src/html.c b/lib/cmark/src/html.c
new file mode 100644
index 0000000..c69ffb6
--- /dev/null
+++ b/lib/cmark/src/html.c
@@ -0,0 +1,341 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include "cmark_ctype.h"
+#include "config.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_html0(dest, source, length, 0);
+}
+
+static CMARK_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=\"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 ((options & CMARK_OPT_UNSAFE) ||
+            !(_scan_dangerous_url(node->as.link.url))) {
+        houdini_escape_href(html, node->as.link.url,
+                            strlen((char *)node->as.link.url));
+      }
+      if (node->as.link.title) {
+        cmark_strbuf_puts(html, "\" title=\"");
+        escape_html(html, node->as.link.title,
+                    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 ((options & CMARK_OPT_UNSAFE) ||
+            !(_scan_dangerous_url(node->as.link.url))) {
+        houdini_escape_href(html, node->as.link.url,
+                            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,
+                    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/lib/cmark/src/inlines.c b/lib/cmark/src/inlines.c
new file mode 100644
index 0000000..5b2edc6
--- /dev/null
+++ b/lib/cmark/src/inlines.c
@@ -0,0 +1,1391 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "cmark_ctype.h"
+#include "config.h"
+#include "node.h"
+#include "parser.h"
+#include "references.h"
+#include "cmark.h"
+#include "houdini.h"
+#include "utf8.h"
+#include "scanners.h"
+#include "inlines.h"
+
+static const char *EMDASH = "\xE2\x80\x94";
+static const char *ENDASH = "\xE2\x80\x93";
+static const char *ELLIPSES = "\xE2\x80\xA6";
+static const char *LEFTDOUBLEQUOTE = "\xE2\x80\x9C";
+static const char *RIGHTDOUBLEQUOTE = "\xE2\x80\x9D";
+static const char *LEFTSINGLEQUOTE = "\xE2\x80\x98";
+static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99";
+
+// Macros for creating various kinds of simple.
+#define make_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 length;
+  unsigned char delim_char;
+  bool can_open;
+  bool can_close;
+} delimiter;
+
+typedef struct bracket {
+  struct bracket *previous;
+  struct delimiter *previous_delimiter;
+  cmark_node *inl_text;
+  bufsize_t position;
+  bool image;
+  bool active;
+  bool bracket_after;
+} bracket;
+
+typedef struct {
+  cmark_mem *mem;
+  cmark_chunk input;
+  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;
+} subject;
+
+static CMARK_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 CMARK_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 CMARK_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);
+  }
+}
+
+// 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 CMARK_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;
+  cmark_node_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->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;
+}
+
+static CMARK_INLINE int isbacktick(int c) { return (c == '`'); }
+
+static CMARK_INLINE unsigned char peek_char(subject *subj) {
+  // NULL bytes should have been stripped out by now.  If they're
+  // present, it's a programming error:
+  assert(!(subj->pos < subj->input.len && subj->input.data[subj->pos] == 0));
+  return (subj->pos < subj->input.len) ? subj->input.data[subj->pos] : 0;
+}
+
+static CMARK_INLINE unsigned char peek_at(subject *subj, bufsize_t pos) {
+  return subj->input.data[pos];
+}
+
+// Return true if there are more characters in the subject.
+static CMARK_INLINE int is_eof(subject *subj) {
+  return (subj->pos >= subj->input.len);
+}
+
+// Advance the subject.  Doesn't check for eof.
+#define advance(subj) (subj)->pos += 1
+
+static CMARK_INLINE bool skip_spaces(subject *subj) {
+  bool skipped = false;
+  while (peek_char(subj) == ' ' || peek_char(subj) == '\t') {
+    advance(subj);
+    skipped = true;
+  }
+  return skipped;
+}
+
+static CMARK_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 CMARK_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) {
+  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, subj->pos, subj->pos, 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(after_char) ||
+                   cmark_utf8proc_is_space(before_char) ||
+                   cmark_utf8proc_is_punctuation(before_char));
+  right_flanking = numdelims > 0 && !cmark_utf8proc_is_space(before_char) &&
+                   (!cmark_utf8proc_is_punctuation(before_char) ||
+                    cmark_utf8proc_is_space(after_char) ||
+                    cmark_utf8proc_is_punctuation(after_char));
+  if (c == '_') {
+    *can_open = left_flanking &&
+                (!right_flanking || cmark_utf8proc_is_punctuation(before_char));
+    *can_close = right_flanking &&
+                 (!left_flanking || cmark_utf8proc_is_punctuation(after_char));
+  } else if (c == '\'' || c == '"') {
+    *can_open = left_flanking &&
+         (!right_flanking || 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->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->previous_delimiter = subj->last_delim;
+  b->position = subj->pos;
+  b->bracket_after = false;
+  subj->last_bracket = b;
+}
+
+// Assumes the subject has a c at the current position.
+static cmark_node *handle_delim(subject *subj, unsigned char c, bool smart) {
+  bufsize_t numdelims;
+  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, delimiter *stack_bottom) {
+  delimiter *closer = subj->last_delim;
+  delimiter *opener;
+  delimiter *old_closer;
+  bool opener_found;
+  int openers_bottom_index = 0;
+  delimiter *openers_bottom[6] = {stack_bottom, stack_bottom, stack_bottom,
+                                  stack_bottom, stack_bottom, stack_bottom};
+
+  // move back to first relevant delim.
+  while (closer != NULL && closer->previous != stack_bottom) {
+    closer = closer->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;
+        break;
+      case '*':
+        openers_bottom_index = 3 + (closer->length % 3);
+        break;
+      default:
+        assert(false);
+      }
+
+      // Now look backwards for first matching opener:
+      opener = closer->previous;
+      opener_found = false;
+      while (opener != NULL && opener != openers_bottom[openers_bottom_index]) {
+        if (opener->can_open && opener->delim_char == closer->delim_char) {
+          // interior closer of size 2 can't match opener of size 1
+          // or of size 1 can't match 2
+          if (!(closer->can_open || opener->can_close) ||
+	      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 == '\'') {
+        cmark_node_set_literal(closer->inl_text, RIGHTSINGLEQUOTE);
+        if (opener_found) {
+          cmark_node_set_literal(opener->inl_text, LEFTSINGLEQUOTE);
+        }
+        closer = closer->next;
+      } else if (closer->delim_char == '"') {
+        cmark_node_set_literal(closer->inl_text, RIGHTDOUBLEQUOTE);
+        if (opener_found) {
+          cmark_node_set_literal(opener->inl_text, LEFTDOUBLEQUOTE);
+        }
+        closer = closer->next;
+      }
+      if (!opener_found) {
+        // set lower bound for future searches for openers
+        openers_bottom[openers_bottom_index] = old_closer->previous;
+        if (!old_closer->can_open) {
+          // we can remove a closer that can't be an
+          // opener, once we've seen there's no
+          // 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 != 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;
+  closer_inl->len = closer_num_chars;
+  closer_inl->data[closer_num_chars] = 0;
+
+  // 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;
+  while (tmp && tmp != closer_inl) {
+    tmpnext = tmp->next;
+    cmark_node_append_child(emph, tmp);
+    tmp = tmpnext;
+  }
+  cmark_node_insert_after(opener_inl, emph);
+
+  emph->start_line = opener_inl->start_line;
+  emph->end_line = closer_inl->end_line;
+  emph->start_column = opener_inl->start_column;
+  emph->end_column = closer_inl->end_column;
+
+  // 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
+  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 (!opener->active) {
+    // take delimiter off stack
+    pop_bracket(subj);
+    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;
+
+  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 spacse 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_append_child(inl, tmp);
+    tmp = tmpnext;
+  }
+
+  // Free the bracket [:
+  cmark_node_free(opener->inl_text);
+
+  process_emphasis(subj, opener->previous_delimiter);
+  pop_bracket(subj);
+
+  // Now, if we have a link, we also want to deactivate earlier link
+  // delimiters. (This code can be removed if we decide to allow links
+  // inside links.)
+  if (!is_image) {
+    opener = subj->last_bracket;
+    while (opener != NULL) {
+      if (!opener->image) {
+        if (!opener->active) {
+          break;
+        } else {
+          opener->active = false;
+        }
+      }
+      opener = opener->previous;
+    }
+  }
+
+  return NULL;
+}
+
+// Parse a hard or soft linebreak, returning an inline.
+// Assumes the subject has a 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) {
+    cmark_node_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) {
+  subject subj;
+  cmark_chunk content = {parent->data, parent->len};
+  subject_from_buf(mem, parent->start_line, parent->start_column - 1 + parent->internal_offset, &subj, &content, refmap);
+  cmark_chunk_rtrim(&subj.input);
+
+  while (!is_eof(&subj) && parse_inline(&subj, parent, options))
+    ;
+
+  process_emphasis(&subj, NULL);
+  // 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/lib/cmark/src/inlines.h b/lib/cmark/src/inlines.h
new file mode 100644
index 0000000..800ed0c
--- /dev/null
+++ b/lib/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/lib/cmark/src/iterator.c b/lib/cmark/src/iterator.c
new file mode 100644
index 0000000..63cbf9e
--- /dev/null
+++ b/lib/cmark/src/iterator.c
@@ -0,0 +1,122 @@
+#include <assert.h>
+#include <stdlib.h>
+
+#include "config.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/lib/cmark/src/iterator.h b/lib/cmark/src/iterator.h
new file mode 100644
index 0000000..30ce76f
--- /dev/null
+++ b/lib/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/lib/cmark/src/latex.c b/lib/cmark/src/latex.c
new file mode 100644
index 0000000..1d4d7bc
--- /dev/null
+++ b/lib/cmark/src/latex.c
@@ -0,0 +1,453 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "config.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 CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
+                              int32_t c, unsigned char nextc) {
+  if (escape == LITERAL) {
+    cmark_render_code_point(renderer, c);
+    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);
+          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 {
+      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/lib/cmark/src/libcmark.pc.in b/lib/cmark/src/libcmark.pc.in
new file mode 100644
index 0000000..0f87c30
--- /dev/null
+++ b/lib/cmark/src/libcmark.pc.in
@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_PREFIX@/@libdir@
+includedir=@CMAKE_INSTALL_PREFIX@/include
+
+Name: libcmark
+Description: CommonMark parsing, rendering, and manipulation
+Version: @PROJECT_VERSION@
+Libs: -L${libdir} -lcmark
+Cflags: -I${includedir}
diff --git a/lib/cmark/src/main.c b/lib/cmark/src/main.c
new file mode 100644
index 0000000..6162704
--- /dev/null
+++ b/lib/cmark/src/main.c
@@ -0,0 +1,210 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include "config.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() {
+  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("  --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);
+  }
+  printf("%s", result);
+  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], "--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/lib/cmark/src/man.c b/lib/cmark/src/man.c
new file mode 100644
index 0000000..1c76f68
--- /dev/null
+++ b/lib/cmark/src/man.c
@@ -0,0 +1,252 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "config.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);
+
+  // avoid unused parameter error:
+  (void)(options);
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    if (entering) {
+      CR();
+      LIT(".RS");
+      CR();
+    } else {
+      CR();
+      LIT(".RE");
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_LIST:
+    break;
+
+  case CMARK_NODE_ITEM:
+    if (entering) {
+      CR();
+      LIT(".IP ");
+      if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+        LIT("\\[bu] 2");
+      } else {
+        list_number = cmark_node_get_list_start(node->parent);
+        tmp = node;
+        while (tmp->prev) {
+          tmp = tmp->prev;
+          list_number += 1;
+        }
+        char list_number_s[LIST_NUMBER_SIZE];
+        snprintf(list_number_s, LIST_NUMBER_SIZE, "\"%d.\" 4", list_number);
+        LIT(list_number_s);
+      }
+      CR();
+    } else {
+      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/lib/cmark/src/node.c b/lib/cmark/src/node.c
new file mode 100644
index 0000000..ea09c30
--- /dev/null
+++ b/lib/cmark/src/node.c
@@ -0,0 +1,871 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "config.h"
+#include "node.h"
+
+static void S_node_unlink(cmark_node *node);
+
+static CMARK_INLINE bool S_is_block(cmark_node *node) {
+  if (node == NULL) {
+    return false;
+  }
+  return node->type >= CMARK_NODE_FIRST_BLOCK &&
+         node->type <= CMARK_NODE_LAST_BLOCK;
+}
+
+static CMARK_INLINE bool S_is_inline(cmark_node *node) {
+  if (node == NULL) {
+    return false;
+  }
+  return node->type >= CMARK_NODE_FIRST_INLINE &&
+         node->type <= CMARK_NODE_LAST_INLINE;
+}
+
+static bool S_can_contain(cmark_node *node, cmark_node *child) {
+  cmark_node *cur;
+
+  if (node == NULL || child == NULL) {
+    return false;
+  }
+
+  // Verify that child is not an ancestor of node or equal to node.
+  cur = node;
+  do {
+    if (cur == child) {
+      return false;
+    }
+    cur = cur->parent;
+  } while (cur != NULL);
+
+  if (child->type == CMARK_NODE_DOCUMENT) {
+    return false;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+  case CMARK_NODE_BLOCK_QUOTE:
+  case CMARK_NODE_ITEM:
+    return S_is_block(child) && child->type != CMARK_NODE_ITEM;
+
+  case CMARK_NODE_LIST:
+    return child->type == CMARK_NODE_ITEM;
+
+  case CMARK_NODE_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 S_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/lib/cmark/src/node.h b/lib/cmark/src/node.h
new file mode 100644
index 0000000..6bf6677
--- /dev/null
+++ b/lib/cmark/src/node.h
@@ -0,0 +1,92 @@
+#ifndef CMARK_NODE_H
+#define CMARK_NODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+
+#include "config.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 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),
+};
+
+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;
+  int internal_offset;
+  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/lib/cmark/src/parser.h b/lib/cmark/src/parser.h
new file mode 100644
index 0000000..8f6c694
--- /dev/null
+++ b/lib/cmark/src/parser.h
@@ -0,0 +1,41 @@
+#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;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/cmark/src/references.c b/lib/cmark/src/references.c
new file mode 100644
index 0000000..623006a
--- /dev/null
+++ b/lib/cmark/src/references.c
@@ -0,0 +1,156 @@
+#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;
+
+  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;
+  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);
+  return ref ? ref[0] : NULL;
+}
+
+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/lib/cmark/src/references.h b/lib/cmark/src/references.h
new file mode 100644
index 0000000..cc59509
--- /dev/null
+++ b/lib/cmark/src/references.h
@@ -0,0 +1,40 @@
+#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;
+};
+
+typedef struct cmark_reference cmark_reference;
+
+struct cmark_reference_map {
+  cmark_mem *mem;
+  cmark_reference *refs;
+  cmark_reference **sorted;
+  unsigned int 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);
+extern void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label,
+                                   cmark_chunk *url, cmark_chunk *title);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/cmark/src/render.c b/lib/cmark/src/render.c
new file mode 100644
index 0000000..dfdd855
--- /dev/null
+++ b/lib/cmark/src/render.c
@@ -0,0 +1,192 @@
+#include <stdlib.h>
+#include "buffer.h"
+#include "cmark.h"
+#include "utf8.h"
+#include "render.h"
+#include "node.h"
+#include "cmark_ctype.h"
+
+static CMARK_INLINE void S_cr(cmark_renderer *renderer) {
+  if (renderer->need_cr < 1) {
+    renderer->need_cr = 1;
+  }
+}
+
+static CMARK_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 = 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, outc, S_cr,  S_blankline, S_out};
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    if (!render_node(&renderer, cur, ev_type, options)) {
+      // a false value causes us to skip processing
+      // the node's contents.  this is used for
+      // autolinks.
+      cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT);
+    }
+  }
+
+  // ensure final newline
+  if (renderer.buffer->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/lib/cmark/src/render.h b/lib/cmark/src/render.h
new file mode 100644
index 0000000..15f6c2c
--- /dev/null
+++ b/lib/cmark/src/render.h
@@ -0,0 +1,49 @@
+#ifndef CMARK_RENDER_H
+#define CMARK_RENDER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include "buffer.h"
+
+typedef enum { LITERAL, NORMAL, TITLE, URL } cmark_escaping;
+
+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;
+  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/lib/cmark/src/scanners.c b/lib/cmark/src/scanners.c
new file mode 100644
index 0000000..f8e6c15
--- /dev/null
+++ b/lib/cmark/src/scanners.c
@@ -0,0 +1,13787 @@
+/* Generated by re2c 0.16 */
+#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 yy2;
+    if (yych <= 'Z')
+      goto yy4;
+    if (yych <= '`')
+      goto yy2;
+    if (yych <= 'z')
+      goto yy4;
+  yy2:
+    ++p;
+  yy3 : { return 0; }
+  yy4:
+    yych = *(marker = ++p);
+    if (yych <= '/') {
+      if (yych <= '+') {
+        if (yych <= '*')
+          goto yy3;
+      } else {
+        if (yych <= ',')
+          goto yy3;
+        if (yych >= '/')
+          goto yy3;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '9')
+          goto yy5;
+        if (yych <= '@')
+          goto yy3;
+      } else {
+        if (yych <= '`')
+          goto yy3;
+        if (yych >= '{')
+          goto yy3;
+      }
+    }
+  yy5:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych == '+')
+          goto yy7;
+      } else {
+        if (yych != '/')
+          goto yy7;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych >= 'A')
+          goto yy7;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych <= 'z')
+          goto yy7;
+      }
+    }
+  yy6:
+    p = marker;
+    goto yy3;
+  yy7:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych == '+')
+          goto yy10;
+        goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+        goto yy10;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+        goto yy10;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych <= 'z')
+          goto yy10;
+        goto yy6;
+      }
+    }
+  yy8:
+    ++p;
+    { return (bufsize_t)(p - start); }
+  yy10:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy6;
+      } else {
+        if (yych == '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy8;
+        if (yych <= '@')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy6;
+        if (yych >= '{')
+          goto yy6;
+      }
+    }
+    ++p;
+    if ((yych = *p) == ':')
+      goto yy8;
+    goto yy6;
+  }
+}
+
+// Try to match URI autolink after first <, returning number of chars matched.
+bufsize_t _scan_autolink_uri(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 0,   128, 0,   128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,
+    };
+    yych = *p;
+    if (yych <= '@')
+      goto yy41;
+    if (yych <= 'Z')
+      goto yy43;
+    if (yych <= '`')
+      goto yy41;
+    if (yych <= 'z')
+      goto yy43;
+  yy41:
+    ++p;
+  yy42 : { return 0; }
+  yy43:
+    yych = *(marker = ++p);
+    if (yych <= '/') {
+      if (yych <= '+') {
+        if (yych <= '*')
+          goto yy42;
+      } else {
+        if (yych <= ',')
+          goto yy42;
+        if (yych >= '/')
+          goto yy42;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '9')
+          goto yy44;
+        if (yych <= '@')
+          goto yy42;
+      } else {
+        if (yych <= '`')
+          goto yy42;
+        if (yych >= '{')
+          goto yy42;
+      }
+    }
+  yy44:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych == '+')
+          goto yy46;
+      } else {
+        if (yych != '/')
+          goto yy46;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych >= 'A')
+          goto yy46;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych <= 'z')
+          goto yy46;
+      }
+    }
+  yy45:
+    p = marker;
+    goto yy42;
+  yy46:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych == '+')
+          goto yy49;
+        goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+        goto yy49;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+        goto yy49;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych <= 'z')
+          goto yy49;
+        goto yy45;
+      }
+    }
+  yy47:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy47;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '<')
+          goto yy45;
+        if (yych <= '>')
+          goto yy50;
+        goto yy45;
+      } else {
+        if (yych <= 0xDF)
+          goto yy52;
+        if (yych <= 0xE0)
+          goto yy53;
+        goto yy54;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy55;
+        if (yych <= 0xEF)
+          goto yy54;
+        goto yy56;
+      } else {
+        if (yych <= 0xF3)
+          goto yy57;
+        if (yych <= 0xF4)
+          goto yy58;
+        goto yy45;
+      }
+    }
+  yy49:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych == '+')
+          goto yy59;
+        goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+        goto yy59;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+        goto yy59;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych <= 'z')
+          goto yy59;
+        goto yy45;
+      }
+    }
+  yy50:
+    ++p;
+    { return (bufsize_t)(p - start); }
+  yy52:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy45;
+    if (yych <= 0xBF)
+      goto yy47;
+    goto yy45;
+  yy53:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy45;
+    if (yych <= 0xBF)
+      goto yy52;
+    goto yy45;
+  yy54:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy45;
+    if (yych <= 0xBF)
+      goto yy52;
+    goto yy45;
+  yy55:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy45;
+    if (yych <= 0x9F)
+      goto yy52;
+    goto yy45;
+  yy56:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy45;
+    if (yych <= 0xBF)
+      goto yy54;
+    goto yy45;
+  yy57:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy45;
+    if (yych <= 0xBF)
+      goto yy54;
+    goto yy45;
+  yy58:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy45;
+    if (yych <= 0x8F)
+      goto yy54;
+    goto yy45;
+  yy59:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy45;
+      } else {
+        if (yych == '/')
+          goto yy45;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy47;
+        if (yych <= '@')
+          goto yy45;
+      } else {
+        if (yych <= '`')
+          goto yy45;
+        if (yych >= '{')
+          goto yy45;
+      }
+    }
+    ++p;
+    if ((yych = *p) == ':')
+      goto yy47;
+    goto yy45;
+  }
+}
+
+// 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 yy91;
+        if (yych >= '#')
+          goto yy91;
+      } else {
+        if (yych <= ')')
+          goto yy89;
+        if (yych != ',')
+          goto yy91;
+      }
+    } else {
+      if (yych <= '?') {
+        if (yych == '=')
+          goto yy91;
+        if (yych >= '?')
+          goto yy91;
+      } else {
+        if (yych <= 'Z') {
+          if (yych >= 'A')
+            goto yy91;
+        } else {
+          if (yych <= ']')
+            goto yy89;
+          if (yych <= '~')
+            goto yy91;
+        }
+      }
+    }
+  yy89:
+    ++p;
+  yy90 : { return 0; }
+  yy91:
+    yych = *(marker = ++p);
+    if (yych <= ',') {
+      if (yych <= '"') {
+        if (yych == '!')
+          goto yy93;
+        goto yy90;
+      } else {
+        if (yych <= '\'')
+          goto yy93;
+        if (yych <= ')')
+          goto yy90;
+        if (yych <= '+')
+          goto yy93;
+        goto yy90;
+      }
+    } else {
+      if (yych <= '>') {
+        if (yych <= '9')
+          goto yy93;
+        if (yych == '=')
+          goto yy93;
+        goto yy90;
+      } else {
+        if (yych <= 'Z')
+          goto yy93;
+        if (yych <= ']')
+          goto yy90;
+        if (yych <= '~')
+          goto yy93;
+        goto yy90;
+      }
+    }
+  yy92:
+    ++p;
+    yych = *p;
+  yy93:
+    if (yybm[0 + yych] & 128) {
+      goto yy92;
+    }
+    if (yych <= '>')
+      goto yy94;
+    if (yych <= '@')
+      goto yy95;
+  yy94:
+    p = marker;
+    goto yy90;
+  yy95:
+    ++p;
+    yych = *p;
+    if (yych <= '@') {
+      if (yych <= '/')
+        goto yy94;
+      if (yych >= ':')
+        goto yy94;
+    } else {
+      if (yych <= 'Z')
+        goto yy96;
+      if (yych <= '`')
+        goto yy94;
+      if (yych >= '{')
+        goto yy94;
+    }
+  yy96:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy98;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy98;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy98;
+        goto yy94;
+      }
+    }
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy101;
+      if (yych <= '/')
+        goto yy94;
+      goto yy102;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy102;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy102;
+        goto yy94;
+      }
+    }
+  yy98:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych <= '-')
+          goto yy101;
+        goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy102;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy102;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy102;
+        goto yy94;
+      }
+    }
+  yy99:
+    ++p;
+    { return (bufsize_t)(p - start); }
+  yy101:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy103;
+      if (yych <= '/')
+        goto yy94;
+      goto yy104;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy104;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy104;
+        goto yy94;
+      }
+    }
+  yy102:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy104;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy104;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy104;
+        goto yy94;
+      }
+    }
+  yy103:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy105;
+      if (yych <= '/')
+        goto yy94;
+      goto yy106;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy106;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy106;
+        goto yy94;
+      }
+    }
+  yy104:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy106;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy106;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy106;
+        goto yy94;
+      }
+    }
+  yy105:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy107;
+      if (yych <= '/')
+        goto yy94;
+      goto yy108;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy108;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy108;
+        goto yy94;
+      }
+    }
+  yy106:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy108;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy108;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy108;
+        goto yy94;
+      }
+    }
+  yy107:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy109;
+      if (yych <= '/')
+        goto yy94;
+      goto yy110;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy110;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy110;
+        goto yy94;
+      }
+    }
+  yy108:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy110;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy110;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy110;
+        goto yy94;
+      }
+    }
+  yy109:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy111;
+      if (yych <= '/')
+        goto yy94;
+      goto yy112;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy112;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy112;
+        goto yy94;
+      }
+    }
+  yy110:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy112;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy112;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy112;
+        goto yy94;
+      }
+    }
+  yy111:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy113;
+      if (yych <= '/')
+        goto yy94;
+      goto yy114;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy114;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy114;
+        goto yy94;
+      }
+    }
+  yy112:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy114;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy114;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy114;
+        goto yy94;
+      }
+    }
+  yy113:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy115;
+      if (yych <= '/')
+        goto yy94;
+      goto yy116;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy116;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy116;
+        goto yy94;
+      }
+    }
+  yy114:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy116;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy116;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy116;
+        goto yy94;
+      }
+    }
+  yy115:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy117;
+      if (yych <= '/')
+        goto yy94;
+      goto yy118;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy118;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy118;
+        goto yy94;
+      }
+    }
+  yy116:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy118;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy118;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy118;
+        goto yy94;
+      }
+    }
+  yy117:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy119;
+      if (yych <= '/')
+        goto yy94;
+      goto yy120;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy120;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy120;
+        goto yy94;
+      }
+    }
+  yy118:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy120;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy120;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy120;
+        goto yy94;
+      }
+    }
+  yy119:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy121;
+      if (yych <= '/')
+        goto yy94;
+      goto yy122;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy122;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy122;
+        goto yy94;
+      }
+    }
+  yy120:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy122;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy122;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy122;
+        goto yy94;
+      }
+    }
+  yy121:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy123;
+      if (yych <= '/')
+        goto yy94;
+      goto yy124;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy124;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy124;
+        goto yy94;
+      }
+    }
+  yy122:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy124;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy124;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy124;
+        goto yy94;
+      }
+    }
+  yy123:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy125;
+      if (yych <= '/')
+        goto yy94;
+      goto yy126;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy126;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy126;
+        goto yy94;
+      }
+    }
+  yy124:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy126;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy126;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy126;
+        goto yy94;
+      }
+    }
+  yy125:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy127;
+      if (yych <= '/')
+        goto yy94;
+      goto yy128;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy128;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy128;
+        goto yy94;
+      }
+    }
+  yy126:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy128;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy128;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy128;
+        goto yy94;
+      }
+    }
+  yy127:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy129;
+      if (yych <= '/')
+        goto yy94;
+      goto yy130;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy130;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy130;
+        goto yy94;
+      }
+    }
+  yy128:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy130;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy130;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy130;
+        goto yy94;
+      }
+    }
+  yy129:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy131;
+      if (yych <= '/')
+        goto yy94;
+      goto yy132;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy132;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy132;
+        goto yy94;
+      }
+    }
+  yy130:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy132;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy132;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy132;
+        goto yy94;
+      }
+    }
+  yy131:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy133;
+      if (yych <= '/')
+        goto yy94;
+      goto yy134;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy134;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy134;
+        goto yy94;
+      }
+    }
+  yy132:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy134;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy134;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy134;
+        goto yy94;
+      }
+    }
+  yy133:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy135;
+      if (yych <= '/')
+        goto yy94;
+      goto yy136;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy136;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy136;
+        goto yy94;
+      }
+    }
+  yy134:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy136;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy136;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy136;
+        goto yy94;
+      }
+    }
+  yy135:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy137;
+      if (yych <= '/')
+        goto yy94;
+      goto yy138;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy138;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy138;
+        goto yy94;
+      }
+    }
+  yy136:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy138;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy138;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy138;
+        goto yy94;
+      }
+    }
+  yy137:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy139;
+      if (yych <= '/')
+        goto yy94;
+      goto yy140;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy140;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy140;
+        goto yy94;
+      }
+    }
+  yy138:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy140;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy140;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy140;
+        goto yy94;
+      }
+    }
+  yy139:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy141;
+      if (yych <= '/')
+        goto yy94;
+      goto yy142;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy142;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy142;
+        goto yy94;
+      }
+    }
+  yy140:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy142;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy142;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy142;
+        goto yy94;
+      }
+    }
+  yy141:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy143;
+      if (yych <= '/')
+        goto yy94;
+      goto yy144;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy144;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy144;
+        goto yy94;
+      }
+    }
+  yy142:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy144;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy144;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy144;
+        goto yy94;
+      }
+    }
+  yy143:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy145;
+      if (yych <= '/')
+        goto yy94;
+      goto yy146;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy146;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy146;
+        goto yy94;
+      }
+    }
+  yy144:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy146;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy146;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy146;
+        goto yy94;
+      }
+    }
+  yy145:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy147;
+      if (yych <= '/')
+        goto yy94;
+      goto yy148;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy148;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy148;
+        goto yy94;
+      }
+    }
+  yy146:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy148;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy148;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy148;
+        goto yy94;
+      }
+    }
+  yy147:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy149;
+      if (yych <= '/')
+        goto yy94;
+      goto yy150;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy150;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy150;
+        goto yy94;
+      }
+    }
+  yy148:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy150;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy150;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy150;
+        goto yy94;
+      }
+    }
+  yy149:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy151;
+      if (yych <= '/')
+        goto yy94;
+      goto yy152;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy152;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy152;
+        goto yy94;
+      }
+    }
+  yy150:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy152;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy152;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy152;
+        goto yy94;
+      }
+    }
+  yy151:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy153;
+      if (yych <= '/')
+        goto yy94;
+      goto yy154;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy154;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy154;
+        goto yy94;
+      }
+    }
+  yy152:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy154;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy154;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy154;
+        goto yy94;
+      }
+    }
+  yy153:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy155;
+      if (yych <= '/')
+        goto yy94;
+      goto yy156;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy156;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy156;
+        goto yy94;
+      }
+    }
+  yy154:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy156;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy156;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy156;
+        goto yy94;
+      }
+    }
+  yy155:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy157;
+      if (yych <= '/')
+        goto yy94;
+      goto yy158;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy158;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy158;
+        goto yy94;
+      }
+    }
+  yy156:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy158;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy158;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy158;
+        goto yy94;
+      }
+    }
+  yy157:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy159;
+      if (yych <= '/')
+        goto yy94;
+      goto yy160;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy160;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy160;
+        goto yy94;
+      }
+    }
+  yy158:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy160;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy160;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy160;
+        goto yy94;
+      }
+    }
+  yy159:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy161;
+      if (yych <= '/')
+        goto yy94;
+      goto yy162;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy162;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy162;
+        goto yy94;
+      }
+    }
+  yy160:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy162;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy162;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy162;
+        goto yy94;
+      }
+    }
+  yy161:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy163;
+      if (yych <= '/')
+        goto yy94;
+      goto yy164;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy164;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy164;
+        goto yy94;
+      }
+    }
+  yy162:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy164;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy164;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy164;
+        goto yy94;
+      }
+    }
+  yy163:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy165;
+      if (yych <= '/')
+        goto yy94;
+      goto yy166;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy166;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy166;
+        goto yy94;
+      }
+    }
+  yy164:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy166;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy166;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy166;
+        goto yy94;
+      }
+    }
+  yy165:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy167;
+      if (yych <= '/')
+        goto yy94;
+      goto yy168;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy168;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy168;
+        goto yy94;
+      }
+    }
+  yy166:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy168;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy168;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy168;
+        goto yy94;
+      }
+    }
+  yy167:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy169;
+      if (yych <= '/')
+        goto yy94;
+      goto yy170;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy170;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy170;
+        goto yy94;
+      }
+    }
+  yy168:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy170;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy170;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy170;
+        goto yy94;
+      }
+    }
+  yy169:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy171;
+      if (yych <= '/')
+        goto yy94;
+      goto yy172;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy172;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy172;
+        goto yy94;
+      }
+    }
+  yy170:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy172;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy172;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy172;
+        goto yy94;
+      }
+    }
+  yy171:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy173;
+      if (yych <= '/')
+        goto yy94;
+      goto yy174;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy174;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy174;
+        goto yy94;
+      }
+    }
+  yy172:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy174;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy174;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy174;
+        goto yy94;
+      }
+    }
+  yy173:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy175;
+      if (yych <= '/')
+        goto yy94;
+      goto yy176;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy176;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy176;
+        goto yy94;
+      }
+    }
+  yy174:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy176;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy176;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy176;
+        goto yy94;
+      }
+    }
+  yy175:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy177;
+      if (yych <= '/')
+        goto yy94;
+      goto yy178;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy178;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy178;
+        goto yy94;
+      }
+    }
+  yy176:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy178;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy178;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy178;
+        goto yy94;
+      }
+    }
+  yy177:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy179;
+      if (yych <= '/')
+        goto yy94;
+      goto yy180;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy180;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy180;
+        goto yy94;
+      }
+    }
+  yy178:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy180;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy180;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy180;
+        goto yy94;
+      }
+    }
+  yy179:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy181;
+      if (yych <= '/')
+        goto yy94;
+      goto yy182;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy182;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy182;
+        goto yy94;
+      }
+    }
+  yy180:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy182;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy182;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy182;
+        goto yy94;
+      }
+    }
+  yy181:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy183;
+      if (yych <= '/')
+        goto yy94;
+      goto yy184;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy184;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy184;
+        goto yy94;
+      }
+    }
+  yy182:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy184;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy184;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy184;
+        goto yy94;
+      }
+    }
+  yy183:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy185;
+      if (yych <= '/')
+        goto yy94;
+      goto yy186;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy186;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy186;
+        goto yy94;
+      }
+    }
+  yy184:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy186;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy186;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy186;
+        goto yy94;
+      }
+    }
+  yy185:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy187;
+      if (yych <= '/')
+        goto yy94;
+      goto yy188;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy188;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy188;
+        goto yy94;
+      }
+    }
+  yy186:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy188;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy188;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy188;
+        goto yy94;
+      }
+    }
+  yy187:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy189;
+      if (yych <= '/')
+        goto yy94;
+      goto yy190;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy190;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy190;
+        goto yy94;
+      }
+    }
+  yy188:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy190;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy190;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy190;
+        goto yy94;
+      }
+    }
+  yy189:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy191;
+      if (yych <= '/')
+        goto yy94;
+      goto yy192;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy192;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy192;
+        goto yy94;
+      }
+    }
+  yy190:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy192;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy192;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy192;
+        goto yy94;
+      }
+    }
+  yy191:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy193;
+      if (yych <= '/')
+        goto yy94;
+      goto yy194;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy194;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy194;
+        goto yy94;
+      }
+    }
+  yy192:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy194;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy194;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy194;
+        goto yy94;
+      }
+    }
+  yy193:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy195;
+      if (yych <= '/')
+        goto yy94;
+      goto yy196;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy196;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy196;
+        goto yy94;
+      }
+    }
+  yy194:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy196;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy196;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy196;
+        goto yy94;
+      }
+    }
+  yy195:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy197;
+      if (yych <= '/')
+        goto yy94;
+      goto yy198;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy198;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy198;
+        goto yy94;
+      }
+    }
+  yy196:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy198;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy198;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy198;
+        goto yy94;
+      }
+    }
+  yy197:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy199;
+      if (yych <= '/')
+        goto yy94;
+      goto yy200;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy200;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy200;
+        goto yy94;
+      }
+    }
+  yy198:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy200;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy200;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy200;
+        goto yy94;
+      }
+    }
+  yy199:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy201;
+      if (yych <= '/')
+        goto yy94;
+      goto yy202;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy202;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy202;
+        goto yy94;
+      }
+    }
+  yy200:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy202;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy202;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy202;
+        goto yy94;
+      }
+    }
+  yy201:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy203;
+      if (yych <= '/')
+        goto yy94;
+      goto yy204;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy204;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy204;
+        goto yy94;
+      }
+    }
+  yy202:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy204;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy204;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy204;
+        goto yy94;
+      }
+    }
+  yy203:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy205;
+      if (yych <= '/')
+        goto yy94;
+      goto yy206;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy206;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy206;
+        goto yy94;
+      }
+    }
+  yy204:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy206;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy206;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy206;
+        goto yy94;
+      }
+    }
+  yy205:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy207;
+      if (yych <= '/')
+        goto yy94;
+      goto yy208;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy208;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy208;
+        goto yy94;
+      }
+    }
+  yy206:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy208;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy208;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy208;
+        goto yy94;
+      }
+    }
+  yy207:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy209;
+      if (yych <= '/')
+        goto yy94;
+      goto yy210;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy210;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy210;
+        goto yy94;
+      }
+    }
+  yy208:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy210;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy210;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy210;
+        goto yy94;
+      }
+    }
+  yy209:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy211;
+      if (yych <= '/')
+        goto yy94;
+      goto yy212;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy212;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy212;
+        goto yy94;
+      }
+    }
+  yy210:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy212;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy212;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy212;
+        goto yy94;
+      }
+    }
+  yy211:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy213;
+      if (yych <= '/')
+        goto yy94;
+      goto yy214;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy214;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy214;
+        goto yy94;
+      }
+    }
+  yy212:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy214;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy214;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy214;
+        goto yy94;
+      }
+    }
+  yy213:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy215;
+      if (yych <= '/')
+        goto yy94;
+      goto yy216;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy216;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy216;
+        goto yy94;
+      }
+    }
+  yy214:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy216;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy216;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy216;
+        goto yy94;
+      }
+    }
+  yy215:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy217;
+      if (yych <= '/')
+        goto yy94;
+      goto yy218;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy218;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy218;
+        goto yy94;
+      }
+    }
+  yy216:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy218;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy218;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy218;
+        goto yy94;
+      }
+    }
+  yy217:
+    ++p;
+    yych = *p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy219;
+      if (yych <= '/')
+        goto yy94;
+      goto yy220;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy94;
+        goto yy220;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy220;
+        goto yy94;
+      }
+    }
+  yy218:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy94;
+        if (yych >= '.')
+          goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych <= '9')
+          goto yy220;
+        goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+        goto yy220;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych <= 'z')
+          goto yy220;
+        goto yy94;
+      }
+    }
+  yy219:
+    ++p;
+    yych = *p;
+    if (yych <= '@') {
+      if (yych <= '/')
+        goto yy94;
+      if (yych <= '9')
+        goto yy221;
+      goto yy94;
+    } else {
+      if (yych <= 'Z')
+        goto yy221;
+      if (yych <= '`')
+        goto yy94;
+      if (yych <= 'z')
+        goto yy221;
+      goto yy94;
+    }
+  yy220:
+    ++p;
+    yych = *p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= '-')
+          goto yy94;
+        goto yy95;
+      } else {
+        if (yych <= '/')
+          goto yy94;
+        if (yych >= ':')
+          goto yy94;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy99;
+        if (yych <= '@')
+          goto yy94;
+      } else {
+        if (yych <= '`')
+          goto yy94;
+        if (yych >= '{')
+          goto yy94;
+      }
+    }
+  yy221:
+    ++p;
+    yych = *p;
+    if (yych == '.')
+      goto yy95;
+    if (yych == '>')
+      goto yy99;
+    goto yy94;
+  }
+}
+
+// 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[] = {
+        /* table 1 .. 8: 0 */
+        0,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        235,
+        235,
+        235,
+        235,
+        235,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        250,
+        235,
+        250,
+        202,
+        250,
+        250,
+        250,
+        250,
+        170,
+        250,
+        250,
+        250,
+        250,
+        250,
+        246,
+        254,
+        250,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        250,
+        234,
+        234,
+        232,
+        250,
+        250,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        250,
+        250,
+        122,
+        250,
+        254,
+        234,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        254,
+        250,
+        250,
+        250,
+        250,
+        250,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        /* table 9 .. 11: 256 */
+        0,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        192,
+        128,
+        128,
+        192,
+        192,
+        192,
+        192,
+        192,
+        192,
+        192,
+        192,
+        192,
+        192,
+        128,
+        128,
+        128,
+        128,
+        128,
+        0,
+        128,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        224,
+        128,
+        128,
+        128,
+        128,
+        128,
+        128,
+        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,
+        128,
+        128,
+        128,
+        128,
+        128,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+    };
+    yych = *p;
+    if (yych <= '>') {
+      if (yych <= '!') {
+        if (yych >= '!')
+          goto yy226;
+      } else {
+        if (yych == '/')
+          goto yy227;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '?')
+          goto yy228;
+        if (yych >= 'A')
+          goto yy229;
+      } else {
+        if (yych <= '`')
+          goto yy224;
+        if (yych <= 'z')
+          goto yy229;
+      }
+    }
+  yy224:
+    ++p;
+  yy225 : { return 0; }
+  yy226:
+    yych = *(marker = ++p);
+    if (yybm[256 + yych] & 32) {
+      goto yy232;
+    }
+    if (yych == '-')
+      goto yy230;
+    if (yych <= '@')
+      goto yy225;
+    if (yych <= '[')
+      goto yy234;
+    goto yy225;
+  yy227:
+    yych = *(marker = ++p);
+    if (yych <= '@')
+      goto yy225;
+    if (yych <= 'Z')
+      goto yy235;
+    if (yych <= '`')
+      goto yy225;
+    if (yych <= 'z')
+      goto yy235;
+    goto yy225;
+  yy228:
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy225;
+    if (yych <= 0x7F)
+      goto yy238;
+    if (yych <= 0xC1)
+      goto yy225;
+    if (yych <= 0xF4)
+      goto yy238;
+    goto yy225;
+  yy229:
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 1) {
+      goto yy247;
+    }
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych == '-')
+          goto yy249;
+        goto yy225;
+      } else {
+        if (yych <= '/')
+          goto yy251;
+        if (yych <= '9')
+          goto yy249;
+        goto yy225;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy252;
+        if (yych <= '@')
+          goto yy225;
+        goto yy249;
+      } else {
+        if (yych <= '`')
+          goto yy225;
+        if (yych <= 'z')
+          goto yy249;
+        goto yy225;
+      }
+    }
+  yy230:
+    yych = *++p;
+    if (yych == '-')
+      goto yy254;
+  yy231:
+    p = marker;
+    goto yy225;
+  yy232:
+    ++p;
+    yych = *p;
+    if (yybm[256 + yych] & 32) {
+      goto yy232;
+    }
+    if (yych <= 0x08)
+      goto yy231;
+    if (yych <= '\r')
+      goto yy255;
+    if (yych == ' ')
+      goto yy255;
+    goto yy231;
+  yy234:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy257;
+    if (yych == 'c')
+      goto yy257;
+    goto yy231;
+  yy235:
+    ++p;
+    yych = *p;
+    if (yybm[256 + yych] & 64) {
+      goto yy235;
+    }
+    if (yych <= 0x1F) {
+      if (yych <= 0x08)
+        goto yy231;
+      if (yych <= '\r')
+        goto yy258;
+      goto yy231;
+    } else {
+      if (yych <= ' ')
+        goto yy258;
+      if (yych == '>')
+        goto yy252;
+      goto yy231;
+    }
+  yy237:
+    ++p;
+    yych = *p;
+  yy238:
+    if (yybm[256 + yych] & 128) {
+      goto yy237;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych >= '@')
+          goto yy231;
+      } else {
+        if (yych <= 0xDF)
+          goto yy240;
+        if (yych <= 0xE0)
+          goto yy241;
+        goto yy242;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy243;
+        if (yych <= 0xEF)
+          goto yy242;
+        goto yy244;
+      } else {
+        if (yych <= 0xF3)
+          goto yy245;
+        if (yych <= 0xF4)
+          goto yy246;
+        goto yy231;
+      }
+    }
+    ++p;
+    yych = *p;
+    if (yych <= 0xE0) {
+      if (yych <= '>') {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych <= '=')
+          goto yy237;
+        goto yy252;
+      } else {
+        if (yych <= 0x7F)
+          goto yy237;
+        if (yych <= 0xC1)
+          goto yy231;
+        if (yych >= 0xE0)
+          goto yy241;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy243;
+        goto yy242;
+      } else {
+        if (yych <= 0xF0)
+          goto yy244;
+        if (yych <= 0xF3)
+          goto yy245;
+        if (yych <= 0xF4)
+          goto yy246;
+        goto yy231;
+      }
+    }
+  yy240:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy237;
+    goto yy231;
+  yy241:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy240;
+    goto yy231;
+  yy242:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy240;
+    goto yy231;
+  yy243:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x9F)
+      goto yy240;
+    goto yy231;
+  yy244:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy242;
+    goto yy231;
+  yy245:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy242;
+    goto yy231;
+  yy246:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x8F)
+      goto yy242;
+    goto yy231;
+  yy247:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 1) {
+      goto yy247;
+    }
+    if (yych <= '>') {
+      if (yych <= '9') {
+        if (yych == '/')
+          goto yy251;
+        goto yy231;
+      } else {
+        if (yych <= ':')
+          goto yy260;
+        if (yych <= '=')
+          goto yy231;
+        goto yy252;
+      }
+    } else {
+      if (yych <= '^') {
+        if (yych <= '@')
+          goto yy231;
+        if (yych <= 'Z')
+          goto yy260;
+        goto yy231;
+      } else {
+        if (yych == '`')
+          goto yy231;
+        if (yych <= 'z')
+          goto yy260;
+        goto yy231;
+      }
+    }
+  yy249:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 1) {
+      goto yy247;
+    }
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych == '-')
+          goto yy249;
+        goto yy231;
+      } else {
+        if (yych <= '/')
+          goto yy251;
+        if (yych <= '9')
+          goto yy249;
+        goto yy231;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy252;
+        if (yych <= '@')
+          goto yy231;
+        goto yy249;
+      } else {
+        if (yych <= '`')
+          goto yy231;
+        if (yych <= 'z')
+          goto yy249;
+        goto yy231;
+      }
+    }
+  yy251:
+    yych = *++p;
+    if (yych != '>')
+      goto yy231;
+  yy252:
+    ++p;
+    { return (bufsize_t)(p - start); }
+  yy254:
+    yych = *++p;
+    if (yych == '-')
+      goto yy264;
+    if (yych == '>')
+      goto yy231;
+    goto yy263;
+  yy255:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 2) {
+      goto yy255;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych <= '>')
+          goto yy252;
+        goto yy231;
+      } else {
+        if (yych <= 0xDF)
+          goto yy272;
+        if (yych <= 0xE0)
+          goto yy273;
+        goto yy274;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy275;
+        if (yych <= 0xEF)
+          goto yy274;
+        goto yy276;
+      } else {
+        if (yych <= 0xF3)
+          goto yy277;
+        if (yych <= 0xF4)
+          goto yy278;
+        goto yy231;
+      }
+    }
+  yy257:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy279;
+    if (yych == 'd')
+      goto yy279;
+    goto yy231;
+  yy258:
+    ++p;
+    yych = *p;
+    if (yych <= 0x1F) {
+      if (yych <= 0x08)
+        goto yy231;
+      if (yych <= '\r')
+        goto yy258;
+      goto yy231;
+    } else {
+      if (yych <= ' ')
+        goto yy258;
+      if (yych == '>')
+        goto yy252;
+      goto yy231;
+    }
+  yy260:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 4) {
+      goto yy260;
+    }
+    if (yych <= ',') {
+      if (yych <= '\r') {
+        if (yych <= 0x08)
+          goto yy231;
+        goto yy280;
+      } else {
+        if (yych == ' ')
+          goto yy280;
+        goto yy231;
+      }
+    } else {
+      if (yych <= '<') {
+        if (yych <= '/')
+          goto yy251;
+        goto yy231;
+      } else {
+        if (yych <= '=')
+          goto yy282;
+        if (yych <= '>')
+          goto yy252;
+        goto yy231;
+      }
+    }
+  yy262:
+    ++p;
+    yych = *p;
+  yy263:
+    if (yybm[0 + yych] & 8) {
+      goto yy262;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych <= '-')
+          goto yy284;
+        goto yy231;
+      } else {
+        if (yych <= 0xDF)
+          goto yy265;
+        if (yych <= 0xE0)
+          goto yy266;
+        goto yy267;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy268;
+        if (yych <= 0xEF)
+          goto yy267;
+        goto yy269;
+      } else {
+        if (yych <= 0xF3)
+          goto yy270;
+        if (yych <= 0xF4)
+          goto yy271;
+        goto yy231;
+      }
+    }
+  yy264:
+    yych = *++p;
+    if (yych == '-')
+      goto yy251;
+    if (yych == '>')
+      goto yy231;
+    goto yy263;
+  yy265:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy262;
+    goto yy231;
+  yy266:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy265;
+    goto yy231;
+  yy267:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy265;
+    goto yy231;
+  yy268:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x9F)
+      goto yy265;
+    goto yy231;
+  yy269:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy267;
+    goto yy231;
+  yy270:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy267;
+    goto yy231;
+  yy271:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x8F)
+      goto yy267;
+    goto yy231;
+  yy272:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy255;
+    goto yy231;
+  yy273:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy272;
+    goto yy231;
+  yy274:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy272;
+    goto yy231;
+  yy275:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x9F)
+      goto yy272;
+    goto yy231;
+  yy276:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy274;
+    goto yy231;
+  yy277:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy274;
+    goto yy231;
+  yy278:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x8F)
+      goto yy274;
+    goto yy231;
+  yy279:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy285;
+    if (yych == 'a')
+      goto yy285;
+    goto yy231;
+  yy280:
+    ++p;
+    yych = *p;
+    if (yych <= '<') {
+      if (yych <= ' ') {
+        if (yych <= 0x08)
+          goto yy231;
+        if (yych <= '\r')
+          goto yy280;
+        if (yych <= 0x1F)
+          goto yy231;
+        goto yy280;
+      } else {
+        if (yych <= '/') {
+          if (yych <= '.')
+            goto yy231;
+          goto yy251;
+        } else {
+          if (yych == ':')
+            goto yy260;
+          goto yy231;
+        }
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '=')
+          goto yy282;
+        if (yych <= '>')
+          goto yy252;
+        if (yych <= '@')
+          goto yy231;
+        goto yy260;
+      } else {
+        if (yych <= '_') {
+          if (yych <= '^')
+            goto yy231;
+          goto yy260;
+        } else {
+          if (yych <= '`')
+            goto yy231;
+          if (yych <= 'z')
+            goto yy260;
+          goto yy231;
+        }
+      }
+    }
+  yy282:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 16) {
+      goto yy286;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '"') {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych <= ' ')
+          goto yy282;
+        goto yy288;
+      } else {
+        if (yych <= '\'')
+          goto yy290;
+        if (yych <= 0xC1)
+          goto yy231;
+        if (yych <= 0xDF)
+          goto yy292;
+        goto yy293;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy295;
+        goto yy294;
+      } else {
+        if (yych <= 0xF0)
+          goto yy296;
+        if (yych <= 0xF3)
+          goto yy297;
+        if (yych <= 0xF4)
+          goto yy298;
+        goto yy231;
+      }
+    }
+  yy284:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 8) {
+      goto yy262;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych <= '-')
+          goto yy251;
+        goto yy231;
+      } else {
+        if (yych <= 0xDF)
+          goto yy265;
+        if (yych <= 0xE0)
+          goto yy266;
+        goto yy267;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy268;
+        if (yych <= 0xEF)
+          goto yy267;
+        goto yy269;
+      } else {
+        if (yych <= 0xF3)
+          goto yy270;
+        if (yych <= 0xF4)
+          goto yy271;
+        goto yy231;
+      }
+    }
+  yy285:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy299;
+    if (yych == 't')
+      goto yy299;
+    goto yy231;
+  yy286:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 16) {
+      goto yy286;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '=') {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych <= ' ')
+          goto yy247;
+        goto yy231;
+      } else {
+        if (yych <= '>')
+          goto yy252;
+        if (yych <= 0xC1)
+          goto yy231;
+        if (yych <= 0xDF)
+          goto yy292;
+        goto yy293;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy295;
+        goto yy294;
+      } else {
+        if (yych <= 0xF0)
+          goto yy296;
+        if (yych <= 0xF3)
+          goto yy297;
+        if (yych <= 0xF4)
+          goto yy298;
+        goto yy231;
+      }
+    }
+  yy288:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 32) {
+      goto yy288;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych <= '"')
+          goto yy300;
+        goto yy231;
+      } else {
+        if (yych <= 0xDF)
+          goto yy301;
+        if (yych <= 0xE0)
+          goto yy302;
+        goto yy303;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy304;
+        if (yych <= 0xEF)
+          goto yy303;
+        goto yy305;
+      } else {
+        if (yych <= 0xF3)
+          goto yy306;
+        if (yych <= 0xF4)
+          goto yy307;
+        goto yy231;
+      }
+    }
+  yy290:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy290;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych <= '\'')
+          goto yy300;
+        goto yy231;
+      } else {
+        if (yych <= 0xDF)
+          goto yy308;
+        if (yych <= 0xE0)
+          goto yy309;
+        goto yy310;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy311;
+        if (yych <= 0xEF)
+          goto yy310;
+        goto yy312;
+      } else {
+        if (yych <= 0xF3)
+          goto yy313;
+        if (yych <= 0xF4)
+          goto yy314;
+        goto yy231;
+      }
+    }
+  yy292:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy286;
+    goto yy231;
+  yy293:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy292;
+    goto yy231;
+  yy294:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy292;
+    goto yy231;
+  yy295:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x9F)
+      goto yy292;
+    goto yy231;
+  yy296:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy294;
+    goto yy231;
+  yy297:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy294;
+    goto yy231;
+  yy298:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x8F)
+      goto yy294;
+    goto yy231;
+  yy299:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy315;
+    if (yych == 'a')
+      goto yy315;
+    goto yy231;
+  yy300:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 1) {
+      goto yy247;
+    }
+    if (yych == '/')
+      goto yy251;
+    if (yych == '>')
+      goto yy252;
+    goto yy231;
+  yy301:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy288;
+    goto yy231;
+  yy302:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy301;
+    goto yy231;
+  yy303:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy301;
+    goto yy231;
+  yy304:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x9F)
+      goto yy301;
+    goto yy231;
+  yy305:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy303;
+    goto yy231;
+  yy306:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy303;
+    goto yy231;
+  yy307:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x8F)
+      goto yy303;
+    goto yy231;
+  yy308:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy290;
+    goto yy231;
+  yy309:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy308;
+    goto yy231;
+  yy310:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy308;
+    goto yy231;
+  yy311:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x9F)
+      goto yy308;
+    goto yy231;
+  yy312:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy310;
+    goto yy231;
+  yy313:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy310;
+    goto yy231;
+  yy314:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x8F)
+      goto yy310;
+    goto yy231;
+  yy315:
+    yych = *++p;
+    if (yych != '[')
+      goto yy231;
+  yy316:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy316;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych >= '^')
+          goto yy231;
+      } else {
+        if (yych <= 0xDF)
+          goto yy319;
+        if (yych <= 0xE0)
+          goto yy320;
+        goto yy321;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy322;
+        if (yych <= 0xEF)
+          goto yy321;
+        goto yy323;
+      } else {
+        if (yych <= 0xF3)
+          goto yy324;
+        if (yych <= 0xF4)
+          goto yy325;
+        goto yy231;
+      }
+    }
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy316;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych <= ']')
+          goto yy326;
+        goto yy231;
+      } else {
+        if (yych <= 0xDF)
+          goto yy319;
+        if (yych <= 0xE0)
+          goto yy320;
+        goto yy321;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy322;
+        if (yych <= 0xEF)
+          goto yy321;
+        goto yy323;
+      } else {
+        if (yych <= 0xF3)
+          goto yy324;
+        if (yych <= 0xF4)
+          goto yy325;
+        goto yy231;
+      }
+    }
+  yy319:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy316;
+    goto yy231;
+  yy320:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy319;
+    goto yy231;
+  yy321:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy319;
+    goto yy231;
+  yy322:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x9F)
+      goto yy319;
+    goto yy231;
+  yy323:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy321;
+    goto yy231;
+  yy324:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0xBF)
+      goto yy321;
+    goto yy231;
+  yy325:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy231;
+    if (yych <= 0x8F)
+      goto yy321;
+    goto yy231;
+  yy326:
+    ++p;
+    yych = *p;
+    if (yych <= 0xE0) {
+      if (yych <= '>') {
+        if (yych <= 0x00)
+          goto yy231;
+        if (yych <= '=')
+          goto yy316;
+        goto yy252;
+      } else {
+        if (yych <= 0x7F)
+          goto yy316;
+        if (yych <= 0xC1)
+          goto yy231;
+        if (yych <= 0xDF)
+          goto yy319;
+        goto yy320;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy322;
+        goto yy321;
+      } else {
+        if (yych <= 0xF0)
+          goto yy323;
+        if (yych <= 0xF3)
+          goto yy324;
+        if (yych <= 0xF4)
+          goto yy325;
+        goto yy231;
+      }
+    }
+  }
+}
+
+// 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 yy331;
+    ++p;
+  yy330 : { return 0; }
+  yy331:
+    yych = *(marker = ++p);
+    switch (yych) {
+    case '!':
+      goto yy332;
+    case '/':
+      goto yy334;
+    case '?':
+      goto yy335;
+    case 'A':
+    case 'a':
+      goto yy337;
+    case 'B':
+    case 'b':
+      goto yy338;
+    case 'C':
+    case 'c':
+      goto yy339;
+    case 'D':
+    case 'd':
+      goto yy340;
+    case 'F':
+    case 'f':
+      goto yy341;
+    case 'H':
+    case 'h':
+      goto yy342;
+    case 'I':
+    case 'i':
+      goto yy343;
+    case 'L':
+    case 'l':
+      goto yy344;
+    case 'M':
+    case 'm':
+      goto yy345;
+    case 'N':
+    case 'n':
+      goto yy346;
+    case 'O':
+    case 'o':
+      goto yy347;
+    case 'P':
+    case 'p':
+      goto yy348;
+    case 'S':
+    case 's':
+      goto yy349;
+    case 'T':
+    case 't':
+      goto yy350;
+    case 'U':
+    case 'u':
+      goto yy351;
+    default:
+      goto yy330;
+    }
+  yy332:
+    yych = *++p;
+    if (yych <= '@') {
+      if (yych == '-')
+        goto yy352;
+    } else {
+      if (yych <= 'Z')
+        goto yy353;
+      if (yych <= '[')
+        goto yy355;
+    }
+  yy333:
+    p = marker;
+    goto yy330;
+  yy334:
+    yych = *++p;
+    switch (yych) {
+    case 'A':
+    case 'a':
+      goto yy337;
+    case 'B':
+    case 'b':
+      goto yy338;
+    case 'C':
+    case 'c':
+      goto yy339;
+    case 'D':
+    case 'd':
+      goto yy340;
+    case 'F':
+    case 'f':
+      goto yy341;
+    case 'H':
+    case 'h':
+      goto yy342;
+    case 'I':
+    case 'i':
+      goto yy343;
+    case 'L':
+    case 'l':
+      goto yy344;
+    case 'M':
+    case 'm':
+      goto yy345;
+    case 'N':
+    case 'n':
+      goto yy346;
+    case 'O':
+    case 'o':
+      goto yy347;
+    case 'P':
+    case 'p':
+      goto yy356;
+    case 'S':
+    case 's':
+      goto yy357;
+    case 'T':
+    case 't':
+      goto yy350;
+    case 'U':
+    case 'u':
+      goto yy351;
+    default:
+      goto yy333;
+    }
+  yy335:
+    ++p;
+    { return 3; }
+  yy337:
+    yych = *++p;
+    if (yych <= 'S') {
+      if (yych <= 'D') {
+        if (yych <= 'C')
+          goto yy333;
+        goto yy358;
+      } else {
+        if (yych <= 'Q')
+          goto yy333;
+        if (yych <= 'R')
+          goto yy359;
+        goto yy360;
+      }
+    } else {
+      if (yych <= 'q') {
+        if (yych == 'd')
+          goto yy358;
+        goto yy333;
+      } else {
+        if (yych <= 'r')
+          goto yy359;
+        if (yych <= 's')
+          goto yy360;
+        goto yy333;
+      }
+    }
+  yy338:
+    yych = *++p;
+    if (yych <= 'O') {
+      if (yych <= 'K') {
+        if (yych == 'A')
+          goto yy361;
+        goto yy333;
+      } else {
+        if (yych <= 'L')
+          goto yy362;
+        if (yych <= 'N')
+          goto yy333;
+        goto yy363;
+      }
+    } else {
+      if (yych <= 'k') {
+        if (yych == 'a')
+          goto yy361;
+        goto yy333;
+      } else {
+        if (yych <= 'l')
+          goto yy362;
+        if (yych == 'o')
+          goto yy363;
+        goto yy333;
+      }
+    }
+  yy339:
+    yych = *++p;
+    if (yych <= 'O') {
+      if (yych <= 'D') {
+        if (yych == 'A')
+          goto yy364;
+        goto yy333;
+      } else {
+        if (yych <= 'E')
+          goto yy365;
+        if (yych <= 'N')
+          goto yy333;
+        goto yy366;
+      }
+    } else {
+      if (yych <= 'd') {
+        if (yych == 'a')
+          goto yy364;
+        goto yy333;
+      } else {
+        if (yych <= 'e')
+          goto yy365;
+        if (yych == 'o')
+          goto yy366;
+        goto yy333;
+      }
+    }
+  yy340:
+    yych = *++p;
+    switch (yych) {
+    case 'D':
+    case 'L':
+    case 'T':
+    case 'd':
+    case 'l':
+    case 't':
+      goto yy367;
+    case 'E':
+    case 'e':
+      goto yy368;
+    case 'I':
+    case 'i':
+      goto yy369;
+    default:
+      goto yy333;
+    }
+  yy341:
+    yych = *++p;
+    if (yych <= 'R') {
+      if (yych <= 'N') {
+        if (yych == 'I')
+          goto yy370;
+        goto yy333;
+      } else {
+        if (yych <= 'O')
+          goto yy371;
+        if (yych <= 'Q')
+          goto yy333;
+        goto yy372;
+      }
+    } else {
+      if (yych <= 'n') {
+        if (yych == 'i')
+          goto yy370;
+        goto yy333;
+      } else {
+        if (yych <= 'o')
+          goto yy371;
+        if (yych == 'r')
+          goto yy372;
+        goto yy333;
+      }
+    }
+  yy342:
+    yych = *++p;
+    if (yych <= 'S') {
+      if (yych <= 'D') {
+        if (yych <= '0')
+          goto yy333;
+        if (yych <= '6')
+          goto yy367;
+        goto yy333;
+      } else {
+        if (yych <= 'E')
+          goto yy373;
+        if (yych == 'R')
+          goto yy367;
+        goto yy333;
+      }
+    } else {
+      if (yych <= 'q') {
+        if (yych <= 'T')
+          goto yy374;
+        if (yych == 'e')
+          goto yy373;
+        goto yy333;
+      } else {
+        if (yych <= 'r')
+          goto yy367;
+        if (yych == 't')
+          goto yy374;
+        goto yy333;
+      }
+    }
+  yy343:
+    yych = *++p;
+    if (yych == 'F')
+      goto yy375;
+    if (yych == 'f')
+      goto yy375;
+    goto yy333;
+  yy344:
+    yych = *++p;
+    if (yych <= 'I') {
+      if (yych == 'E')
+        goto yy376;
+      if (yych <= 'H')
+        goto yy333;
+      goto yy377;
+    } else {
+      if (yych <= 'e') {
+        if (yych <= 'd')
+          goto yy333;
+        goto yy376;
+      } else {
+        if (yych == 'i')
+          goto yy377;
+        goto yy333;
+      }
+    }
+  yy345:
+    yych = *++p;
+    if (yych <= 'E') {
+      if (yych == 'A')
+        goto yy378;
+      if (yych <= 'D')
+        goto yy333;
+      goto yy379;
+    } else {
+      if (yych <= 'a') {
+        if (yych <= '`')
+          goto yy333;
+        goto yy378;
+      } else {
+        if (yych == 'e')
+          goto yy379;
+        goto yy333;
+      }
+    }
+  yy346:
+    yych = *++p;
+    if (yych <= 'O') {
+      if (yych == 'A')
+        goto yy380;
+      if (yych <= 'N')
+        goto yy333;
+      goto yy381;
+    } else {
+      if (yych <= 'a') {
+        if (yych <= '`')
+          goto yy333;
+        goto yy380;
+      } else {
+        if (yych == 'o')
+          goto yy381;
+        goto yy333;
+      }
+    }
+  yy347:
+    yych = *++p;
+    if (yych <= 'P') {
+      if (yych == 'L')
+        goto yy367;
+      if (yych <= 'O')
+        goto yy333;
+      goto yy382;
+    } else {
+      if (yych <= 'l') {
+        if (yych <= 'k')
+          goto yy333;
+        goto yy367;
+      } else {
+        if (yych == 'p')
+          goto yy382;
+        goto yy333;
+      }
+    }
+  yy348:
+    yych = *++p;
+    if (yych <= '>') {
+      if (yych <= ' ') {
+        if (yych <= 0x08)
+          goto yy333;
+        if (yych <= '\r')
+          goto yy383;
+        if (yych <= 0x1F)
+          goto yy333;
+        goto yy383;
+      } else {
+        if (yych == '/')
+          goto yy385;
+        if (yych <= '=')
+          goto yy333;
+        goto yy383;
+      }
+    } else {
+      if (yych <= 'R') {
+        if (yych == 'A')
+          goto yy386;
+        if (yych <= 'Q')
+          goto yy333;
+        goto yy387;
+      } else {
+        if (yych <= 'a') {
+          if (yych <= '`')
+            goto yy333;
+          goto yy386;
+        } else {
+          if (yych == 'r')
+            goto yy387;
+          goto yy333;
+        }
+      }
+    }
+  yy349:
+    yych = *++p;
+    switch (yych) {
+    case 'C':
+    case 'c':
+      goto yy388;
+    case 'E':
+    case 'e':
+      goto yy389;
+    case 'O':
+    case 'o':
+      goto yy390;
+    case 'T':
+    case 't':
+      goto yy391;
+    case 'U':
+    case 'u':
+      goto yy392;
+    default:
+      goto yy333;
+    }
+  yy350:
+    yych = *++p;
+    switch (yych) {
+    case 'A':
+    case 'a':
+      goto yy393;
+    case 'B':
+    case 'b':
+      goto yy394;
+    case 'D':
+    case 'd':
+      goto yy367;
+    case 'F':
+    case 'f':
+      goto yy395;
+    case 'H':
+    case 'h':
+      goto yy396;
+    case 'I':
+    case 'i':
+      goto yy397;
+    case 'R':
+    case 'r':
+      goto yy398;
+    default:
+      goto yy333;
+    }
+  yy351:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy367;
+    if (yych == 'l')
+      goto yy367;
+    goto yy333;
+  yy352:
+    yych = *++p;
+    if (yych == '-')
+      goto yy399;
+    goto yy333;
+  yy353:
+    ++p;
+    { return 4; }
+  yy355:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy401;
+    if (yych == 'c')
+      goto yy401;
+    goto yy333;
+  yy356:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy333;
+        if (yych <= '\r')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= ' ')
+          goto yy383;
+        if (yych <= '.')
+          goto yy333;
+        goto yy385;
+      }
+    } else {
+      if (yych <= '@') {
+        if (yych == '>')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= 'A')
+          goto yy386;
+        if (yych == 'a')
+          goto yy386;
+        goto yy333;
+      }
+    }
+  yy357:
+    yych = *++p;
+    if (yych <= 'U') {
+      if (yych <= 'N') {
+        if (yych == 'E')
+          goto yy389;
+        goto yy333;
+      } else {
+        if (yych <= 'O')
+          goto yy390;
+        if (yych <= 'T')
+          goto yy333;
+        goto yy392;
+      }
+    } else {
+      if (yych <= 'n') {
+        if (yych == 'e')
+          goto yy389;
+        goto yy333;
+      } else {
+        if (yych <= 'o')
+          goto yy390;
+        if (yych == 'u')
+          goto yy392;
+        goto yy333;
+      }
+    }
+  yy358:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy402;
+    if (yych == 'd')
+      goto yy402;
+    goto yy333;
+  yy359:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy403;
+    if (yych == 't')
+      goto yy403;
+    goto yy333;
+  yy360:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy404;
+    if (yych == 'i')
+      goto yy404;
+    goto yy333;
+  yy361:
+    yych = *++p;
+    if (yych == 'S')
+      goto yy405;
+    if (yych == 's')
+      goto yy405;
+    goto yy333;
+  yy362:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy406;
+    if (yych == 'o')
+      goto yy406;
+    goto yy333;
+  yy363:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy407;
+    if (yych == 'd')
+      goto yy407;
+    goto yy333;
+  yy364:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy408;
+    if (yych == 'p')
+      goto yy408;
+    goto yy333;
+  yy365:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy409;
+    if (yych == 'n')
+      goto yy409;
+    goto yy333;
+  yy366:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy410;
+    if (yych == 'l')
+      goto yy410;
+    goto yy333;
+  yy367:
+    yych = *++p;
+    if (yych <= ' ') {
+      if (yych <= 0x08)
+        goto yy333;
+      if (yych <= '\r')
+        goto yy383;
+      if (yych <= 0x1F)
+        goto yy333;
+      goto yy383;
+    } else {
+      if (yych <= '/') {
+        if (yych <= '.')
+          goto yy333;
+        goto yy385;
+      } else {
+        if (yych == '>')
+          goto yy383;
+        goto yy333;
+      }
+    }
+  yy368:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy411;
+    if (yych == 't')
+      goto yy411;
+    goto yy333;
+  yy369:
+    yych = *++p;
+    if (yych <= 'V') {
+      if (yych <= 'Q') {
+        if (yych == 'A')
+          goto yy412;
+        goto yy333;
+      } else {
+        if (yych <= 'R')
+          goto yy367;
+        if (yych <= 'U')
+          goto yy333;
+        goto yy367;
+      }
+    } else {
+      if (yych <= 'q') {
+        if (yych == 'a')
+          goto yy412;
+        goto yy333;
+      } else {
+        if (yych <= 'r')
+          goto yy367;
+        if (yych == 'v')
+          goto yy367;
+        goto yy333;
+      }
+    }
+  yy370:
+    yych = *++p;
+    if (yych <= 'G') {
+      if (yych == 'E')
+        goto yy413;
+      if (yych <= 'F')
+        goto yy333;
+      goto yy414;
+    } else {
+      if (yych <= 'e') {
+        if (yych <= 'd')
+          goto yy333;
+        goto yy413;
+      } else {
+        if (yych == 'g')
+          goto yy414;
+        goto yy333;
+      }
+    }
+  yy371:
+    yych = *++p;
+    if (yych <= 'R') {
+      if (yych == 'O')
+        goto yy409;
+      if (yych <= 'Q')
+        goto yy333;
+      goto yy415;
+    } else {
+      if (yych <= 'o') {
+        if (yych <= 'n')
+          goto yy333;
+        goto yy409;
+      } else {
+        if (yych == 'r')
+          goto yy415;
+        goto yy333;
+      }
+    }
+  yy372:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy416;
+    if (yych == 'a')
+      goto yy416;
+    goto yy333;
+  yy373:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy417;
+    if (yych == 'a')
+      goto yy417;
+    goto yy333;
+  yy374:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy351;
+    if (yych == 'm')
+      goto yy351;
+    goto yy333;
+  yy375:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy418;
+    if (yych == 'r')
+      goto yy418;
+    goto yy333;
+  yy376:
+    yych = *++p;
+    if (yych == 'G')
+      goto yy419;
+    if (yych == 'g')
+      goto yy419;
+    goto yy333;
+  yy377:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy333;
+        if (yych <= '\r')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= ' ')
+          goto yy383;
+        if (yych <= '.')
+          goto yy333;
+        goto yy385;
+      }
+    } else {
+      if (yych <= 'M') {
+        if (yych == '>')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= 'N')
+          goto yy420;
+        if (yych == 'n')
+          goto yy420;
+        goto yy333;
+      }
+    }
+  yy378:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy421;
+    if (yych == 'i')
+      goto yy421;
+    goto yy333;
+  yy379:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy422;
+    if (yych == 'n')
+      goto yy422;
+    goto yy333;
+  yy380:
+    yych = *++p;
+    if (yych == 'V')
+      goto yy367;
+    if (yych == 'v')
+      goto yy367;
+    goto yy333;
+  yy381:
+    yych = *++p;
+    if (yych == 'F')
+      goto yy423;
+    if (yych == 'f')
+      goto yy423;
+    goto yy333;
+  yy382:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy424;
+    if (yych == 't')
+      goto yy424;
+    goto yy333;
+  yy383:
+    ++p;
+    { return 6; }
+  yy385:
+    yych = *++p;
+    if (yych == '>')
+      goto yy383;
+    goto yy333;
+  yy386:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy425;
+    if (yych == 'r')
+      goto yy425;
+    goto yy333;
+  yy387:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy426;
+    if (yych == 'e')
+      goto yy426;
+    goto yy333;
+  yy388:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy427;
+    if (yych == 'r')
+      goto yy427;
+    goto yy333;
+  yy389:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy408;
+    if (yych == 'c')
+      goto yy408;
+    goto yy333;
+  yy390:
+    yych = *++p;
+    if (yych == 'U')
+      goto yy428;
+    if (yych == 'u')
+      goto yy428;
+    goto yy333;
+  yy391:
+    yych = *++p;
+    if (yych == 'Y')
+      goto yy429;
+    if (yych == 'y')
+      goto yy429;
+    goto yy333;
+  yy392:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy430;
+    if (yych == 'm')
+      goto yy430;
+    goto yy333;
+  yy393:
+    yych = *++p;
+    if (yych == 'B')
+      goto yy431;
+    if (yych == 'b')
+      goto yy431;
+    goto yy333;
+  yy394:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy363;
+    if (yych == 'o')
+      goto yy363;
+    goto yy333;
+  yy395:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy432;
+    if (yych == 'o')
+      goto yy432;
+    goto yy333;
+  yy396:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy333;
+        if (yych <= '\r')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= ' ')
+          goto yy383;
+        if (yych <= '.')
+          goto yy333;
+        goto yy385;
+      }
+    } else {
+      if (yych <= 'D') {
+        if (yych == '>')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= 'E')
+          goto yy433;
+        if (yych == 'e')
+          goto yy433;
+        goto yy333;
+      }
+    }
+  yy397:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy431;
+    if (yych == 't')
+      goto yy431;
+    goto yy333;
+  yy398:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy333;
+        if (yych <= '\r')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= ' ')
+          goto yy383;
+        if (yych <= '.')
+          goto yy333;
+        goto yy385;
+      }
+    } else {
+      if (yych <= '@') {
+        if (yych == '>')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= 'A')
+          goto yy434;
+        if (yych == 'a')
+          goto yy434;
+        goto yy333;
+      }
+    }
+  yy399:
+    ++p;
+    { return 2; }
+  yy401:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy435;
+    if (yych == 'd')
+      goto yy435;
+    goto yy333;
+  yy402:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy436;
+    if (yych == 'r')
+      goto yy436;
+    goto yy333;
+  yy403:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy437;
+    if (yych == 'i')
+      goto yy437;
+    goto yy333;
+  yy404:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy438;
+    if (yych == 'd')
+      goto yy438;
+    goto yy333;
+  yy405:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy439;
+    if (yych == 'e')
+      goto yy439;
+    goto yy333;
+  yy406:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy440;
+    if (yych == 'c')
+      goto yy440;
+    goto yy333;
+  yy407:
+    yych = *++p;
+    if (yych == 'Y')
+      goto yy367;
+    if (yych == 'y')
+      goto yy367;
+    goto yy333;
+  yy408:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy441;
+    if (yych == 't')
+      goto yy441;
+    goto yy333;
+  yy409:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy442;
+    if (yych == 't')
+      goto yy442;
+    goto yy333;
+  yy410:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy333;
+        if (yych <= '\r')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= ' ')
+          goto yy383;
+        if (yych <= '.')
+          goto yy333;
+        goto yy385;
+      }
+    } else {
+      if (yych <= 'F') {
+        if (yych == '>')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= 'G')
+          goto yy443;
+        if (yych == 'g')
+          goto yy443;
+        goto yy333;
+      }
+    }
+  yy411:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy444;
+    if (yych == 'a')
+      goto yy444;
+    goto yy333;
+  yy412:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy445;
+    if (yych == 'l')
+      goto yy445;
+    goto yy333;
+  yy413:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy446;
+    if (yych == 'l')
+      goto yy446;
+    goto yy333;
+  yy414:
+    yych = *++p;
+    if (yych <= 'U') {
+      if (yych == 'C')
+        goto yy447;
+      if (yych <= 'T')
+        goto yy333;
+      goto yy448;
+    } else {
+      if (yych <= 'c') {
+        if (yych <= 'b')
+          goto yy333;
+        goto yy447;
+      } else {
+        if (yych == 'u')
+          goto yy448;
+        goto yy333;
+      }
+    }
+  yy415:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy367;
+    if (yych == 'm')
+      goto yy367;
+    goto yy333;
+  yy416:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy449;
+    if (yych == 'm')
+      goto yy449;
+    goto yy333;
+  yy417:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy450;
+    if (yych == 'd')
+      goto yy450;
+    goto yy333;
+  yy418:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy451;
+    if (yych == 'a')
+      goto yy451;
+    goto yy333;
+  yy419:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy452;
+    if (yych == 'e')
+      goto yy452;
+    goto yy333;
+  yy420:
+    yych = *++p;
+    if (yych == 'K')
+      goto yy367;
+    if (yych == 'k')
+      goto yy367;
+    goto yy333;
+  yy421:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy367;
+    if (yych == 'n')
+      goto yy367;
+    goto yy333;
+  yy422:
+    yych = *++p;
+    if (yych == 'U')
+      goto yy453;
+    if (yych == 'u')
+      goto yy453;
+    goto yy333;
+  yy423:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy454;
+    if (yych == 'r')
+      goto yy454;
+    goto yy333;
+  yy424:
+    yych = *++p;
+    if (yych <= 'I') {
+      if (yych == 'G')
+        goto yy443;
+      if (yych <= 'H')
+        goto yy333;
+      goto yy455;
+    } else {
+      if (yych <= 'g') {
+        if (yych <= 'f')
+          goto yy333;
+        goto yy443;
+      } else {
+        if (yych == 'i')
+          goto yy455;
+        goto yy333;
+      }
+    }
+  yy425:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy415;
+    if (yych == 'a')
+      goto yy415;
+    goto yy333;
+  yy426:
+    yych = *++p;
+    if (yych <= 0x1F) {
+      if (yych <= 0x08)
+        goto yy333;
+      if (yych <= '\r')
+        goto yy456;
+      goto yy333;
+    } else {
+      if (yych <= ' ')
+        goto yy456;
+      if (yych == '>')
+        goto yy456;
+      goto yy333;
+    }
+  yy427:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy458;
+    if (yych == 'i')
+      goto yy458;
+    goto yy333;
+  yy428:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy459;
+    if (yych == 'r')
+      goto yy459;
+    goto yy333;
+  yy429:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy387;
+    if (yych == 'l')
+      goto yy387;
+    goto yy333;
+  yy430:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy460;
+    if (yych == 'm')
+      goto yy460;
+    goto yy333;
+  yy431:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy438;
+    if (yych == 'l')
+      goto yy438;
+    goto yy333;
+  yy432:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy461;
+    if (yych == 'o')
+      goto yy461;
+    goto yy333;
+  yy433:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy462;
+    if (yych == 'a')
+      goto yy462;
+    goto yy333;
+  yy434:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy420;
+    if (yych == 'c')
+      goto yy420;
+    goto yy333;
+  yy435:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy463;
+    if (yych == 'a')
+      goto yy463;
+    goto yy333;
+  yy436:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy464;
+    if (yych == 'e')
+      goto yy464;
+    goto yy333;
+  yy437:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy431;
+    if (yych == 'c')
+      goto yy431;
+    goto yy333;
+  yy438:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy367;
+    if (yych == 'e')
+      goto yy367;
+    goto yy333;
+  yy439:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy333;
+        if (yych <= '\r')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= ' ')
+          goto yy383;
+        if (yych <= '.')
+          goto yy333;
+        goto yy385;
+      }
+    } else {
+      if (yych <= 'E') {
+        if (yych == '>')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= 'F')
+          goto yy465;
+        if (yych == 'f')
+          goto yy465;
+        goto yy333;
+      }
+    }
+  yy440:
+    yych = *++p;
+    if (yych == 'K')
+      goto yy466;
+    if (yych == 'k')
+      goto yy466;
+    goto yy333;
+  yy441:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy455;
+    if (yych == 'i')
+      goto yy455;
+    goto yy333;
+  yy442:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy467;
+    if (yych == 'e')
+      goto yy467;
+    goto yy333;
+  yy443:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy468;
+    if (yych == 'r')
+      goto yy468;
+    goto yy333;
+  yy444:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy469;
+    if (yych == 'i')
+      goto yy469;
+    goto yy333;
+  yy445:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy470;
+    if (yych == 'o')
+      goto yy470;
+    goto yy333;
+  yy446:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy471;
+    if (yych == 'd')
+      goto yy471;
+    goto yy333;
+  yy447:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy364;
+    if (yych == 'a')
+      goto yy364;
+    goto yy333;
+  yy448:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy438;
+    if (yych == 'r')
+      goto yy438;
+    goto yy333;
+  yy449:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy472;
+    if (yych == 'e')
+      goto yy472;
+    goto yy333;
+  yy450:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy333;
+        if (yych <= '\r')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= ' ')
+          goto yy383;
+        if (yych <= '.')
+          goto yy333;
+        goto yy385;
+      }
+    } else {
+      if (yych <= 'D') {
+        if (yych == '>')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= 'E')
+          goto yy467;
+        if (yych == 'e')
+          goto yy467;
+        goto yy333;
+      }
+    }
+  yy451:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy438;
+    if (yych == 'm')
+      goto yy438;
+    goto yy333;
+  yy452:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy462;
+    if (yych == 'n')
+      goto yy462;
+    goto yy333;
+  yy453:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy333;
+        if (yych <= '\r')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= ' ')
+          goto yy383;
+        if (yych <= '.')
+          goto yy333;
+        goto yy385;
+      }
+    } else {
+      if (yych <= 'H') {
+        if (yych == '>')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= 'I')
+          goto yy473;
+        if (yych == 'i')
+          goto yy473;
+        goto yy333;
+      }
+    }
+  yy454:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy474;
+    if (yych == 'a')
+      goto yy474;
+    goto yy333;
+  yy455:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy421;
+    if (yych == 'o')
+      goto yy421;
+    goto yy333;
+  yy456:
+    ++p;
+    { return 1; }
+  yy458:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy475;
+    if (yych == 'p')
+      goto yy475;
+    goto yy333;
+  yy459:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy438;
+    if (yych == 'c')
+      goto yy438;
+    goto yy333;
+  yy460:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy476;
+    if (yych == 'a')
+      goto yy476;
+    goto yy333;
+  yy461:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy367;
+    if (yych == 't')
+      goto yy367;
+    goto yy333;
+  yy462:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy367;
+    if (yych == 'd')
+      goto yy367;
+    goto yy333;
+  yy463:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy477;
+    if (yych == 't')
+      goto yy477;
+    goto yy333;
+  yy464:
+    yych = *++p;
+    if (yych == 'S')
+      goto yy478;
+    if (yych == 's')
+      goto yy478;
+    goto yy333;
+  yy465:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy479;
+    if (yych == 'o')
+      goto yy479;
+    goto yy333;
+  yy466:
+    yych = *++p;
+    if (yych == 'Q')
+      goto yy480;
+    if (yych == 'q')
+      goto yy480;
+    goto yy333;
+  yy467:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy367;
+    if (yych == 'r')
+      goto yy367;
+    goto yy333;
+  yy468:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy481;
+    if (yych == 'o')
+      goto yy481;
+    goto yy333;
+  yy469:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy478;
+    if (yych == 'l')
+      goto yy478;
+    goto yy333;
+  yy470:
+    yych = *++p;
+    if (yych == 'G')
+      goto yy367;
+    if (yych == 'g')
+      goto yy367;
+    goto yy333;
+  yy471:
+    yych = *++p;
+    if (yych == 'S')
+      goto yy482;
+    if (yych == 's')
+      goto yy482;
+    goto yy333;
+  yy472:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy333;
+        if (yych <= '\r')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= ' ')
+          goto yy383;
+        if (yych <= '.')
+          goto yy333;
+        goto yy385;
+      }
+    } else {
+      if (yych <= 'R') {
+        if (yych == '>')
+          goto yy383;
+        goto yy333;
+      } else {
+        if (yych <= 'S')
+          goto yy482;
+        if (yych == 's')
+          goto yy482;
+        goto yy333;
+      }
+    }
+  yy473:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy483;
+    if (yych == 't')
+      goto yy483;
+    goto yy333;
+  yy474:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy484;
+    if (yych == 'm')
+      goto yy484;
+    goto yy333;
+  yy475:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy426;
+    if (yych == 't')
+      goto yy426;
+    goto yy333;
+  yy476:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy407;
+    if (yych == 'r')
+      goto yy407;
+    goto yy333;
+  yy477:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy485;
+    if (yych == 'a')
+      goto yy485;
+    goto yy333;
+  yy478:
+    yych = *++p;
+    if (yych == 'S')
+      goto yy367;
+    if (yych == 's')
+      goto yy367;
+    goto yy333;
+  yy479:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy461;
+    if (yych == 'n')
+      goto yy461;
+    goto yy333;
+  yy480:
+    yych = *++p;
+    if (yych == 'U')
+      goto yy486;
+    if (yych == 'u')
+      goto yy486;
+    goto yy333;
+  yy481:
+    yych = *++p;
+    if (yych == 'U')
+      goto yy487;
+    if (yych == 'u')
+      goto yy487;
+    goto yy333;
+  yy482:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy461;
+    if (yych == 'e')
+      goto yy461;
+    goto yy333;
+  yy483:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy415;
+    if (yych == 'e')
+      goto yy415;
+    goto yy333;
+  yy484:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy478;
+    if (yych == 'e')
+      goto yy478;
+    goto yy333;
+  yy485:
+    yych = *++p;
+    if (yych == '[')
+      goto yy488;
+    goto yy333;
+  yy486:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy490;
+    if (yych == 'o')
+      goto yy490;
+    goto yy333;
+  yy487:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy367;
+    if (yych == 'p')
+      goto yy367;
+    goto yy333;
+  yy488:
+    ++p;
+    { return 5; }
+  yy490:
+    ++p;
+    if ((yych = *p) == 'T')
+      goto yy438;
+    if (yych == 't')
+      goto yy438;
+    goto yy333;
+  }
+}
+
+// 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, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   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 yy495;
+    ++p;
+  yy494 : { return 0; }
+  yy495:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '@') {
+      if (yych != '/')
+        goto yy494;
+    } else {
+      if (yych <= 'Z')
+        goto yy498;
+      if (yych <= '`')
+        goto yy494;
+      if (yych <= 'z')
+        goto yy498;
+      goto yy494;
+    }
+    yych = *++p;
+    if (yych <= '@')
+      goto yy497;
+    if (yych <= 'Z')
+      goto yy500;
+    if (yych <= '`')
+      goto yy497;
+    if (yych <= 'z')
+      goto yy500;
+  yy497:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy494;
+    } else {
+      goto yy513;
+    }
+  yy498:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 2) {
+      goto yy502;
+    }
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych == '-')
+          goto yy498;
+        goto yy497;
+      } else {
+        if (yych <= '/')
+          goto yy504;
+        if (yych <= '9')
+          goto yy498;
+        goto yy497;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy505;
+        if (yych <= '@')
+          goto yy497;
+        goto yy498;
+      } else {
+        if (yych <= '`')
+          goto yy497;
+        if (yych <= 'z')
+          goto yy498;
+        goto yy497;
+      }
+    }
+  yy500:
+    ++p;
+    yych = *p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy497;
+        if (yych <= '\r')
+          goto yy507;
+        goto yy497;
+      } else {
+        if (yych <= ' ')
+          goto yy507;
+        if (yych == '-')
+          goto yy500;
+        goto yy497;
+      }
+    } else {
+      if (yych <= '@') {
+        if (yych <= '9')
+          goto yy500;
+        if (yych == '>')
+          goto yy505;
+        goto yy497;
+      } else {
+        if (yych <= 'Z')
+          goto yy500;
+        if (yych <= '`')
+          goto yy497;
+        if (yych <= 'z')
+          goto yy500;
+        goto yy497;
+      }
+    }
+  yy502:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 2) {
+      goto yy502;
+    }
+    if (yych <= '>') {
+      if (yych <= '9') {
+        if (yych != '/')
+          goto yy497;
+      } else {
+        if (yych <= ':')
+          goto yy509;
+        if (yych <= '=')
+          goto yy497;
+        goto yy505;
+      }
+    } else {
+      if (yych <= '^') {
+        if (yych <= '@')
+          goto yy497;
+        if (yych <= 'Z')
+          goto yy509;
+        goto yy497;
+      } else {
+        if (yych == '`')
+          goto yy497;
+        if (yych <= 'z')
+          goto yy509;
+        goto yy497;
+      }
+    }
+  yy504:
+    yych = *++p;
+    if (yych != '>')
+      goto yy497;
+  yy505:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 4) {
+      goto yy505;
+    }
+    if (yych <= 0x08)
+      goto yy497;
+    if (yych <= '\n')
+      goto yy511;
+    if (yych <= '\v')
+      goto yy497;
+    if (yych <= '\r')
+      goto yy514;
+    goto yy497;
+  yy507:
+    ++p;
+    yych = *p;
+    if (yych <= 0x1F) {
+      if (yych <= 0x08)
+        goto yy497;
+      if (yych <= '\r')
+        goto yy507;
+      goto yy497;
+    } else {
+      if (yych <= ' ')
+        goto yy507;
+      if (yych == '>')
+        goto yy505;
+      goto yy497;
+    }
+  yy509:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 8) {
+      goto yy509;
+    }
+    if (yych <= ',') {
+      if (yych <= '\r') {
+        if (yych <= 0x08)
+          goto yy497;
+        goto yy515;
+      } else {
+        if (yych == ' ')
+          goto yy515;
+        goto yy497;
+      }
+    } else {
+      if (yych <= '<') {
+        if (yych <= '/')
+          goto yy504;
+        goto yy497;
+      } else {
+        if (yych <= '=')
+          goto yy517;
+        if (yych <= '>')
+          goto yy505;
+        goto yy497;
+      }
+    }
+  yy511:
+    yyaccept = 1;
+    marker = ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 4) {
+      goto yy505;
+    }
+    if (yych <= 0x08)
+      goto yy513;
+    if (yych <= '\n')
+      goto yy511;
+    if (yych <= '\v')
+      goto yy513;
+    if (yych <= '\r')
+      goto yy514;
+  yy513 : { return 7; }
+  yy514:
+    yych = *++p;
+    goto yy513;
+  yy515:
+    ++p;
+    yych = *p;
+    if (yych <= '<') {
+      if (yych <= ' ') {
+        if (yych <= 0x08)
+          goto yy497;
+        if (yych <= '\r')
+          goto yy515;
+        if (yych <= 0x1F)
+          goto yy497;
+        goto yy515;
+      } else {
+        if (yych <= '/') {
+          if (yych <= '.')
+            goto yy497;
+          goto yy504;
+        } else {
+          if (yych == ':')
+            goto yy509;
+          goto yy497;
+        }
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '=')
+          goto yy517;
+        if (yych <= '>')
+          goto yy505;
+        if (yych <= '@')
+          goto yy497;
+        goto yy509;
+      } else {
+        if (yych <= '_') {
+          if (yych <= '^')
+            goto yy497;
+          goto yy509;
+        } else {
+          if (yych <= '`')
+            goto yy497;
+          if (yych <= 'z')
+            goto yy509;
+          goto yy497;
+        }
+      }
+    }
+  yy517:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 32) {
+      goto yy519;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '"') {
+        if (yych <= 0x00)
+          goto yy497;
+        if (yych <= ' ')
+          goto yy517;
+        goto yy521;
+      } else {
+        if (yych <= '\'')
+          goto yy523;
+        if (yych <= 0xC1)
+          goto yy497;
+        if (yych <= 0xDF)
+          goto yy525;
+        goto yy526;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy528;
+        goto yy527;
+      } else {
+        if (yych <= 0xF0)
+          goto yy529;
+        if (yych <= 0xF3)
+          goto yy530;
+        if (yych <= 0xF4)
+          goto yy531;
+        goto yy497;
+      }
+    }
+  yy519:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 32) {
+      goto yy519;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '=') {
+        if (yych <= 0x00)
+          goto yy497;
+        if (yych <= ' ')
+          goto yy502;
+        goto yy497;
+      } else {
+        if (yych <= '>')
+          goto yy505;
+        if (yych <= 0xC1)
+          goto yy497;
+        if (yych <= 0xDF)
+          goto yy525;
+        goto yy526;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy528;
+        goto yy527;
+      } else {
+        if (yych <= 0xF0)
+          goto yy529;
+        if (yych <= 0xF3)
+          goto yy530;
+        if (yych <= 0xF4)
+          goto yy531;
+        goto yy497;
+      }
+    }
+  yy521:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy521;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy497;
+        if (yych <= '"')
+          goto yy532;
+        goto yy497;
+      } else {
+        if (yych <= 0xDF)
+          goto yy533;
+        if (yych <= 0xE0)
+          goto yy534;
+        goto yy535;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy536;
+        if (yych <= 0xEF)
+          goto yy535;
+        goto yy537;
+      } else {
+        if (yych <= 0xF3)
+          goto yy538;
+        if (yych <= 0xF4)
+          goto yy539;
+        goto yy497;
+      }
+    }
+  yy523:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy523;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy497;
+        if (yych <= '\'')
+          goto yy532;
+        goto yy497;
+      } else {
+        if (yych <= 0xDF)
+          goto yy540;
+        if (yych <= 0xE0)
+          goto yy541;
+        goto yy542;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy543;
+        if (yych <= 0xEF)
+          goto yy542;
+        goto yy544;
+      } else {
+        if (yych <= 0xF3)
+          goto yy545;
+        if (yych <= 0xF4)
+          goto yy546;
+        goto yy497;
+      }
+    }
+  yy525:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy519;
+    goto yy497;
+  yy526:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy525;
+    goto yy497;
+  yy527:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy525;
+    goto yy497;
+  yy528:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0x9F)
+      goto yy525;
+    goto yy497;
+  yy529:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy527;
+    goto yy497;
+  yy530:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy527;
+    goto yy497;
+  yy531:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0x8F)
+      goto yy527;
+    goto yy497;
+  yy532:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 2) {
+      goto yy502;
+    }
+    if (yych == '/')
+      goto yy504;
+    if (yych == '>')
+      goto yy505;
+    goto yy497;
+  yy533:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy521;
+    goto yy497;
+  yy534:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy533;
+    goto yy497;
+  yy535:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy533;
+    goto yy497;
+  yy536:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0x9F)
+      goto yy533;
+    goto yy497;
+  yy537:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy535;
+    goto yy497;
+  yy538:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy535;
+    goto yy497;
+  yy539:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0x8F)
+      goto yy535;
+    goto yy497;
+  yy540:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy523;
+    goto yy497;
+  yy541:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy540;
+    goto yy497;
+  yy542:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy540;
+    goto yy497;
+  yy543:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0x9F)
+      goto yy540;
+    goto yy497;
+  yy544:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy542;
+    goto yy497;
+  yy545:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0xBF)
+      goto yy542;
+    goto yy497;
+  yy546:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy497;
+    if (yych <= 0x8F)
+      goto yy542;
+    goto yy497;
+  }
+}
+
+// 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, 0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,
+    };
+    yych = *p;
+    if (yych <= 0xDF) {
+      if (yych <= ';') {
+        if (yych <= 0x00)
+          goto yy549;
+        if (yych != '\n')
+          goto yy551;
+      } else {
+        if (yych <= '<')
+          goto yy552;
+        if (yych <= 0x7F)
+          goto yy551;
+        if (yych >= 0xC2)
+          goto yy553;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy554;
+        if (yych == 0xED)
+          goto yy556;
+        goto yy555;
+      } else {
+        if (yych <= 0xF0)
+          goto yy557;
+        if (yych <= 0xF3)
+          goto yy558;
+        if (yych <= 0xF4)
+          goto yy559;
+      }
+    }
+  yy549:
+    ++p;
+  yy550 : { return 0; }
+  yy551:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy550;
+      if (yych <= '\t')
+        goto yy561;
+      goto yy550;
+    } else {
+      if (yych <= 0x7F)
+        goto yy561;
+      if (yych <= 0xC1)
+        goto yy550;
+      if (yych <= 0xF4)
+        goto yy561;
+      goto yy550;
+    }
+  yy552:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '.') {
+      if (yych <= 0x00)
+        goto yy550;
+      if (yych == '\n')
+        goto yy550;
+      goto yy561;
+    } else {
+      if (yych <= 0x7F) {
+        if (yych <= '/')
+          goto yy572;
+        goto yy561;
+      } else {
+        if (yych <= 0xC1)
+          goto yy550;
+        if (yych <= 0xF4)
+          goto yy561;
+        goto yy550;
+      }
+    }
+  yy553:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy550;
+    if (yych <= 0xBF)
+      goto yy560;
+    goto yy550;
+  yy554:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x9F)
+      goto yy550;
+    if (yych <= 0xBF)
+      goto yy565;
+    goto yy550;
+  yy555:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy550;
+    if (yych <= 0xBF)
+      goto yy565;
+    goto yy550;
+  yy556:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy550;
+    if (yych <= 0x9F)
+      goto yy565;
+    goto yy550;
+  yy557:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x8F)
+      goto yy550;
+    if (yych <= 0xBF)
+      goto yy567;
+    goto yy550;
+  yy558:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy550;
+    if (yych <= 0xBF)
+      goto yy567;
+    goto yy550;
+  yy559:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy550;
+    if (yych <= 0x8F)
+      goto yy567;
+    goto yy550;
+  yy560:
+    ++p;
+    yych = *p;
+  yy561:
+    if (yybm[0 + yych] & 64) {
+      goto yy560;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy562;
+        if (yych <= '<')
+          goto yy563;
+      } else {
+        if (yych <= 0xDF)
+          goto yy565;
+        if (yych <= 0xE0)
+          goto yy566;
+        goto yy567;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy568;
+        if (yych <= 0xEF)
+          goto yy567;
+        goto yy569;
+      } else {
+        if (yych <= 0xF3)
+          goto yy570;
+        if (yych <= 0xF4)
+          goto yy571;
+      }
+    }
+  yy562:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy550;
+    } else {
+      goto yy582;
+    }
+  yy563:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 0xDF) {
+      if (yych <= '.') {
+        if (yych <= 0x00)
+          goto yy562;
+        if (yych == '\n')
+          goto yy562;
+        goto yy560;
+      } else {
+        if (yych <= '/')
+          goto yy572;
+        if (yych <= 0x7F)
+          goto yy560;
+        if (yych <= 0xC1)
+          goto yy562;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy566;
+        if (yych == 0xED)
+          goto yy568;
+        goto yy567;
+      } else {
+        if (yych <= 0xF0)
+          goto yy569;
+        if (yych <= 0xF3)
+          goto yy570;
+        if (yych <= 0xF4)
+          goto yy571;
+        goto yy562;
+      }
+    }
+  yy565:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy562;
+    if (yych <= 0xBF)
+      goto yy560;
+    goto yy562;
+  yy566:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy562;
+    if (yych <= 0xBF)
+      goto yy565;
+    goto yy562;
+  yy567:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy562;
+    if (yych <= 0xBF)
+      goto yy565;
+    goto yy562;
+  yy568:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy562;
+    if (yych <= 0x9F)
+      goto yy565;
+    goto yy562;
+  yy569:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy562;
+    if (yych <= 0xBF)
+      goto yy567;
+    goto yy562;
+  yy570:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy562;
+    if (yych <= 0xBF)
+      goto yy567;
+    goto yy562;
+  yy571:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy562;
+    if (yych <= 0x8F)
+      goto yy567;
+    goto yy562;
+  yy572:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 's') {
+      if (yych <= 'P') {
+        if (yych <= '\t') {
+          if (yych <= 0x00)
+            goto yy562;
+          goto yy560;
+        } else {
+          if (yych <= '\n')
+            goto yy562;
+          if (yych <= 'O')
+            goto yy560;
+        }
+      } else {
+        if (yych <= 'o') {
+          if (yych == 'S')
+            goto yy574;
+          goto yy560;
+        } else {
+          if (yych <= 'p')
+            goto yy573;
+          if (yych <= 'r')
+            goto yy560;
+          goto yy574;
+        }
+      }
+    } else {
+      if (yych <= 0xEC) {
+        if (yych <= 0xC1) {
+          if (yych <= 0x7F)
+            goto yy560;
+          goto yy562;
+        } else {
+          if (yych <= 0xDF)
+            goto yy565;
+          if (yych <= 0xE0)
+            goto yy566;
+          goto yy567;
+        }
+      } else {
+        if (yych <= 0xF0) {
+          if (yych <= 0xED)
+            goto yy568;
+          if (yych <= 0xEF)
+            goto yy567;
+          goto yy569;
+        } else {
+          if (yych <= 0xF3)
+            goto yy570;
+          if (yych <= 0xF4)
+            goto yy571;
+          goto yy562;
+        }
+      }
+    }
+  yy573:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 0xC1) {
+      if (yych <= 'Q') {
+        if (yych <= 0x00)
+          goto yy562;
+        if (yych == '\n')
+          goto yy562;
+        goto yy560;
+      } else {
+        if (yych <= 'q') {
+          if (yych <= 'R')
+            goto yy575;
+          goto yy560;
+        } else {
+          if (yych <= 'r')
+            goto yy575;
+          if (yych <= 0x7F)
+            goto yy560;
+          goto yy562;
+        }
+      }
+    } else {
+      if (yych <= 0xED) {
+        if (yych <= 0xDF)
+          goto yy565;
+        if (yych <= 0xE0)
+          goto yy566;
+        if (yych <= 0xEC)
+          goto yy567;
+        goto yy568;
+      } else {
+        if (yych <= 0xF0) {
+          if (yych <= 0xEF)
+            goto yy567;
+          goto yy569;
+        } else {
+          if (yych <= 0xF3)
+            goto yy570;
+          if (yych <= 0xF4)
+            goto yy571;
+          goto yy562;
+        }
+      }
+    }
+  yy574:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 't') {
+      if (yych <= 'C') {
+        if (yych <= '\t') {
+          if (yych <= 0x00)
+            goto yy562;
+          goto yy560;
+        } else {
+          if (yych <= '\n')
+            goto yy562;
+          if (yych <= 'B')
+            goto yy560;
+          goto yy576;
+        }
+      } else {
+        if (yych <= 'b') {
+          if (yych == 'T')
+            goto yy577;
+          goto yy560;
+        } else {
+          if (yych <= 'c')
+            goto yy576;
+          if (yych <= 's')
+            goto yy560;
+          goto yy577;
+        }
+      }
+    } else {
+      if (yych <= 0xEC) {
+        if (yych <= 0xC1) {
+          if (yych <= 0x7F)
+            goto yy560;
+          goto yy562;
+        } else {
+          if (yych <= 0xDF)
+            goto yy565;
+          if (yych <= 0xE0)
+            goto yy566;
+          goto yy567;
+        }
+      } else {
+        if (yych <= 0xF0) {
+          if (yych <= 0xED)
+            goto yy568;
+          if (yych <= 0xEF)
+            goto yy567;
+          goto yy569;
+        } else {
+          if (yych <= 0xF3)
+            goto yy570;
+          if (yych <= 0xF4)
+            goto yy571;
+          goto yy562;
+        }
+      }
+    }
+  yy575:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 0xC1) {
+      if (yych <= 'D') {
+        if (yych <= 0x00)
+          goto yy562;
+        if (yych == '\n')
+          goto yy562;
+        goto yy560;
+      } else {
+        if (yych <= 'd') {
+          if (yych <= 'E')
+            goto yy578;
+          goto yy560;
+        } else {
+          if (yych <= 'e')
+            goto yy578;
+          if (yych <= 0x7F)
+            goto yy560;
+          goto yy562;
+        }
+      }
+    } else {
+      if (yych <= 0xED) {
+        if (yych <= 0xDF)
+          goto yy565;
+        if (yych <= 0xE0)
+          goto yy566;
+        if (yych <= 0xEC)
+          goto yy567;
+        goto yy568;
+      } else {
+        if (yych <= 0xF0) {
+          if (yych <= 0xEF)
+            goto yy567;
+          goto yy569;
+        } else {
+          if (yych <= 0xF3)
+            goto yy570;
+          if (yych <= 0xF4)
+            goto yy571;
+          goto yy562;
+        }
+      }
+    }
+  yy576:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 0xC1) {
+      if (yych <= 'Q') {
+        if (yych <= 0x00)
+          goto yy562;
+        if (yych == '\n')
+          goto yy562;
+        goto yy560;
+      } else {
+        if (yych <= 'q') {
+          if (yych <= 'R')
+            goto yy579;
+          goto yy560;
+        } else {
+          if (yych <= 'r')
+            goto yy579;
+          if (yych <= 0x7F)
+            goto yy560;
+          goto yy562;
+        }
+      }
+    } else {
+      if (yych <= 0xED) {
+        if (yych <= 0xDF)
+          goto yy565;
+        if (yych <= 0xE0)
+          goto yy566;
+        if (yych <= 0xEC)
+          goto yy567;
+        goto yy568;
+      } else {
+        if (yych <= 0xF0) {
+          if (yych <= 0xEF)
+            goto yy567;
+          goto yy569;
+        } else {
+          if (yych <= 0xF3)
+            goto yy570;
+          if (yych <= 0xF4)
+            goto yy571;
+          goto yy562;
+        }
+      }
+    }
+  yy577:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 0xC1) {
+      if (yych <= 'X') {
+        if (yych <= 0x00)
+          goto yy562;
+        if (yych == '\n')
+          goto yy562;
+        goto yy560;
+      } else {
+        if (yych <= 'x') {
+          if (yych <= 'Y')
+            goto yy580;
+          goto yy560;
+        } else {
+          if (yych <= 'y')
+            goto yy580;
+          if (yych <= 0x7F)
+            goto yy560;
+          goto yy562;
+        }
+      }
+    } else {
+      if (yych <= 0xED) {
+        if (yych <= 0xDF)
+          goto yy565;
+        if (yych <= 0xE0)
+          goto yy566;
+        if (yych <= 0xEC)
+          goto yy567;
+        goto yy568;
+      } else {
+        if (yych <= 0xF0) {
+          if (yych <= 0xEF)
+            goto yy567;
+          goto yy569;
+        } else {
+          if (yych <= 0xF3)
+            goto yy570;
+          if (yych <= 0xF4)
+            goto yy571;
+          goto yy562;
+        }
+      }
+    }
+  yy578:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 0xDF) {
+      if (yych <= '=') {
+        if (yych <= 0x00)
+          goto yy562;
+        if (yych == '\n')
+          goto yy562;
+        goto yy560;
+      } else {
+        if (yych <= '>')
+          goto yy581;
+        if (yych <= 0x7F)
+          goto yy560;
+        if (yych <= 0xC1)
+          goto yy562;
+        goto yy565;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy566;
+        if (yych == 0xED)
+          goto yy568;
+        goto yy567;
+      } else {
+        if (yych <= 0xF0)
+          goto yy569;
+        if (yych <= 0xF3)
+          goto yy570;
+        if (yych <= 0xF4)
+          goto yy571;
+        goto yy562;
+      }
+    }
+  yy579:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 0xC1) {
+      if (yych <= 'H') {
+        if (yych <= 0x00)
+          goto yy562;
+        if (yych == '\n')
+          goto yy562;
+        goto yy560;
+      } else {
+        if (yych <= 'h') {
+          if (yych <= 'I')
+            goto yy583;
+          goto yy560;
+        } else {
+          if (yych <= 'i')
+            goto yy583;
+          if (yych <= 0x7F)
+            goto yy560;
+          goto yy562;
+        }
+      }
+    } else {
+      if (yych <= 0xED) {
+        if (yych <= 0xDF)
+          goto yy565;
+        if (yych <= 0xE0)
+          goto yy566;
+        if (yych <= 0xEC)
+          goto yy567;
+        goto yy568;
+      } else {
+        if (yych <= 0xF0) {
+          if (yych <= 0xEF)
+            goto yy567;
+          goto yy569;
+        } else {
+          if (yych <= 0xF3)
+            goto yy570;
+          if (yych <= 0xF4)
+            goto yy571;
+          goto yy562;
+        }
+      }
+    }
+  yy580:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 0xC1) {
+      if (yych <= 'K') {
+        if (yych <= 0x00)
+          goto yy562;
+        if (yych == '\n')
+          goto yy562;
+        goto yy560;
+      } else {
+        if (yych <= 'k') {
+          if (yych <= 'L')
+            goto yy575;
+          goto yy560;
+        } else {
+          if (yych <= 'l')
+            goto yy575;
+          if (yych <= 0x7F)
+            goto yy560;
+          goto yy562;
+        }
+      }
+    } else {
+      if (yych <= 0xED) {
+        if (yych <= 0xDF)
+          goto yy565;
+        if (yych <= 0xE0)
+          goto yy566;
+        if (yych <= 0xEC)
+          goto yy567;
+        goto yy568;
+      } else {
+        if (yych <= 0xF0) {
+          if (yych <= 0xEF)
+            goto yy567;
+          goto yy569;
+        } else {
+          if (yych <= 0xF3)
+            goto yy570;
+          if (yych <= 0xF4)
+            goto yy571;
+          goto yy562;
+        }
+      }
+    }
+  yy581:
+    yyaccept = 1;
+    marker = ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy560;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy582;
+        if (yych <= '<')
+          goto yy563;
+      } else {
+        if (yych <= 0xDF)
+          goto yy565;
+        if (yych <= 0xE0)
+          goto yy566;
+        goto yy567;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy568;
+        if (yych <= 0xEF)
+          goto yy567;
+        goto yy569;
+      } else {
+        if (yych <= 0xF3)
+          goto yy570;
+        if (yych <= 0xF4)
+          goto yy571;
+      }
+    }
+  yy582 : { return (bufsize_t)(p - start); }
+  yy583:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 0xC1) {
+      if (yych <= 'O') {
+        if (yych <= 0x00)
+          goto yy562;
+        if (yych == '\n')
+          goto yy562;
+        goto yy560;
+      } else {
+        if (yych <= 'o') {
+          if (yych >= 'Q')
+            goto yy560;
+        } else {
+          if (yych <= 'p')
+            goto yy584;
+          if (yych <= 0x7F)
+            goto yy560;
+          goto yy562;
+        }
+      }
+    } else {
+      if (yych <= 0xED) {
+        if (yych <= 0xDF)
+          goto yy565;
+        if (yych <= 0xE0)
+          goto yy566;
+        if (yych <= 0xEC)
+          goto yy567;
+        goto yy568;
+      } else {
+        if (yych <= 0xF0) {
+          if (yych <= 0xEF)
+            goto yy567;
+          goto yy569;
+        } else {
+          if (yych <= 0xF3)
+            goto yy570;
+          if (yych <= 0xF4)
+            goto yy571;
+          goto yy562;
+        }
+      }
+    }
+  yy584:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy563;
+    }
+    if (yych <= 0xC1) {
+      if (yych <= 'S') {
+        if (yych <= 0x00)
+          goto yy562;
+        if (yych == '\n')
+          goto yy562;
+        goto yy560;
+      } else {
+        if (yych <= 's') {
+          if (yych <= 'T')
+            goto yy578;
+          goto yy560;
+        } else {
+          if (yych <= 't')
+            goto yy578;
+          if (yych <= 0x7F)
+            goto yy560;
+          goto yy562;
+        }
+      }
+    } else {
+      if (yych <= 0xED) {
+        if (yych <= 0xDF)
+          goto yy565;
+        if (yych <= 0xE0)
+          goto yy566;
+        if (yych <= 0xEC)
+          goto yy567;
+        goto yy568;
+      } else {
+        if (yych <= 0xF0) {
+          if (yych <= 0xEF)
+            goto yy567;
+          goto yy569;
+        } else {
+          if (yych <= 0xF3)
+            goto yy570;
+          if (yych <= 0xF4)
+            goto yy571;
+          goto yy562;
+        }
+      }
+    }
+  }
+}
+
+// Try to match an HTML block end line of type 2
+bufsize_t _scan_html_block_end_2(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,  64, 64, 64, 64, 64, 64, 64, 64, 64,  0,  64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,
+    };
+    yych = *p;
+    if (yych <= 0xDF) {
+      if (yych <= ',') {
+        if (yych <= 0x00)
+          goto yy587;
+        if (yych != '\n')
+          goto yy589;
+      } else {
+        if (yych <= '-')
+          goto yy590;
+        if (yych <= 0x7F)
+          goto yy589;
+        if (yych >= 0xC2)
+          goto yy591;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy592;
+        if (yych == 0xED)
+          goto yy594;
+        goto yy593;
+      } else {
+        if (yych <= 0xF0)
+          goto yy595;
+        if (yych <= 0xF3)
+          goto yy596;
+        if (yych <= 0xF4)
+          goto yy597;
+      }
+    }
+  yy587:
+    ++p;
+  yy588 : { return 0; }
+  yy589:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy588;
+      if (yych <= '\t')
+        goto yy599;
+      goto yy588;
+    } else {
+      if (yych <= 0x7F)
+        goto yy599;
+      if (yych <= 0xC1)
+        goto yy588;
+      if (yych <= 0xF4)
+        goto yy599;
+      goto yy588;
+    }
+  yy590:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 128) {
+      goto yy609;
+    }
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy588;
+      if (yych <= '\t')
+        goto yy599;
+      goto yy588;
+    } else {
+      if (yych <= 0x7F)
+        goto yy599;
+      if (yych <= 0xC1)
+        goto yy588;
+      if (yych <= 0xF4)
+        goto yy599;
+      goto yy588;
+    }
+  yy591:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy588;
+    if (yych <= 0xBF)
+      goto yy598;
+    goto yy588;
+  yy592:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x9F)
+      goto yy588;
+    if (yych <= 0xBF)
+      goto yy602;
+    goto yy588;
+  yy593:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy588;
+    if (yych <= 0xBF)
+      goto yy602;
+    goto yy588;
+  yy594:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy588;
+    if (yych <= 0x9F)
+      goto yy602;
+    goto yy588;
+  yy595:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x8F)
+      goto yy588;
+    if (yych <= 0xBF)
+      goto yy604;
+    goto yy588;
+  yy596:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy588;
+    if (yych <= 0xBF)
+      goto yy604;
+    goto yy588;
+  yy597:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy588;
+    if (yych <= 0x8F)
+      goto yy604;
+    goto yy588;
+  yy598:
+    ++p;
+    yych = *p;
+  yy599:
+    if (yybm[0 + yych] & 64) {
+      goto yy598;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy600;
+        if (yych <= '-')
+          goto yy601;
+      } else {
+        if (yych <= 0xDF)
+          goto yy602;
+        if (yych <= 0xE0)
+          goto yy603;
+        goto yy604;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy605;
+        if (yych <= 0xEF)
+          goto yy604;
+        goto yy606;
+      } else {
+        if (yych <= 0xF3)
+          goto yy607;
+        if (yych <= 0xF4)
+          goto yy608;
+      }
+    }
+  yy600:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy588;
+    } else {
+      goto yy612;
+    }
+  yy601:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy598;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy600;
+        if (yych <= '-')
+          goto yy609;
+        goto yy600;
+      } else {
+        if (yych <= 0xDF)
+          goto yy602;
+        if (yych <= 0xE0)
+          goto yy603;
+        goto yy604;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy605;
+        if (yych <= 0xEF)
+          goto yy604;
+        goto yy606;
+      } else {
+        if (yych <= 0xF3)
+          goto yy607;
+        if (yych <= 0xF4)
+          goto yy608;
+        goto yy600;
+      }
+    }
+  yy602:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy600;
+    if (yych <= 0xBF)
+      goto yy598;
+    goto yy600;
+  yy603:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy600;
+    if (yych <= 0xBF)
+      goto yy602;
+    goto yy600;
+  yy604:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy600;
+    if (yych <= 0xBF)
+      goto yy602;
+    goto yy600;
+  yy605:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy600;
+    if (yych <= 0x9F)
+      goto yy602;
+    goto yy600;
+  yy606:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy600;
+    if (yych <= 0xBF)
+      goto yy604;
+    goto yy600;
+  yy607:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy600;
+    if (yych <= 0xBF)
+      goto yy604;
+    goto yy600;
+  yy608:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy600;
+    if (yych <= 0x8F)
+      goto yy604;
+    goto yy600;
+  yy609:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy609;
+    }
+    if (yych <= 0xDF) {
+      if (yych <= '=') {
+        if (yych <= 0x00)
+          goto yy600;
+        if (yych == '\n')
+          goto yy600;
+        goto yy598;
+      } else {
+        if (yych <= '>')
+          goto yy611;
+        if (yych <= 0x7F)
+          goto yy598;
+        if (yych <= 0xC1)
+          goto yy600;
+        goto yy602;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy603;
+        if (yych == 0xED)
+          goto yy605;
+        goto yy604;
+      } else {
+        if (yych <= 0xF0)
+          goto yy606;
+        if (yych <= 0xF3)
+          goto yy607;
+        if (yych <= 0xF4)
+          goto yy608;
+        goto yy600;
+      }
+    }
+  yy611:
+    yyaccept = 1;
+    marker = ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy598;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy612;
+        if (yych <= '-')
+          goto yy601;
+      } else {
+        if (yych <= 0xDF)
+          goto yy602;
+        if (yych <= 0xE0)
+          goto yy603;
+        goto yy604;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy605;
+        if (yych <= 0xEF)
+          goto yy604;
+        goto yy606;
+      } else {
+        if (yych <= 0xF3)
+          goto yy607;
+        if (yych <= 0xF4)
+          goto yy608;
+      }
+    }
+  yy612 : { return (bufsize_t)(p - start); }
+  }
+}
+
+// Try to match an HTML block end line of type 3
+bufsize_t _scan_html_block_end_3(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,  64, 64, 64, 64, 64, 64, 64, 64, 64,  0,  64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,
+    };
+    yych = *p;
+    if (yych <= 0xDF) {
+      if (yych <= '>') {
+        if (yych <= 0x00)
+          goto yy615;
+        if (yych != '\n')
+          goto yy617;
+      } else {
+        if (yych <= '?')
+          goto yy618;
+        if (yych <= 0x7F)
+          goto yy617;
+        if (yych >= 0xC2)
+          goto yy619;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy620;
+        if (yych == 0xED)
+          goto yy622;
+        goto yy621;
+      } else {
+        if (yych <= 0xF0)
+          goto yy623;
+        if (yych <= 0xF3)
+          goto yy624;
+        if (yych <= 0xF4)
+          goto yy625;
+      }
+    }
+  yy615:
+    ++p;
+  yy616 : { return 0; }
+  yy617:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy616;
+      if (yych <= '\t')
+        goto yy627;
+      goto yy616;
+    } else {
+      if (yych <= 0x7F)
+        goto yy627;
+      if (yych <= 0xC1)
+        goto yy616;
+      if (yych <= 0xF4)
+        goto yy627;
+      goto yy616;
+    }
+  yy618:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '=') {
+      if (yych <= 0x00)
+        goto yy616;
+      if (yych == '\n')
+        goto yy616;
+      goto yy627;
+    } else {
+      if (yych <= 0x7F) {
+        if (yych <= '>')
+          goto yy638;
+        goto yy627;
+      } else {
+        if (yych <= 0xC1)
+          goto yy616;
+        if (yych <= 0xF4)
+          goto yy627;
+        goto yy616;
+      }
+    }
+  yy619:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy616;
+    if (yych <= 0xBF)
+      goto yy626;
+    goto yy616;
+  yy620:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x9F)
+      goto yy616;
+    if (yych <= 0xBF)
+      goto yy631;
+    goto yy616;
+  yy621:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy616;
+    if (yych <= 0xBF)
+      goto yy631;
+    goto yy616;
+  yy622:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy616;
+    if (yych <= 0x9F)
+      goto yy631;
+    goto yy616;
+  yy623:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x8F)
+      goto yy616;
+    if (yych <= 0xBF)
+      goto yy633;
+    goto yy616;
+  yy624:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy616;
+    if (yych <= 0xBF)
+      goto yy633;
+    goto yy616;
+  yy625:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy616;
+    if (yych <= 0x8F)
+      goto yy633;
+    goto yy616;
+  yy626:
+    ++p;
+    yych = *p;
+  yy627:
+    if (yybm[0 + yych] & 64) {
+      goto yy626;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy628;
+        if (yych <= '?')
+          goto yy629;
+      } else {
+        if (yych <= 0xDF)
+          goto yy631;
+        if (yych <= 0xE0)
+          goto yy632;
+        goto yy633;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy634;
+        if (yych <= 0xEF)
+          goto yy633;
+        goto yy635;
+      } else {
+        if (yych <= 0xF3)
+          goto yy636;
+        if (yych <= 0xF4)
+          goto yy637;
+      }
+    }
+  yy628:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy616;
+    } else {
+      goto yy639;
+    }
+  yy629:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy629;
+    }
+    if (yych <= 0xDF) {
+      if (yych <= '=') {
+        if (yych <= 0x00)
+          goto yy628;
+        if (yych == '\n')
+          goto yy628;
+        goto yy626;
+      } else {
+        if (yych <= '>')
+          goto yy638;
+        if (yych <= 0x7F)
+          goto yy626;
+        if (yych <= 0xC1)
+          goto yy628;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy632;
+        if (yych == 0xED)
+          goto yy634;
+        goto yy633;
+      } else {
+        if (yych <= 0xF0)
+          goto yy635;
+        if (yych <= 0xF3)
+          goto yy636;
+        if (yych <= 0xF4)
+          goto yy637;
+        goto yy628;
+      }
+    }
+  yy631:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy628;
+    if (yych <= 0xBF)
+      goto yy626;
+    goto yy628;
+  yy632:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy628;
+    if (yych <= 0xBF)
+      goto yy631;
+    goto yy628;
+  yy633:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy628;
+    if (yych <= 0xBF)
+      goto yy631;
+    goto yy628;
+  yy634:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy628;
+    if (yych <= 0x9F)
+      goto yy631;
+    goto yy628;
+  yy635:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy628;
+    if (yych <= 0xBF)
+      goto yy633;
+    goto yy628;
+  yy636:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy628;
+    if (yych <= 0xBF)
+      goto yy633;
+    goto yy628;
+  yy637:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy628;
+    if (yych <= 0x8F)
+      goto yy633;
+    goto yy628;
+  yy638:
+    yyaccept = 1;
+    marker = ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy626;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy639;
+        if (yych <= '?')
+          goto yy629;
+      } else {
+        if (yych <= 0xDF)
+          goto yy631;
+        if (yych <= 0xE0)
+          goto yy632;
+        goto yy633;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy634;
+        if (yych <= 0xEF)
+          goto yy633;
+        goto yy635;
+      } else {
+        if (yych <= 0xF3)
+          goto yy636;
+        if (yych <= 0xF4)
+          goto yy637;
+      }
+    }
+  yy639 : { 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, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   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] & 64) {
+      goto yy645;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '\n') {
+        if (yych <= 0x00)
+          goto yy642;
+        if (yych <= '\t')
+          goto yy644;
+      } else {
+        if (yych <= 0x7F)
+          goto yy644;
+        if (yych <= 0xC1)
+          goto yy642;
+        if (yych <= 0xDF)
+          goto yy648;
+        goto yy649;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy651;
+        goto yy650;
+      } else {
+        if (yych <= 0xF0)
+          goto yy652;
+        if (yych <= 0xF3)
+          goto yy653;
+        if (yych <= 0xF4)
+          goto yy654;
+      }
+    }
+  yy642:
+    ++p;
+  yy643 : { return 0; }
+  yy644:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy643;
+      if (yych <= '\t')
+        goto yy656;
+      goto yy643;
+    } else {
+      if (yych <= 0x7F)
+        goto yy656;
+      if (yych <= 0xC1)
+        goto yy643;
+      if (yych <= 0xF4)
+        goto yy656;
+      goto yy643;
+    }
+  yy645:
+    yyaccept = 1;
+    marker = ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy655;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy647;
+        if (yych <= '>')
+          goto yy645;
+      } else {
+        if (yych <= 0xDF)
+          goto yy658;
+        if (yych <= 0xE0)
+          goto yy659;
+        goto yy660;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy661;
+        if (yych <= 0xEF)
+          goto yy660;
+        goto yy662;
+      } else {
+        if (yych <= 0xF3)
+          goto yy663;
+        if (yych <= 0xF4)
+          goto yy664;
+      }
+    }
+  yy647 : { return (bufsize_t)(p - start); }
+  yy648:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy643;
+    if (yych <= 0xBF)
+      goto yy655;
+    goto yy643;
+  yy649:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x9F)
+      goto yy643;
+    if (yych <= 0xBF)
+      goto yy658;
+    goto yy643;
+  yy650:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy643;
+    if (yych <= 0xBF)
+      goto yy658;
+    goto yy643;
+  yy651:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy643;
+    if (yych <= 0x9F)
+      goto yy658;
+    goto yy643;
+  yy652:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x8F)
+      goto yy643;
+    if (yych <= 0xBF)
+      goto yy660;
+    goto yy643;
+  yy653:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy643;
+    if (yych <= 0xBF)
+      goto yy660;
+    goto yy643;
+  yy654:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy643;
+    if (yych <= 0x8F)
+      goto yy660;
+    goto yy643;
+  yy655:
+    ++p;
+    yych = *p;
+  yy656:
+    if (yybm[0 + yych] & 128) {
+      goto yy655;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy657;
+        if (yych <= '>')
+          goto yy645;
+      } else {
+        if (yych <= 0xDF)
+          goto yy658;
+        if (yych <= 0xE0)
+          goto yy659;
+        goto yy660;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy661;
+        if (yych <= 0xEF)
+          goto yy660;
+        goto yy662;
+      } else {
+        if (yych <= 0xF3)
+          goto yy663;
+        if (yych <= 0xF4)
+          goto yy664;
+      }
+    }
+  yy657:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy643;
+    } else {
+      goto yy647;
+    }
+  yy658:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy657;
+    if (yych <= 0xBF)
+      goto yy655;
+    goto yy657;
+  yy659:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy657;
+    if (yych <= 0xBF)
+      goto yy658;
+    goto yy657;
+  yy660:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy657;
+    if (yych <= 0xBF)
+      goto yy658;
+    goto yy657;
+  yy661:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy657;
+    if (yych <= 0x9F)
+      goto yy658;
+    goto yy657;
+  yy662:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy657;
+    if (yych <= 0xBF)
+      goto yy660;
+    goto yy657;
+  yy663:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy657;
+    if (yych <= 0xBF)
+      goto yy660;
+    goto yy657;
+  yy664:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy657;
+    if (yych <= 0x8F)
+      goto yy660;
+    goto yy657;
+  }
+}
+
+// Try to match an HTML block end line of type 5
+bufsize_t _scan_html_block_end_5(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,  64, 64, 64,  64, 64, 64, 64, 64, 64, 0,  64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,
+    };
+    yych = *p;
+    if (yych <= 0xDF) {
+      if (yych <= '\\') {
+        if (yych <= 0x00)
+          goto yy667;
+        if (yych != '\n')
+          goto yy669;
+      } else {
+        if (yych <= ']')
+          goto yy670;
+        if (yych <= 0x7F)
+          goto yy669;
+        if (yych >= 0xC2)
+          goto yy671;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy672;
+        if (yych == 0xED)
+          goto yy674;
+        goto yy673;
+      } else {
+        if (yych <= 0xF0)
+          goto yy675;
+        if (yych <= 0xF3)
+          goto yy676;
+        if (yych <= 0xF4)
+          goto yy677;
+      }
+    }
+  yy667:
+    ++p;
+  yy668 : { return 0; }
+  yy669:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy668;
+      if (yych <= '\t')
+        goto yy679;
+      goto yy668;
+    } else {
+      if (yych <= 0x7F)
+        goto yy679;
+      if (yych <= 0xC1)
+        goto yy668;
+      if (yych <= 0xF4)
+        goto yy679;
+      goto yy668;
+    }
+  yy670:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 128) {
+      goto yy689;
+    }
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy668;
+      if (yych <= '\t')
+        goto yy679;
+      goto yy668;
+    } else {
+      if (yych <= 0x7F)
+        goto yy679;
+      if (yych <= 0xC1)
+        goto yy668;
+      if (yych <= 0xF4)
+        goto yy679;
+      goto yy668;
+    }
+  yy671:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy668;
+    if (yych <= 0xBF)
+      goto yy678;
+    goto yy668;
+  yy672:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x9F)
+      goto yy668;
+    if (yych <= 0xBF)
+      goto yy682;
+    goto yy668;
+  yy673:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy668;
+    if (yych <= 0xBF)
+      goto yy682;
+    goto yy668;
+  yy674:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy668;
+    if (yych <= 0x9F)
+      goto yy682;
+    goto yy668;
+  yy675:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x8F)
+      goto yy668;
+    if (yych <= 0xBF)
+      goto yy684;
+    goto yy668;
+  yy676:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy668;
+    if (yych <= 0xBF)
+      goto yy684;
+    goto yy668;
+  yy677:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x7F)
+      goto yy668;
+    if (yych <= 0x8F)
+      goto yy684;
+    goto yy668;
+  yy678:
+    ++p;
+    yych = *p;
+  yy679:
+    if (yybm[0 + yych] & 64) {
+      goto yy678;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy680;
+        if (yych <= ']')
+          goto yy681;
+      } else {
+        if (yych <= 0xDF)
+          goto yy682;
+        if (yych <= 0xE0)
+          goto yy683;
+        goto yy684;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy685;
+        if (yych <= 0xEF)
+          goto yy684;
+        goto yy686;
+      } else {
+        if (yych <= 0xF3)
+          goto yy687;
+        if (yych <= 0xF4)
+          goto yy688;
+      }
+    }
+  yy680:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy668;
+    } else {
+      goto yy692;
+    }
+  yy681:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy678;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy680;
+        if (yych <= ']')
+          goto yy689;
+        goto yy680;
+      } else {
+        if (yych <= 0xDF)
+          goto yy682;
+        if (yych <= 0xE0)
+          goto yy683;
+        goto yy684;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy685;
+        if (yych <= 0xEF)
+          goto yy684;
+        goto yy686;
+      } else {
+        if (yych <= 0xF3)
+          goto yy687;
+        if (yych <= 0xF4)
+          goto yy688;
+        goto yy680;
+      }
+    }
+  yy682:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy680;
+    if (yych <= 0xBF)
+      goto yy678;
+    goto yy680;
+  yy683:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy680;
+    if (yych <= 0xBF)
+      goto yy682;
+    goto yy680;
+  yy684:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy680;
+    if (yych <= 0xBF)
+      goto yy682;
+    goto yy680;
+  yy685:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy680;
+    if (yych <= 0x9F)
+      goto yy682;
+    goto yy680;
+  yy686:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy680;
+    if (yych <= 0xBF)
+      goto yy684;
+    goto yy680;
+  yy687:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy680;
+    if (yych <= 0xBF)
+      goto yy684;
+    goto yy680;
+  yy688:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy680;
+    if (yych <= 0x8F)
+      goto yy684;
+    goto yy680;
+  yy689:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy689;
+    }
+    if (yych <= 0xDF) {
+      if (yych <= '=') {
+        if (yych <= 0x00)
+          goto yy680;
+        if (yych == '\n')
+          goto yy680;
+        goto yy678;
+      } else {
+        if (yych <= '>')
+          goto yy691;
+        if (yych <= 0x7F)
+          goto yy678;
+        if (yych <= 0xC1)
+          goto yy680;
+        goto yy682;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy683;
+        if (yych == 0xED)
+          goto yy685;
+        goto yy684;
+      } else {
+        if (yych <= 0xF0)
+          goto yy686;
+        if (yych <= 0xF3)
+          goto yy687;
+        if (yych <= 0xF4)
+          goto yy688;
+        goto yy680;
+      }
+    }
+  yy691:
+    yyaccept = 1;
+    marker = ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy678;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= '\n')
+          goto yy692;
+        if (yych <= ']')
+          goto yy681;
+      } else {
+        if (yych <= 0xDF)
+          goto yy682;
+        if (yych <= 0xE0)
+          goto yy683;
+        goto yy684;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy685;
+        if (yych <= 0xEF)
+          goto yy684;
+        goto yy686;
+      } else {
+        if (yych <= 0xF3)
+          goto yy687;
+        if (yych <= 0xF4)
+          goto yy688;
+      }
+    }
+  yy692 : { 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, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,
+    };
+    yych = *p;
+    if (yych <= '&') {
+      if (yych == '"')
+        goto yy697;
+    } else {
+      if (yych <= '\'')
+        goto yy698;
+      if (yych <= '(')
+        goto yy699;
+    }
+    ++p;
+  yy696 : { return 0; }
+  yy697:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy696;
+    if (yych <= 0x7F)
+      goto yy701;
+    if (yych <= 0xC1)
+      goto yy696;
+    if (yych <= 0xF4)
+      goto yy701;
+    goto yy696;
+  yy698:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy696;
+    if (yych <= 0x7F)
+      goto yy715;
+    if (yych <= 0xC1)
+      goto yy696;
+    if (yych <= 0xF4)
+      goto yy715;
+    goto yy696;
+  yy699:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '(') {
+      if (yych <= 0x00)
+        goto yy696;
+      if (yych <= '\'')
+        goto yy728;
+      goto yy696;
+    } else {
+      if (yych <= 0x7F)
+        goto yy728;
+      if (yych <= 0xC1)
+        goto yy696;
+      if (yych <= 0xF4)
+        goto yy728;
+      goto yy696;
+    }
+  yy700:
+    ++p;
+    yych = *p;
+  yy701:
+    if (yybm[0 + yych] & 16) {
+      goto yy700;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '\\') {
+        if (yych <= 0x00)
+          goto yy702;
+        if (yych <= '"')
+          goto yy703;
+        goto yy705;
+      } else {
+        if (yych <= 0xC1)
+          goto yy702;
+        if (yych <= 0xDF)
+          goto yy707;
+        goto yy708;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy710;
+        goto yy709;
+      } else {
+        if (yych <= 0xF0)
+          goto yy711;
+        if (yych <= 0xF3)
+          goto yy712;
+        if (yych <= 0xF4)
+          goto yy713;
+      }
+    }
+  yy702:
+    p = marker;
+    if (yyaccept <= 1) {
+      if (yyaccept == 0) {
+        goto yy696;
+      } else {
+        goto yy704;
+      }
+    } else {
+      if (yyaccept == 2) {
+        goto yy717;
+      } else {
+        goto yy730;
+      }
+    }
+  yy703:
+    ++p;
+  yy704 : { return (bufsize_t)(p - start); }
+  yy705:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 16) {
+      goto yy700;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '\\') {
+        if (yych <= 0x00)
+          goto yy702;
+        if (yych <= '"')
+          goto yy740;
+        goto yy705;
+      } else {
+        if (yych <= 0xC1)
+          goto yy702;
+        if (yych >= 0xE0)
+          goto yy708;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy710;
+        goto yy709;
+      } else {
+        if (yych <= 0xF0)
+          goto yy711;
+        if (yych <= 0xF3)
+          goto yy712;
+        if (yych <= 0xF4)
+          goto yy713;
+        goto yy702;
+      }
+    }
+  yy707:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy700;
+    goto yy702;
+  yy708:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy707;
+    goto yy702;
+  yy709:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy707;
+    goto yy702;
+  yy710:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0x9F)
+      goto yy707;
+    goto yy702;
+  yy711:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy709;
+    goto yy702;
+  yy712:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy709;
+    goto yy702;
+  yy713:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0x8F)
+      goto yy709;
+    goto yy702;
+  yy714:
+    ++p;
+    yych = *p;
+  yy715:
+    if (yybm[0 + yych] & 64) {
+      goto yy714;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '\\') {
+        if (yych <= 0x00)
+          goto yy702;
+        if (yych >= '(')
+          goto yy718;
+      } else {
+        if (yych <= 0xC1)
+          goto yy702;
+        if (yych <= 0xDF)
+          goto yy720;
+        goto yy721;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy723;
+        goto yy722;
+      } else {
+        if (yych <= 0xF0)
+          goto yy724;
+        if (yych <= 0xF3)
+          goto yy725;
+        if (yych <= 0xF4)
+          goto yy726;
+        goto yy702;
+      }
+    }
+  yy716:
+    ++p;
+  yy717 : { return (bufsize_t)(p - start); }
+  yy718:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy714;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '\\') {
+        if (yych <= 0x00)
+          goto yy702;
+        if (yych <= '\'')
+          goto yy741;
+        goto yy718;
+      } else {
+        if (yych <= 0xC1)
+          goto yy702;
+        if (yych >= 0xE0)
+          goto yy721;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy723;
+        goto yy722;
+      } else {
+        if (yych <= 0xF0)
+          goto yy724;
+        if (yych <= 0xF3)
+          goto yy725;
+        if (yych <= 0xF4)
+          goto yy726;
+        goto yy702;
+      }
+    }
+  yy720:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy714;
+    goto yy702;
+  yy721:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy720;
+    goto yy702;
+  yy722:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy720;
+    goto yy702;
+  yy723:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0x9F)
+      goto yy720;
+    goto yy702;
+  yy724:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy722;
+    goto yy702;
+  yy725:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy722;
+    goto yy702;
+  yy726:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0x8F)
+      goto yy722;
+    goto yy702;
+  yy727:
+    ++p;
+    yych = *p;
+  yy728:
+    if (yybm[0 + yych] & 128) {
+      goto yy727;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '\\') {
+        if (yych <= '(')
+          goto yy702;
+        if (yych >= '*')
+          goto yy731;
+      } else {
+        if (yych <= 0xC1)
+          goto yy702;
+        if (yych <= 0xDF)
+          goto yy733;
+        goto yy734;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy736;
+        goto yy735;
+      } else {
+        if (yych <= 0xF0)
+          goto yy737;
+        if (yych <= 0xF3)
+          goto yy738;
+        if (yych <= 0xF4)
+          goto yy739;
+        goto yy702;
+      }
+    }
+  yy729:
+    ++p;
+  yy730 : { return (bufsize_t)(p - start); }
+  yy731:
+    ++p;
+    yych = *p;
+    if (yych <= 0xDF) {
+      if (yych <= '[') {
+        if (yych <= 0x00)
+          goto yy702;
+        if (yych == ')')
+          goto yy742;
+        goto yy727;
+      } else {
+        if (yych <= '\\')
+          goto yy731;
+        if (yych <= 0x7F)
+          goto yy727;
+        if (yych <= 0xC1)
+          goto yy702;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy734;
+        if (yych == 0xED)
+          goto yy736;
+        goto yy735;
+      } else {
+        if (yych <= 0xF0)
+          goto yy737;
+        if (yych <= 0xF3)
+          goto yy738;
+        if (yych <= 0xF4)
+          goto yy739;
+        goto yy702;
+      }
+    }
+  yy733:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy727;
+    goto yy702;
+  yy734:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy733;
+    goto yy702;
+  yy735:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy733;
+    goto yy702;
+  yy736:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0x9F)
+      goto yy733;
+    goto yy702;
+  yy737:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy735;
+    goto yy702;
+  yy738:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0xBF)
+      goto yy735;
+    goto yy702;
+  yy739:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy702;
+    if (yych <= 0x8F)
+      goto yy735;
+    goto yy702;
+  yy740:
+    yyaccept = 1;
+    marker = ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 16) {
+      goto yy700;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '\\') {
+        if (yych <= 0x00)
+          goto yy704;
+        if (yych <= '"')
+          goto yy703;
+        goto yy705;
+      } else {
+        if (yych <= 0xC1)
+          goto yy704;
+        if (yych <= 0xDF)
+          goto yy707;
+        goto yy708;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy710;
+        goto yy709;
+      } else {
+        if (yych <= 0xF0)
+          goto yy711;
+        if (yych <= 0xF3)
+          goto yy712;
+        if (yych <= 0xF4)
+          goto yy713;
+        goto yy704;
+      }
+    }
+  yy741:
+    yyaccept = 2;
+    marker = ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy714;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '\\') {
+        if (yych <= 0x00)
+          goto yy717;
+        if (yych <= '\'')
+          goto yy716;
+        goto yy718;
+      } else {
+        if (yych <= 0xC1)
+          goto yy717;
+        if (yych <= 0xDF)
+          goto yy720;
+        goto yy721;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy723;
+        goto yy722;
+      } else {
+        if (yych <= 0xF0)
+          goto yy724;
+        if (yych <= 0xF3)
+          goto yy725;
+        if (yych <= 0xF4)
+          goto yy726;
+        goto yy717;
+      }
+    }
+  yy742:
+    yyaccept = 3;
+    marker = ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy727;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '\\') {
+        if (yych <= '(')
+          goto yy730;
+        if (yych <= ')')
+          goto yy729;
+        goto yy731;
+      } else {
+        if (yych <= 0xC1)
+          goto yy730;
+        if (yych <= 0xDF)
+          goto yy733;
+        goto yy734;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy736;
+        goto yy735;
+      } else {
+        if (yych <= 0xF0)
+          goto yy737;
+        if (yych <= 0xF3)
+          goto yy738;
+        if (yych <= 0xF4)
+          goto yy739;
+        goto yy730;
+      }
+    }
+  }
+}
+
+// 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 yy747;
+    }
+    ++p;
+    { return 0; }
+  yy747:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy747;
+    }
+    { 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 yy754;
+    ++p;
+  yy753 : { return 0; }
+  yy754:
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 128) {
+      goto yy755;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy753;
+      if (yych <= '\n')
+        goto yy758;
+      goto yy753;
+    } else {
+      if (yych <= '\r')
+        goto yy758;
+      if (yych == '#')
+        goto yy759;
+      goto yy753;
+    }
+  yy755:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy755;
+    }
+  yy757 : { return (bufsize_t)(p - start); }
+  yy758:
+    yych = *++p;
+    goto yy757;
+  yy759:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy755;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy760;
+      if (yych <= '\n')
+        goto yy758;
+    } else {
+      if (yych <= '\r')
+        goto yy758;
+      if (yych == '#')
+        goto yy761;
+    }
+  yy760:
+    p = marker;
+    goto yy753;
+  yy761:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy755;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy760;
+      if (yych <= '\n')
+        goto yy758;
+      goto yy760;
+    } else {
+      if (yych <= '\r')
+        goto yy758;
+      if (yych != '#')
+        goto yy760;
+    }
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy755;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy760;
+      if (yych <= '\n')
+        goto yy758;
+      goto yy760;
+    } else {
+      if (yych <= '\r')
+        goto yy758;
+      if (yych != '#')
+        goto yy760;
+    }
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy755;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy760;
+      if (yych <= '\n')
+        goto yy758;
+      goto yy760;
+    } else {
+      if (yych <= '\r')
+        goto yy758;
+      if (yych != '#')
+        goto yy760;
+    }
+    ++p;
+    if (yybm[0 + (yych = *p)] & 128) {
+      goto yy755;
+    }
+    if (yych <= 0x08)
+      goto yy760;
+    if (yych <= '\n')
+      goto yy758;
+    if (yych == '\r')
+      goto yy758;
+    goto yy760;
+  }
+}
+
+// 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 yy769;
+    if (yych == '=')
+      goto yy770;
+    ++p;
+  yy768 : { return 0; }
+  yy769:
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 64) {
+      goto yy776;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy768;
+      if (yych <= '\n')
+        goto yy772;
+      goto yy768;
+    } else {
+      if (yych <= '\r')
+        goto yy772;
+      if (yych == ' ')
+        goto yy772;
+      goto yy768;
+    }
+  yy770:
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 128) {
+      goto yy782;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy768;
+      if (yych <= '\n')
+        goto yy779;
+      goto yy768;
+    } else {
+      if (yych <= '\r')
+        goto yy779;
+      if (yych == ' ')
+        goto yy779;
+      goto yy768;
+    }
+  yy771:
+    ++p;
+    yych = *p;
+  yy772:
+    if (yybm[0 + yych] & 32) {
+      goto yy771;
+    }
+    if (yych <= 0x08)
+      goto yy773;
+    if (yych <= '\n')
+      goto yy774;
+    if (yych == '\r')
+      goto yy774;
+  yy773:
+    p = marker;
+    goto yy768;
+  yy774:
+    ++p;
+    { return 2; }
+  yy776:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 32) {
+      goto yy771;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy773;
+      if (yych <= '\n')
+        goto yy774;
+      goto yy773;
+    } else {
+      if (yych <= '\r')
+        goto yy774;
+      if (yych == '-')
+        goto yy776;
+      goto yy773;
+    }
+  yy778:
+    ++p;
+    yych = *p;
+  yy779:
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy773;
+      if (yych <= '\t')
+        goto yy778;
+      if (yych >= '\v')
+        goto yy773;
+    } else {
+      if (yych <= '\r')
+        goto yy780;
+      if (yych == ' ')
+        goto yy778;
+      goto yy773;
+    }
+  yy780:
+    ++p;
+    { return 1; }
+  yy782:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy782;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy773;
+      if (yych <= '\t')
+        goto yy778;
+      if (yych <= '\n')
+        goto yy780;
+      goto yy773;
+    } else {
+      if (yych <= '\r')
+        goto yy780;
+      if (yych == ' ')
+        goto yy778;
+      goto yy773;
+    }
+  }
+}
+
+// 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, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   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 yy788;
+    if (yych == '~')
+      goto yy789;
+    ++p;
+  yy787 : { return 0; }
+  yy788:
+    yych = *(marker = ++p);
+    if (yych == '`')
+      goto yy790;
+    goto yy787;
+  yy789:
+    yych = *(marker = ++p);
+    if (yych == '~')
+      goto yy792;
+    goto yy787;
+  yy790:
+    yych = *++p;
+    if (yybm[0 + yych] & 16) {
+      goto yy793;
+    }
+  yy791:
+    p = marker;
+    goto yy787;
+  yy792:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy795;
+    }
+    goto yy791;
+  yy793:
+    ++p;
+    yych = *p;
+    marker = p;
+    if (yybm[0 + yych] & 64) {
+      goto yy797;
+    }
+    if (yych <= 0xE0) {
+      if (yych <= '`') {
+        if (yych <= 0x00)
+          goto yy791;
+        if (yych <= '\r')
+          goto yy799;
+        goto yy793;
+      } else {
+        if (yych <= 0xC1)
+          goto yy791;
+        if (yych <= 0xDF)
+          goto yy801;
+        goto yy802;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych == 0xED)
+          goto yy804;
+        goto yy803;
+      } else {
+        if (yych <= 0xF0)
+          goto yy805;
+        if (yych <= 0xF3)
+          goto yy806;
+        if (yych <= 0xF4)
+          goto yy807;
+        goto yy791;
+      }
+    }
+  yy795:
+    ++p;
+    yych = *p;
+    marker = p;
+    if (yybm[0 + yych] & 32) {
+      goto yy795;
+    }
+    if (yych <= 0xDF) {
+      if (yych <= '\f') {
+        if (yych <= 0x00)
+          goto yy791;
+        if (yych == '\n')
+          goto yy810;
+        goto yy808;
+      } else {
+        if (yych <= '\r')
+          goto yy810;
+        if (yych <= 0x7F)
+          goto yy808;
+        if (yych <= 0xC1)
+          goto yy791;
+        goto yy812;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0)
+          goto yy813;
+        if (yych == 0xED)
+          goto yy815;
+        goto yy814;
+      } else {
+        if (yych <= 0xF0)
+          goto yy816;
+        if (yych <= 0xF3)
+          goto yy817;
+        if (yych <= 0xF4)
+          goto yy818;
+        goto yy791;
+      }
+    }
+  yy797:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy797;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy791;
+        if (yych >= 0x0E)
+          goto yy791;
+      } else {
+        if (yych <= 0xDF)
+          goto yy801;
+        if (yych <= 0xE0)
+          goto yy802;
+        goto yy803;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy804;
+        if (yych <= 0xEF)
+          goto yy803;
+        goto yy805;
+      } else {
+        if (yych <= 0xF3)
+          goto yy806;
+        if (yych <= 0xF4)
+          goto yy807;
+        goto yy791;
+      }
+    }
+  yy799:
+    ++p;
+    p = marker;
+    { return (bufsize_t)(p - start); }
+  yy801:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy791;
+    if (yych <= 0xBF)
+      goto yy797;
+    goto yy791;
+  yy802:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy791;
+    if (yych <= 0xBF)
+      goto yy801;
+    goto yy791;
+  yy803:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy791;
+    if (yych <= 0xBF)
+      goto yy801;
+    goto yy791;
+  yy804:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy791;
+    if (yych <= 0x9F)
+      goto yy801;
+    goto yy791;
+  yy805:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy791;
+    if (yych <= 0xBF)
+      goto yy803;
+    goto yy791;
+  yy806:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy791;
+    if (yych <= 0xBF)
+      goto yy803;
+    goto yy791;
+  yy807:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy791;
+    if (yych <= 0x8F)
+      goto yy803;
+    goto yy791;
+  yy808:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy808;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy791;
+        if (yych >= 0x0E)
+          goto yy791;
+      } else {
+        if (yych <= 0xDF)
+          goto yy812;
+        if (yych <= 0xE0)
+          goto yy813;
+        goto yy814;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy815;
+        if (yych <= 0xEF)
+          goto yy814;
+        goto yy816;
+      } else {
+        if (yych <= 0xF3)
+          goto yy817;
+        if (yych <= 0xF4)
+          goto yy818;
+        goto yy791;
+      }
+    }
+  yy810:
+    ++p;
+    p = marker;
+    { return (bufsize_t)(p - start); }
+  yy812:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy791;
+    if (yych <= 0xBF)
+      goto yy808;
+    goto yy791;
+  yy813:
+    ++p;
+    yych = *p;
+    if (yych <= 0x9F)
+      goto yy791;
+    if (yych <= 0xBF)
+      goto yy812;
+    goto yy791;
+  yy814:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy791;
+    if (yych <= 0xBF)
+      goto yy812;
+    goto yy791;
+  yy815:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy791;
+    if (yych <= 0x9F)
+      goto yy812;
+    goto yy791;
+  yy816:
+    ++p;
+    yych = *p;
+    if (yych <= 0x8F)
+      goto yy791;
+    if (yych <= 0xBF)
+      goto yy814;
+    goto yy791;
+  yy817:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy791;
+    if (yych <= 0xBF)
+      goto yy814;
+    goto yy791;
+  yy818:
+    ++p;
+    yych = *p;
+    if (yych <= 0x7F)
+      goto yy791;
+    if (yych <= 0x8F)
+      goto yy814;
+    goto yy791;
+  }
+}
+
+// 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 yy823;
+    if (yych == '~')
+      goto yy824;
+    ++p;
+  yy822 : { return 0; }
+  yy823:
+    yych = *(marker = ++p);
+    if (yych == '`')
+      goto yy825;
+    goto yy822;
+  yy824:
+    yych = *(marker = ++p);
+    if (yych == '~')
+      goto yy827;
+    goto yy822;
+  yy825:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy828;
+    }
+  yy826:
+    p = marker;
+    goto yy822;
+  yy827:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy830;
+    }
+    goto yy826;
+  yy828:
+    ++p;
+    yych = *p;
+    marker = p;
+    if (yybm[0 + yych] & 128) {
+      goto yy832;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy826;
+      if (yych <= '\n')
+        goto yy834;
+      goto yy826;
+    } else {
+      if (yych <= '\r')
+        goto yy834;
+      if (yych == '`')
+        goto yy828;
+      goto yy826;
+    }
+  yy830:
+    ++p;
+    yych = *p;
+    marker = p;
+    if (yybm[0 + yych] & 64) {
+      goto yy830;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy826;
+      if (yych <= '\t')
+        goto yy836;
+      if (yych <= '\n')
+        goto yy838;
+      goto yy826;
+    } else {
+      if (yych <= '\r')
+        goto yy838;
+      if (yych == ' ')
+        goto yy836;
+      goto yy826;
+    }
+  yy832:
+    ++p;
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy832;
+    }
+    if (yych <= 0x08)
+      goto yy826;
+    if (yych <= '\n')
+      goto yy834;
+    if (yych != '\r')
+      goto yy826;
+  yy834:
+    ++p;
+    p = marker;
+    { return (bufsize_t)(p - start); }
+  yy836:
+    ++p;
+    yych = *p;
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy826;
+      if (yych <= '\t')
+        goto yy836;
+      if (yych >= '\v')
+        goto yy826;
+    } else {
+      if (yych <= '\r')
+        goto yy838;
+      if (yych == ' ')
+        goto yy836;
+      goto yy826;
+    }
+  yy838:
+    ++p;
+    p = marker;
+    { return (bufsize_t)(p - start); }
+  }
+}
+
+// Scans an entity.
+// Returns number of chars matched.
+bufsize_t _scan_entity(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    yych = *p;
+    if (yych == '&')
+      goto yy844;
+    ++p;
+  yy843 : { return 0; }
+  yy844:
+    yych = *(marker = ++p);
+    if (yych <= '@') {
+      if (yych != '#')
+        goto yy843;
+    } else {
+      if (yych <= 'Z')
+        goto yy847;
+      if (yych <= '`')
+        goto yy843;
+      if (yych <= 'z')
+        goto yy847;
+      goto yy843;
+    }
+    yych = *++p;
+    if (yych <= 'W') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy848;
+    } else {
+      if (yych <= 'X')
+        goto yy849;
+      if (yych == 'x')
+        goto yy849;
+    }
+  yy846:
+    p = marker;
+    goto yy843;
+  yy847:
+    yych = *++p;
+    if (yych <= '@') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy850;
+      goto yy846;
+    } else {
+      if (yych <= 'Z')
+        goto yy850;
+      if (yych <= '`')
+        goto yy846;
+      if (yych <= 'z')
+        goto yy850;
+      goto yy846;
+    }
+  yy848:
+    yych = *++p;
+    if (yych <= '/')
+      goto yy846;
+    if (yych <= '9')
+      goto yy851;
+    if (yych == ';')
+      goto yy852;
+    goto yy846;
+  yy849:
+    yych = *++p;
+    if (yych <= '@') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy854;
+      goto yy846;
+    } else {
+      if (yych <= 'F')
+        goto yy854;
+      if (yych <= '`')
+        goto yy846;
+      if (yych <= 'f')
+        goto yy854;
+      goto yy846;
+    }
+  yy850:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy855;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy855;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'z')
+          goto yy855;
+        goto yy846;
+      }
+    }
+  yy851:
+    yych = *++p;
+    if (yych <= '/')
+      goto yy846;
+    if (yych <= '9')
+      goto yy856;
+    if (yych != ';')
+      goto yy846;
+  yy852:
+    ++p;
+    { return (bufsize_t)(p - start); }
+  yy854:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy857;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'F') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy857;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'f')
+          goto yy857;
+        goto yy846;
+      }
+    }
+  yy855:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy858;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy858;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'z')
+          goto yy858;
+        goto yy846;
+      }
+    }
+  yy856:
+    yych = *++p;
+    if (yych <= '/')
+      goto yy846;
+    if (yych <= '9')
+      goto yy859;
+    if (yych == ';')
+      goto yy852;
+    goto yy846;
+  yy857:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy860;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'F') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy860;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'f')
+          goto yy860;
+        goto yy846;
+      }
+    }
+  yy858:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy861;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy861;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'z')
+          goto yy861;
+        goto yy846;
+      }
+    }
+  yy859:
+    yych = *++p;
+    if (yych <= '/')
+      goto yy846;
+    if (yych <= '9')
+      goto yy862;
+    if (yych == ';')
+      goto yy852;
+    goto yy846;
+  yy860:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy863;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'F') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy863;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'f')
+          goto yy863;
+        goto yy846;
+      }
+    }
+  yy861:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy864;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy864;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'z')
+          goto yy864;
+        goto yy846;
+      }
+    }
+  yy862:
+    yych = *++p;
+    if (yych <= '/')
+      goto yy846;
+    if (yych <= '9')
+      goto yy865;
+    if (yych == ';')
+      goto yy852;
+    goto yy846;
+  yy863:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy866;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'F') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy866;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'f')
+          goto yy866;
+        goto yy846;
+      }
+    }
+  yy864:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy867;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy867;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'z')
+          goto yy867;
+        goto yy846;
+      }
+    }
+  yy865:
+    yych = *++p;
+    if (yych <= '/')
+      goto yy846;
+    if (yych <= '9')
+      goto yy868;
+    if (yych == ';')
+      goto yy852;
+    goto yy846;
+  yy866:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy868;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'F') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy868;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'f')
+          goto yy868;
+        goto yy846;
+      }
+    }
+  yy867:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy869;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy869;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'z')
+          goto yy869;
+        goto yy846;
+      }
+    }
+  yy868:
+    yych = *++p;
+    if (yych == ';')
+      goto yy852;
+    goto yy846;
+  yy869:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy870;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy870:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy871;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy871:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy872;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy872:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy873;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy873:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy874;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy874:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy875;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy875:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy876;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy876:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy877;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy877:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy878;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy878:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy879;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy879:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy880;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy880:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy881;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy881:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy882;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy882:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy883;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy883:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy884;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy884:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy885;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy885:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy886;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy886:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy887;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy887:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy888;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy888:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy889;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy889:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy890;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy890:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy891;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy891:
+    yych = *++p;
+    if (yych <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy892;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych >= '{')
+          goto yy846;
+      }
+    }
+  yy892:
+    ++p;
+    if ((yych = *p) <= ';') {
+      if (yych <= '/')
+        goto yy846;
+      if (yych <= '9')
+        goto yy868;
+      if (yych <= ':')
+        goto yy846;
+      goto yy852;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy846;
+        goto yy868;
+      } else {
+        if (yych <= '`')
+          goto yy846;
+        if (yych <= 'z')
+          goto yy868;
+        goto yy846;
+      }
+    }
+  }
+}
+
+// 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 yy897;
+        if (yych >= 'F')
+          goto yy898;
+      } else {
+        if (yych == 'J')
+          goto yy899;
+        if (yych >= 'V')
+          goto yy900;
+      }
+    } else {
+      if (yych <= 'f') {
+        if (yych == 'd')
+          goto yy897;
+        if (yych >= 'f')
+          goto yy898;
+      } else {
+        if (yych <= 'j') {
+          if (yych >= 'j')
+            goto yy899;
+        } else {
+          if (yych == 'v')
+            goto yy900;
+        }
+      }
+    }
+    ++p;
+  yy896 : { return 0; }
+  yy897:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych == 'A')
+      goto yy901;
+    if (yych == 'a')
+      goto yy901;
+    goto yy896;
+  yy898:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych == 'I')
+      goto yy903;
+    if (yych == 'i')
+      goto yy903;
+    goto yy896;
+  yy899:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych == 'A')
+      goto yy904;
+    if (yych == 'a')
+      goto yy904;
+    goto yy896;
+  yy900:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych == 'B')
+      goto yy905;
+    if (yych == 'b')
+      goto yy905;
+    goto yy896;
+  yy901:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy906;
+    if (yych == 't')
+      goto yy906;
+  yy902:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy896;
+    } else {
+      goto yy914;
+    }
+  yy903:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy907;
+    if (yych == 'l')
+      goto yy907;
+    goto yy902;
+  yy904:
+    yych = *++p;
+    if (yych == 'V')
+      goto yy908;
+    if (yych == 'v')
+      goto yy908;
+    goto yy902;
+  yy905:
+    yych = *++p;
+    if (yych == 'S')
+      goto yy909;
+    if (yych == 's')
+      goto yy909;
+    goto yy902;
+  yy906:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy910;
+    if (yych == 'a')
+      goto yy910;
+    goto yy902;
+  yy907:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy911;
+    if (yych == 'e')
+      goto yy911;
+    goto yy902;
+  yy908:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy905;
+    if (yych == 'a')
+      goto yy905;
+    goto yy902;
+  yy909:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy912;
+    if (yych == 'c')
+      goto yy912;
+    goto yy902;
+  yy910:
+    yych = *++p;
+    if (yych == ':')
+      goto yy913;
+    goto yy902;
+  yy911:
+    yych = *++p;
+    if (yych == ':')
+      goto yy915;
+    goto yy902;
+  yy912:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy916;
+    if (yych == 'r')
+      goto yy916;
+    goto yy902;
+  yy913:
+    yyaccept = 1;
+    yych = *(marker = ++p);
+    if (yych == 'I')
+      goto yy917;
+    if (yych == 'i')
+      goto yy917;
+  yy914 : { return (bufsize_t)(p - start); }
+  yy915:
+    yych = *++p;
+    goto yy914;
+  yy916:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy918;
+    if (yych == 'i')
+      goto yy918;
+    goto yy902;
+  yy917:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy919;
+    if (yych == 'm')
+      goto yy919;
+    goto yy902;
+  yy918:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy920;
+    if (yych == 'p')
+      goto yy920;
+    goto yy902;
+  yy919:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy921;
+    if (yych == 'a')
+      goto yy921;
+    goto yy902;
+  yy920:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy911;
+    if (yych == 't')
+      goto yy911;
+    goto yy902;
+  yy921:
+    yych = *++p;
+    if (yych == 'G')
+      goto yy922;
+    if (yych != 'g')
+      goto yy902;
+  yy922:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy923;
+    if (yych != 'e')
+      goto yy902;
+  yy923:
+    yych = *++p;
+    if (yych != '/')
+      goto yy902;
+    yych = *++p;
+    if (yych <= 'W') {
+      if (yych <= 'J') {
+        if (yych == 'G')
+          goto yy925;
+        if (yych <= 'I')
+          goto yy902;
+        goto yy926;
+      } else {
+        if (yych == 'P')
+          goto yy927;
+        if (yych <= 'V')
+          goto yy902;
+        goto yy928;
+      }
+    } else {
+      if (yych <= 'j') {
+        if (yych == 'g')
+          goto yy925;
+        if (yych <= 'i')
+          goto yy902;
+        goto yy926;
+      } else {
+        if (yych <= 'p') {
+          if (yych <= 'o')
+            goto yy902;
+          goto yy927;
+        } else {
+          if (yych == 'w')
+            goto yy928;
+          goto yy902;
+        }
+      }
+    }
+  yy925:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy929;
+    if (yych == 'i')
+      goto yy929;
+    goto yy902;
+  yy926:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy930;
+    if (yych == 'p')
+      goto yy930;
+    goto yy902;
+  yy927:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy931;
+    if (yych == 'n')
+      goto yy931;
+    goto yy902;
+  yy928:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy932;
+    if (yych == 'e')
+      goto yy932;
+    goto yy902;
+  yy929:
+    yych = *++p;
+    if (yych == 'F')
+      goto yy933;
+    if (yych == 'f')
+      goto yy933;
+    goto yy902;
+  yy930:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy931;
+    if (yych != 'e')
+      goto yy902;
+  yy931:
+    yych = *++p;
+    if (yych == 'G')
+      goto yy933;
+    if (yych == 'g')
+      goto yy933;
+    goto yy902;
+  yy932:
+    yych = *++p;
+    if (yych == 'B')
+      goto yy935;
+    if (yych == 'b')
+      goto yy935;
+    goto yy902;
+  yy933:
+    ++p;
+    { return 0; }
+  yy935:
+    ++p;
+    if ((yych = *p) == 'P')
+      goto yy933;
+    if (yych == 'p')
+      goto yy933;
+    goto yy902;
+  }
+}
diff --git a/lib/cmark/src/scanners.h b/lib/cmark/src/scanners.h
new file mode 100644
index 0000000..bcb5fe8
--- /dev/null
+++ b/lib/cmark/src/scanners.h
@@ -0,0 +1,53 @@
+#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_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_entity(const unsigned char *p);
+bufsize_t _scan_dangerous_url(const unsigned char *p);
+
+#define scan_scheme(c, n) _scan_at(&_scan_scheme, c, n)
+#define scan_autolink_uri(c, n) _scan_at(&_scan_autolink_uri, c, n)
+#define scan_autolink_email(c, n) _scan_at(&_scan_autolink_email, c, n)
+#define scan_html_tag(c, n) _scan_at(&_scan_html_tag, c, n)
+#define scan_html_block_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_entity(c, n) _scan_at(&_scan_entity, c, n)
+#define scan_dangerous_url(c, n) _scan_at(&_scan_dangerous_url, c, n)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/cmark/src/scanners.re b/lib/cmark/src/scanners.re
new file mode 100644
index 0000000..447147b
--- /dev/null
+++ b/lib/cmark/src/scanners.re
@@ -0,0 +1,305 @@
+#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;
+
+  wordchar = [^\x00-\x20];
+
+  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'|'source'|'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-])* "-->");
+
+  processinginstruction = "?" ([^?>\x00]+ | [?][^>\x00] | [>])* "?>";
+
+  declaration = "!" [A-Z]+ spacechar+ [^>\x00]* ">";
+
+  cdata = "![CDATA[" ([^\]\x00]+ | "]" [^\]\x00] | "]]" [^>\x00])* "]]>";
+
+  htmltag = opentag | closetag | htmlcomment | processinginstruction |
+            declaration | cdata;
+
+  in_parens_nosp   = [(] (reg_char|escaped_char|[\\])* [)];
+
+  in_double_quotes = ["] (escaped_char|[^"\x00])* ["];
+  in_single_quotes = ['] (escaped_char|[^'\x00])* ['];
+  in_parens        = [(] (escaped_char|[^)\x00])* [)];
+
+  scheme           = [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; }
+*/
+}
+
+// Try to match an HTML block tag start line, returning
+// an integer code for the type of block (1-6, matching the spec).
+// #7 is handled by a separate function, below.
+bufsize_t _scan_html_block_start(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+/*!re2c
+  [<] ('script'|'pre'|'style') (spacechar | [>]) { return 1; }
+  '<!--' { return 2; }
+  '<?' { return 3; }
+  '<!' [A-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'|'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; }
+*/
+}
+
+// Scans an entity.
+// Returns number of chars matched.
+bufsize_t _scan_entity(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [&] ([#] ([Xx][A-Fa-f0-9]{1,6}|[0-9]{1,7}) |[A-Za-z][A-Za-z0-9]{1,31} ) [;]
+     { 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/lib/cmark/src/utf8.c b/lib/cmark/src/utf8.c
new file mode 100644
index 0000000..c29bbf7
--- /dev/null
+++ b/lib/cmark/src/utf8.c
@@ -0,0 +1,317 @@
+#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 == 0xFFFF) {
+    dst[0] = 0xFF;
+    len = 1;
+  } else if (uc == 0xFFFE) {
+    dst[0] = 0xFE;
+    len = 1;
+  } else if (uc < 0x10000) {
+    dst[0] = (uint8_t)(0xE0 + (uc >> 12));
+    dst[1] = 0x80 + ((uc >> 6) & 0x3F);
+    dst[2] = 0x80 + (uc & 0x3F);
+    len = 3;
+  } else if (uc < 0x110000) {
+    dst[0] = (uint8_t)(0xF0 + (uc >> 18));
+    dst[1] = 0x80 + ((uc >> 12) & 0x3F);
+    dst[2] = 0x80 + ((uc >> 6) & 0x3F);
+    dst[3] = 0x80 + (uc & 0x3F);
+    len = 4;
+  } else {
+    encode_unknown(buf);
+    return;
+  }
+
+  cmark_strbuf_put(buf, dst, len);
+}
+
+void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str,
+                              bufsize_t len) {
+  int32_t c;
+
+#define bufpush(x) cmark_utf8proc_encode_char(x, dest)
+
+  while (len > 0) {
+    bufsize_t char_len = cmark_utf8proc_iterate(str, len, &c);
+
+    if (char_len >= 0) {
+#include "case_fold_switch.inc"
+    } else {
+      encode_unknown(dest);
+      char_len = -char_len;
+    }
+
+    str += char_len;
+    len -= char_len;
+  }
+}
+
+// matches anything in the Zs class, plus LF, CR, TAB, FF.
+int cmark_utf8proc_is_space(int32_t uc) {
+  return (uc == 9 || uc == 10 || uc == 12 || uc == 13 || uc == 32 ||
+          uc == 160 || uc == 5760 || (uc >= 8192 && uc <= 8202) || uc == 8239 ||
+          uc == 8287 || uc == 12288);
+}
+
+// matches anything in the P[cdefios] classes.
+int cmark_utf8proc_is_punctuation(int32_t uc) {
+  return (
+      (uc < 128 && cmark_ispunct((char)uc)) || uc == 161 || uc == 167 ||
+      uc == 171 || uc == 182 || uc == 183 || uc == 187 || uc == 191 ||
+      uc == 894 || uc == 903 || (uc >= 1370 && uc <= 1375) || uc == 1417 ||
+      uc == 1418 || uc == 1470 || uc == 1472 || uc == 1475 || uc == 1478 ||
+      uc == 1523 || uc == 1524 || uc == 1545 || uc == 1546 || uc == 1548 ||
+      uc == 1549 || uc == 1563 || uc == 1566 || uc == 1567 ||
+      (uc >= 1642 && uc <= 1645) || uc == 1748 || (uc >= 1792 && uc <= 1805) ||
+      (uc >= 2039 && uc <= 2041) || (uc >= 2096 && uc <= 2110) || uc == 2142 ||
+      uc == 2404 || uc == 2405 || uc == 2416 || uc == 2800 || uc == 3572 ||
+      uc == 3663 || uc == 3674 || uc == 3675 || (uc >= 3844 && uc <= 3858) ||
+      uc == 3860 || (uc >= 3898 && uc <= 3901) || uc == 3973 ||
+      (uc >= 4048 && uc <= 4052) || uc == 4057 || uc == 4058 ||
+      (uc >= 4170 && uc <= 4175) || uc == 4347 || (uc >= 4960 && uc <= 4968) ||
+      uc == 5120 || uc == 5741 || uc == 5742 || uc == 5787 || uc == 5788 ||
+      (uc >= 5867 && uc <= 5869) || uc == 5941 || uc == 5942 ||
+      (uc >= 6100 && uc <= 6102) || (uc >= 6104 && uc <= 6106) ||
+      (uc >= 6144 && uc <= 6154) || uc == 6468 || uc == 6469 || uc == 6686 ||
+      uc == 6687 || (uc >= 6816 && uc <= 6822) || (uc >= 6824 && uc <= 6829) ||
+      (uc >= 7002 && uc <= 7008) || (uc >= 7164 && uc <= 7167) ||
+      (uc >= 7227 && uc <= 7231) || uc == 7294 || uc == 7295 ||
+      (uc >= 7360 && uc <= 7367) || uc == 7379 || (uc >= 8208 && uc <= 8231) ||
+      (uc >= 8240 && uc <= 8259) || (uc >= 8261 && uc <= 8273) ||
+      (uc >= 8275 && uc <= 8286) || uc == 8317 || uc == 8318 || uc == 8333 ||
+      uc == 8334 || (uc >= 8968 && uc <= 8971) || uc == 9001 || uc == 9002 ||
+      (uc >= 10088 && uc <= 10101) || uc == 10181 || uc == 10182 ||
+      (uc >= 10214 && uc <= 10223) || (uc >= 10627 && uc <= 10648) ||
+      (uc >= 10712 && uc <= 10715) || uc == 10748 || uc == 10749 ||
+      (uc >= 11513 && uc <= 11516) || uc == 11518 || uc == 11519 ||
+      uc == 11632 || (uc >= 11776 && uc <= 11822) ||
+      (uc >= 11824 && uc <= 11842) || (uc >= 12289 && uc <= 12291) ||
+      (uc >= 12296 && uc <= 12305) || (uc >= 12308 && uc <= 12319) ||
+      uc == 12336 || uc == 12349 || uc == 12448 || uc == 12539 || uc == 42238 ||
+      uc == 42239 || (uc >= 42509 && uc <= 42511) || uc == 42611 ||
+      uc == 42622 || (uc >= 42738 && uc <= 42743) ||
+      (uc >= 43124 && uc <= 43127) || uc == 43214 || uc == 43215 ||
+      (uc >= 43256 && uc <= 43258) || uc == 43310 || uc == 43311 ||
+      uc == 43359 || (uc >= 43457 && uc <= 43469) || uc == 43486 ||
+      uc == 43487 || (uc >= 43612 && uc <= 43615) || uc == 43742 ||
+      uc == 43743 || uc == 43760 || uc == 43761 || uc == 44011 || uc == 64830 ||
+      uc == 64831 || (uc >= 65040 && uc <= 65049) ||
+      (uc >= 65072 && uc <= 65106) || (uc >= 65108 && uc <= 65121) ||
+      uc == 65123 || uc == 65128 || uc == 65130 || uc == 65131 ||
+      (uc >= 65281 && uc <= 65283) || (uc >= 65285 && uc <= 65290) ||
+      (uc >= 65292 && uc <= 65295) || uc == 65306 || uc == 65307 ||
+      uc == 65311 || uc == 65312 || (uc >= 65339 && uc <= 65341) ||
+      uc == 65343 || uc == 65371 || uc == 65373 ||
+      (uc >= 65375 && uc <= 65381) || (uc >= 65792 && uc <= 65794) ||
+      uc == 66463 || uc == 66512 || uc == 66927 || uc == 67671 || uc == 67871 ||
+      uc == 67903 || (uc >= 68176 && uc <= 68184) || uc == 68223 ||
+      (uc >= 68336 && uc <= 68342) || (uc >= 68409 && uc <= 68415) ||
+      (uc >= 68505 && uc <= 68508) || (uc >= 69703 && uc <= 69709) ||
+      uc == 69819 || uc == 69820 || (uc >= 69822 && uc <= 69825) ||
+      (uc >= 69952 && uc <= 69955) || uc == 70004 || uc == 70005 ||
+      (uc >= 70085 && uc <= 70088) || uc == 70093 ||
+      (uc >= 70200 && uc <= 70205) || uc == 70854 ||
+      (uc >= 71105 && uc <= 71113) || (uc >= 71233 && uc <= 71235) ||
+      (uc >= 74864 && uc <= 74868) || uc == 92782 || uc == 92783 ||
+      uc == 92917 || (uc >= 92983 && uc <= 92987) || uc == 92996 ||
+      uc == 113823);
+}
diff --git a/lib/cmark/src/utf8.h b/lib/cmark/src/utf8.h
new file mode 100644
index 0000000..8e45714
--- /dev/null
+++ b/lib/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(int32_t uc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/cmark/src/xml.c b/lib/cmark/src/xml.c
new file mode 100644
index 0000000..9306141
--- /dev/null
+++ b/lib/cmark/src/xml.c
@@ -0,0 +1,173 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "config.h"
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "houdini.h"
+
+#define BUFFER_SIZE 100
+
+// Functions to convert cmark_nodes to XML strings.
+
+static void escape_xml(cmark_strbuf *dest, const unsigned char *source,
+                       bufsize_t length) {
+  houdini_escape_html0(dest, source, length, 0);
+}
+
+struct render_state {
+  cmark_strbuf *xml;
+  int indent;
+};
+
+static CMARK_INLINE void indent(struct render_state *state) {
+  int i;
+  for (i = 0; i < state->indent; i++) {
+    cmark_strbuf_putc(state->xml, ' ');
+  }
+}
+
+static int S_render_node(cmark_node *node, cmark_event_type ev_type,
+                         struct render_state *state, int options) {
+  cmark_strbuf *xml = state->xml;
+  bool literal = false;
+  cmark_delim_type delim;
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  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, " delim=\"paren\"");
+        } else if (delim == CMARK_PERIOD_DELIM) {
+          cmark_strbuf_puts(xml, " delim=\"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(xml, node->as.code.info, strlen((char *)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(xml, node->as.custom.on_enter,
+                 strlen((char *)node->as.custom.on_enter));
+      cmark_strbuf_putc(xml, '"');
+      cmark_strbuf_puts(xml, " on_exit=\"");
+      escape_xml(xml, node->as.custom.on_exit,
+                 strlen((char *)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(xml, node->as.link.url, strlen((char *)node->as.link.url));
+      cmark_strbuf_putc(xml, '"');
+      if (node->as.link.title) {
+        cmark_strbuf_puts(xml, " title=\"");
+        escape_xml(xml, node->as.link.title,
+                   strlen((char *)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;
+}