Add 'cmark/' from commit '64efa3b3b3d35f2ffb604b57a8a9c89047cb420b'

git-subtree-dir: cmark
git-subtree-mainline: 6bf7c5ce92ff6237c0b17c332873805018812b40
git-subtree-split: 64efa3b3b3d35f2ffb604b57a8a9c89047cb420b

40 files changed, 21224 insertions, 0 deletions

diff --git a/cmark/src/CMakeLists.txt b/cmark/src/CMakeLists.txt
new file mode 100644
index 0000000000..523b2cb82b
--- /dev/null
+++ b/cmark/src/CMakeLists.txt
@@ -0,0 +1,100 @@
+
+configure_file(cmark_version.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h)
+configure_file(libcmark.pc.in
+  ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc
+  @ONLY)
+
+add_library(cmark
+  blocks.c
+  buffer.c
+  cmark.c
+  cmark_ctype.c
+  commonmark.c
+  houdini_href_e.c
+  houdini_html_e.c
+  houdini_html_u.c
+  html.c
+  inlines.c
+  iterator.c
+  latex.c
+  man.c
+  node.c
+  references.c
+  render.c
+  scanners.c
+  scanners.re
+  utf8.c
+  xml.c)
+cmark_add_compile_options(cmark)
+set_target_properties(cmark PROPERTIES
+  OUTPUT_NAME "cmark"
+  # Avoid name clash between PROGRAM and LIBRARY pdb files.
+  PDB_NAME libcmark
+  POSITION_INDEPENDENT_CODE YES
+  # Include minor version and patch level in soname for now.
+  SOVERSION ${PROJECT_VERSION}
+  VERSION ${PROJECT_VERSION})
+if(NOT BUILD_SHARED_LIBS)
+  target_compile_definitions(cmark PUBLIC
+    CMARK_STATIC_DEFINE)
+endif()
+target_include_directories(cmark INTERFACE
+  $<INSTALL_INTERFACE:include>
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+
+generate_export_header(cmark
+  BASE_NAME ${PROJECT_NAME})
+
+# FIXME(compnerd) this should be removed, but exists solely to allow a migration
+# path for OSS Fuzz.
+add_custom_target(cmark_static DEPENDS cmark)
+
+add_executable(cmark_exe
+  main.c)
+cmark_add_compile_options(cmark_exe)
+set_target_properties(cmark_exe PROPERTIES
+  OUTPUT_NAME "cmark"
+  INSTALL_RPATH "${Base_rpath}")
+target_link_libraries(cmark_exe PRIVATE
+  cmark)
+
+install(TARGETS cmark_exe cmark
+  EXPORT cmark-targets
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  )
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+
+install(FILES
+  cmark.h
+  ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h
+  ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  )
+
+# generate cmark-config.cmake and cmark-config-version.cmake files
+configure_package_config_file(
+  "cmarkConfig.cmake.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config.cmake"
+  INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cmark")
+write_basic_package_version_file(
+  "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config-version.cmake"
+  VERSION ${PROJECT_VERSION}
+  COMPATIBILITY SameMajorVersion)
+# install config and version file
+install(
+  FILES "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config-version.cmake"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cmark"
+)
+# install targets file
+install(
+  EXPORT "cmark-targets"
+  NAMESPACE "cmark::"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cmark"
+)
diff --git a/cmark/src/blocks.c b/cmark/src/blocks.c
new file mode 100644
index 0000000000..292e563bb6
--- /dev/null
+++ b/cmark/src/blocks.c
@@ -0,0 +1,1345 @@
+/**
+ * Block parsing implementation.
+ *
+ * For a high-level overview of the block parsing process,
+ * see http://spec.commonmark.org/0.24/#phase-1-block-structure
+ */
+
+#include <assert.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "cmark_ctype.h"
+#include "parser.h"
+#include "cmark.h"
+#include "node.h"
+#include "references.h"
+#include "utf8.h"
+#include "scanners.h"
+#include "inlines.h"
+#include "houdini.h"
+#include "buffer.h"
+#include "chunk.h"
+
+#define CODE_INDENT 4
+#define TAB_STOP 4
+
+#ifndef MIN
+#define MIN(x, y) ((x < y) ? x : y)
+#endif
+
+#define peek_at(i, n) (i)->data[n]
+
+static bool S_last_line_blank(const cmark_node *node) {
+  return (node->flags & CMARK_NODE__LAST_LINE_BLANK) != 0;
+}
+
+static bool S_last_line_checked(const cmark_node *node) {
+  return (node->flags & CMARK_NODE__LAST_LINE_CHECKED) != 0;
+}
+
+static inline cmark_node_type S_type(const cmark_node *node) {
+  return (cmark_node_type)node->type;
+}
+
+static void S_set_last_line_blank(cmark_node *node, bool is_blank) {
+  if (is_blank)
+    node->flags |= CMARK_NODE__LAST_LINE_BLANK;
+  else
+    node->flags &= ~CMARK_NODE__LAST_LINE_BLANK;
+}
+
+static void S_set_last_line_checked(cmark_node *node) {
+  node->flags |= CMARK_NODE__LAST_LINE_CHECKED;
+}
+
+static inline bool S_is_line_end_char(char c) {
+  return (c == '\n' || c == '\r');
+}
+
+static inline bool S_is_space_or_tab(char c) {
+  return (c == ' ' || c == '\t');
+}
+
+static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
+                          size_t len, bool eof);
+
+static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
+                           bufsize_t bytes);
+
+static cmark_node *make_block(cmark_mem *mem, cmark_node_type tag,
+                              int start_line, int start_column) {
+  cmark_node *e;
+
+  e = (cmark_node *)mem->calloc(1, sizeof(*e));
+  e->mem = mem;
+  e->type = (uint16_t)tag;
+  e->flags = CMARK_NODE__OPEN;
+  e->start_line = start_line;
+  e->start_column = start_column;
+  e->end_line = start_line;
+
+  return e;
+}
+
+// Create a root document node.
+static cmark_node *make_document(cmark_mem *mem) {
+  cmark_node *e = make_block(mem, CMARK_NODE_DOCUMENT, 1, 1);
+  return e;
+}
+
+cmark_parser *cmark_parser_new_with_mem_into_root(int options, cmark_mem *mem, cmark_node *root) {
+  cmark_parser *parser = (cmark_parser *)mem->calloc(1, sizeof(cmark_parser));
+  parser->mem = mem;
+
+  cmark_strbuf_init(mem, &parser->curline, 256);
+  cmark_strbuf_init(mem, &parser->linebuf, 0);
+  cmark_strbuf_init(mem, &parser->content, 0);
+
+  root->flags = CMARK_NODE__OPEN;
+
+  parser->refmap = cmark_reference_map_new(mem);
+  parser->root = root;
+  parser->current = root;
+  parser->line_number = 0;
+  parser->offset = 0;
+  parser->column = 0;
+  parser->first_nonspace = 0;
+  parser->first_nonspace_column = 0;
+  parser->thematic_break_kill_pos = 0;
+  parser->indent = 0;
+  parser->blank = false;
+  parser->partially_consumed_tab = false;
+  parser->last_line_length = 0;
+  parser->options = options;
+  parser->last_buffer_ended_with_cr = false;
+
+  return parser;
+}
+
+cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem) {
+  cmark_node *document = make_document(mem);
+  return cmark_parser_new_with_mem_into_root(options, mem, document);
+}
+
+cmark_parser *cmark_parser_new(int options) {
+  extern cmark_mem DEFAULT_MEM_ALLOCATOR;
+  return cmark_parser_new_with_mem(options, &DEFAULT_MEM_ALLOCATOR);
+}
+
+void cmark_parser_free(cmark_parser *parser) {
+  cmark_mem *mem = parser->mem;
+  cmark_strbuf_free(&parser->curline);
+  cmark_strbuf_free(&parser->linebuf);
+  cmark_reference_map_free(parser->refmap);
+  mem->free(parser);
+}
+
+static cmark_node *finalize(cmark_parser *parser, cmark_node *b);
+
+// Returns true if line has only space characters, else false.
+static bool is_blank(cmark_strbuf *s, bufsize_t offset) {
+  while (offset < s->size) {
+    switch (s->ptr[offset]) {
+    case '\r':
+    case '\n':
+      return true;
+    case ' ':
+      offset++;
+      break;
+    case '\t':
+      offset++;
+      break;
+    default:
+      return false;
+    }
+  }
+
+  return true;
+}
+
+static inline bool can_contain(cmark_node_type parent_type,
+                               cmark_node_type child_type) {
+  return (parent_type == CMARK_NODE_DOCUMENT ||
+          parent_type == CMARK_NODE_BLOCK_QUOTE ||
+          parent_type == CMARK_NODE_ITEM ||
+          (parent_type == CMARK_NODE_LIST && child_type == CMARK_NODE_ITEM));
+}
+
+static inline bool accepts_lines(cmark_node_type block_type) {
+  return (block_type == CMARK_NODE_PARAGRAPH ||
+          block_type == CMARK_NODE_HEADING ||
+          block_type == CMARK_NODE_CODE_BLOCK);
+}
+
+static inline bool contains_inlines(cmark_node_type block_type) {
+  return (block_type == CMARK_NODE_PARAGRAPH ||
+          block_type == CMARK_NODE_HEADING);
+}
+
+static void add_line(cmark_chunk *ch, cmark_parser *parser) {
+  int chars_to_tab;
+  int i;
+  if (parser->partially_consumed_tab) {
+    parser->offset += 1; // skip over tab
+    // add space characters:
+    chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);
+    for (i = 0; i < chars_to_tab; i++) {
+      cmark_strbuf_putc(&parser->content, ' ');
+    }
+  }
+  cmark_strbuf_put(&parser->content, ch->data + parser->offset,
+                   ch->len - parser->offset);
+}
+
+static void remove_trailing_blank_lines(cmark_strbuf *ln) {
+  bufsize_t i;
+  unsigned char c;
+
+  for (i = ln->size - 1; i >= 0; --i) {
+    c = ln->ptr[i];
+
+    if (c != ' ' && c != '\t' && !S_is_line_end_char(c))
+      break;
+  }
+
+  if (i < 0) {
+    cmark_strbuf_clear(ln);
+    return;
+  }
+
+  for (; i < ln->size; ++i) {
+    c = ln->ptr[i];
+
+    if (!S_is_line_end_char(c))
+      continue;
+
+    cmark_strbuf_truncate(ln, i);
+    break;
+  }
+}
+
+// Check to see if a node ends with a blank line, descending
+// if needed into lists and sublists.
+static bool S_ends_with_blank_line(cmark_node *node) {
+  if (S_last_line_checked(node)) {
+    return(S_last_line_blank(node));
+  } else if ((S_type(node) == CMARK_NODE_LIST ||
+              S_type(node) == CMARK_NODE_ITEM) && node->last_child) {
+    S_set_last_line_checked(node);
+    return(S_ends_with_blank_line(node->last_child));
+  } else {
+    S_set_last_line_checked(node);
+    return (S_last_line_blank(node));
+  }
+}
+
+// returns true if content remains after link defs are resolved.
+static bool resolve_reference_link_definitions(cmark_parser *parser) {
+  bufsize_t pos;
+  cmark_strbuf *node_content = &parser->content;
+  cmark_chunk chunk = {node_content->ptr, node_content->size};
+  while (chunk.len && chunk.data[0] == '[' &&
+         (pos = cmark_parse_reference_inline(parser->mem, &chunk,
+                                             parser->refmap))) {
+
+    chunk.data += pos;
+    chunk.len -= pos;
+  }
+  cmark_strbuf_drop(node_content, (node_content->size - chunk.len));
+  return !is_blank(node_content, 0);
+}
+
+static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {
+  bufsize_t pos;
+  cmark_node *item;
+  cmark_node *subitem;
+  cmark_node *parent;
+  bool has_content;
+
+  parent = b->parent;
+  assert(b->flags &
+         CMARK_NODE__OPEN); // shouldn't call finalize on closed blocks
+  b->flags &= ~CMARK_NODE__OPEN;
+
+  if (parser->curline.size == 0) {
+    // end of input - line number has not been incremented
+    b->end_line = parser->line_number;
+    b->end_column = parser->last_line_length;
+  } else if (S_type(b) == CMARK_NODE_DOCUMENT ||
+             (S_type(b) == CMARK_NODE_CODE_BLOCK && b->as.code.fenced) ||
+             (S_type(b) == CMARK_NODE_HEADING && b->as.heading.setext)) {
+    b->end_line = parser->line_number;
+    b->end_column = parser->curline.size;
+    if (b->end_column && parser->curline.ptr[b->end_column - 1] == '\n')
+      b->end_column -= 1;
+    if (b->end_column && parser->curline.ptr[b->end_column - 1] == '\r')
+      b->end_column -= 1;
+  } else {
+    b->end_line = parser->line_number - 1;
+    b->end_column = parser->last_line_length;
+  }
+
+  cmark_strbuf *node_content = &parser->content;
+
+  switch (S_type(b)) {
+  case CMARK_NODE_PARAGRAPH:
+  {
+    has_content = resolve_reference_link_definitions(parser);
+    if (!has_content) {
+      // remove blank node (former reference def)
+      cmark_node_free(b);
+    } else {
+      b->len = node_content->size;
+      b->data = cmark_strbuf_detach(node_content);
+    }
+    break;
+  }
+
+  case CMARK_NODE_CODE_BLOCK:
+    if (!b->as.code.fenced) { // indented code
+      remove_trailing_blank_lines(node_content);
+      cmark_strbuf_putc(node_content, '\n');
+    } else {
+      // first line of contents becomes info
+      for (pos = 0; pos < node_content->size; ++pos) {
+        if (S_is_line_end_char(node_content->ptr[pos]))
+          break;
+      }
+      assert(pos < node_content->size);
+
+      if (pos == 0) {
+        b->as.code.info = NULL;
+      } else {
+        cmark_strbuf tmp = CMARK_BUF_INIT(parser->mem);
+        houdini_unescape_html_f(&tmp, node_content->ptr, pos);
+        cmark_strbuf_trim(&tmp);
+        cmark_strbuf_unescape(&tmp);
+        b->as.code.info = cmark_strbuf_detach(&tmp);
+      }
+
+      if (node_content->ptr[pos] == '\r')
+        pos += 1;
+      if (node_content->ptr[pos] == '\n')
+        pos += 1;
+      cmark_strbuf_drop(node_content, pos);
+    }
+    b->len = node_content->size;
+    b->data = cmark_strbuf_detach(node_content);
+    break;
+
+  case CMARK_NODE_HEADING:
+  case CMARK_NODE_HTML_BLOCK:
+    b->len = node_content->size;
+    b->data = cmark_strbuf_detach(node_content);
+    break;
+
+  case CMARK_NODE_LIST:      // determine tight/loose status
+    b->as.list.tight = true; // tight by default
+    item = b->first_child;
+
+    while (item) {
+      // check for non-final non-empty list item ending with blank line:
+      if (S_last_line_blank(item) && item->next) {
+        b->as.list.tight = false;
+        break;
+      }
+      // recurse into children of list item, to see if there are
+      // spaces between them:
+      subitem = item->first_child;
+      while (subitem) {
+        if ((item->next || subitem->next) &&
+            S_ends_with_blank_line(subitem)) {
+          b->as.list.tight = false;
+          break;
+        }
+        subitem = subitem->next;
+      }
+      if (!(b->as.list.tight)) {
+        break;
+      }
+      item = item->next;
+    }
+
+    break;
+
+  default:
+    break;
+  }
+
+  return parent;
+}
+
+// Add a node as child of another.  Return pointer to child.
+static cmark_node *add_child(cmark_parser *parser, cmark_node *parent,
+                             cmark_node_type block_type, int start_column) {
+  assert(parent);
+
+  // if 'parent' isn't the kind of node that can accept this child,
+  // then back up til we hit a node that can.
+  while (!can_contain(S_type(parent), block_type)) {
+    parent = finalize(parser, parent);
+  }
+
+  cmark_node *child =
+      make_block(parser->mem, block_type, parser->line_number, start_column);
+  child->parent = parent;
+
+  if (parent->last_child) {
+    parent->last_child->next = child;
+    child->prev = parent->last_child;
+  } else {
+    parent->first_child = child;
+    child->prev = NULL;
+  }
+  parent->last_child = child;
+  return child;
+}
+
+// Walk through node and all children, recursively, parsing
+// string content into inline content where appropriate.
+static void process_inlines(cmark_mem *mem, cmark_node *root,
+                            cmark_reference_map *refmap, int options) {
+  cmark_iter *iter = cmark_iter_new(root);
+  cmark_node *cur;
+  cmark_event_type ev_type;
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    if (ev_type == CMARK_EVENT_ENTER) {
+      if (contains_inlines(S_type(cur))) {
+        cmark_parse_inlines(mem, cur, refmap, options);
+        mem->free(cur->data);
+        cur->data = NULL;
+        cur->len = 0;
+      }
+    }
+  }
+
+  cmark_iter_free(iter);
+}
+
+// Attempts to parse a list item marker (bullet or enumerated).
+// On success, returns length of the marker, and populates
+// data with the details.  On failure, returns 0.
+static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input,
+                                   bufsize_t pos, bool interrupts_paragraph,
+                                   cmark_list **dataptr) {
+  unsigned char c;
+  bufsize_t startpos;
+  cmark_list *data;
+  bufsize_t i;
+
+  startpos = pos;
+  c = peek_at(input, pos);
+
+  if (c == '*' || c == '-' || c == '+') {
+    pos++;
+    if (!cmark_isspace(peek_at(input, pos))) {
+      return 0;
+    }
+
+    if (interrupts_paragraph) {
+      i = pos;
+      // require non-blank content after list marker:
+      while (S_is_space_or_tab(peek_at(input, i))) {
+        i++;
+      }
+      if (peek_at(input, i) == '\n') {
+        return 0;
+      }
+    }
+
+    data = (cmark_list *)mem->calloc(1, sizeof(*data));
+    data->marker_offset = 0; // will be adjusted later
+    data->list_type = CMARK_BULLET_LIST;
+    data->bullet_char = c;
+    data->start = 0;
+    data->delimiter = CMARK_NO_DELIM;
+    data->tight = false;
+  } else if (cmark_isdigit(c)) {
+    int start = 0;
+    int digits = 0;
+
+    do {
+      start = (10 * start) + (peek_at(input, pos) - '0');
+      pos++;
+      digits++;
+      // We limit to 9 digits to avoid overflow,
+      // assuming max int is 2^31 - 1
+      // This also seems to be the limit for 'start' in some browsers.
+    } while (digits < 9 && cmark_isdigit(peek_at(input, pos)));
+
+    if (interrupts_paragraph && start != 1) {
+      return 0;
+    }
+    c = peek_at(input, pos);
+    if (c == '.' || c == ')') {
+      pos++;
+      if (!cmark_isspace(peek_at(input, pos))) {
+        return 0;
+      }
+      if (interrupts_paragraph) {
+        // require non-blank content after list marker:
+        i = pos;
+        while (S_is_space_or_tab(peek_at(input, i))) {
+          i++;
+        }
+        if (S_is_line_end_char(peek_at(input, i))) {
+          return 0;
+        }
+      }
+
+      data = (cmark_list *)mem->calloc(1, sizeof(*data));
+      data->marker_offset = 0; // will be adjusted later
+      data->list_type = CMARK_ORDERED_LIST;
+      data->bullet_char = 0;
+      data->start = start;
+      data->delimiter = (c == '.' ? CMARK_PERIOD_DELIM : CMARK_PAREN_DELIM);
+      data->tight = false;
+    } else {
+      return 0;
+    }
+  } else {
+    return 0;
+  }
+
+  *dataptr = data;
+  return (pos - startpos);
+}
+
+// Return 1 if list item belongs in list, else 0.
+static int lists_match(cmark_list *list_data, cmark_list *item_data) {
+  return (list_data->list_type == item_data->list_type &&
+          list_data->delimiter == item_data->delimiter &&
+          // list_data->marker_offset == item_data.marker_offset &&
+          list_data->bullet_char == item_data->bullet_char);
+}
+
+static cmark_node *finalize_document(cmark_parser *parser) {
+  while (parser->current != parser->root) {
+    parser->current = finalize(parser, parser->current);
+  }
+
+  finalize(parser, parser->root);
+
+  // Limit total size of extra content created from reference links to
+  // document size to avoid superlinear growth. Always allow 100KB.
+  if (parser->total_size > 100000)
+    parser->refmap->max_ref_size = parser->total_size;
+  else
+    parser->refmap->max_ref_size = 100000;
+
+  process_inlines(parser->mem, parser->root, parser->refmap, parser->options);
+
+  cmark_strbuf_free(&parser->content);
+
+  return parser->root;
+}
+
+cmark_node *cmark_parse_file(FILE *f, int options) {
+  unsigned char buffer[4096];
+  cmark_parser *parser = cmark_parser_new(options);
+  size_t bytes;
+  cmark_node *document;
+
+  while ((bytes = fread(buffer, 1, sizeof(buffer), f)) > 0) {
+    bool eof = bytes < sizeof(buffer);
+    S_parser_feed(parser, buffer, bytes, eof);
+    if (eof) {
+      break;
+    }
+  }
+
+  document = cmark_parser_finish(parser);
+  cmark_parser_free(parser);
+  return document;
+}
+
+cmark_node *cmark_parse_document(const char *buffer, size_t len, int options) {
+  cmark_parser *parser = cmark_parser_new(options);
+  cmark_node *document;
+
+  S_parser_feed(parser, (const unsigned char *)buffer, len, true);
+
+  document = cmark_parser_finish(parser);
+  cmark_parser_free(parser);
+  return document;
+}
+
+void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len) {
+  S_parser_feed(parser, (const unsigned char *)buffer, len, false);
+}
+
+static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
+                          size_t len, bool eof) {
+  const unsigned char *end = buffer + len;
+  static const uint8_t repl[] = {239, 191, 189};
+
+  if (len > UINT_MAX - parser->total_size)
+    parser->total_size = UINT_MAX;
+  else
+    parser->total_size += (int)len;
+
+  // Skip UTF-8 BOM if present; see #334
+  if (parser->line_number == 0 && parser->column == 0 && len >= 3 &&
+      *buffer == 0xEF && *(buffer + 1) == 0xBB &&
+      *(buffer + 2) == 0xBF) {
+    buffer += 3;
+  } else if (parser->last_buffer_ended_with_cr && *buffer == '\n') {
+    // skip NL if last buffer ended with CR ; see #117
+    buffer++;
+  }
+
+  parser->last_buffer_ended_with_cr = false;
+  while (buffer < end) {
+    const unsigned char *eol;
+    bufsize_t chunk_len;
+    bool process = false;
+    for (eol = buffer; eol < end; ++eol) {
+      if (S_is_line_end_char(*eol)) {
+        process = true;
+        break;
+      }
+      if (*eol == '\0' && eol < end) {
+        break;
+      }
+    }
+    if (eol >= end && eof) {
+      process = true;
+    }
+
+    chunk_len = (eol - buffer);
+    if (process) {
+      if (parser->linebuf.size > 0) {
+        cmark_strbuf_put(&parser->linebuf, buffer, chunk_len);
+        S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size);
+        cmark_strbuf_clear(&parser->linebuf);
+      } else {
+        S_process_line(parser, buffer, chunk_len);
+      }
+    } else {
+      if (eol < end && *eol == '\0') {
+        // omit NULL byte
+        cmark_strbuf_put(&parser->linebuf, buffer, chunk_len);
+        // add replacement character
+        cmark_strbuf_put(&parser->linebuf, repl, 3);
+      } else {
+        cmark_strbuf_put(&parser->linebuf, buffer, chunk_len);
+      }
+    }
+
+    buffer += chunk_len;
+    if (buffer < end) {
+      if (*buffer == '\0') {
+        // skip over NULL
+        buffer++;
+      } else {
+        // skip over line ending characters
+        if (*buffer == '\r') {
+          buffer++;
+          if (buffer == end)
+            parser->last_buffer_ended_with_cr = true;
+        }
+        if (buffer < end && *buffer == '\n')
+          buffer++;
+      }
+    }
+  }
+}
+
+static void chop_trailing_hashtags(cmark_chunk *ch) {
+  bufsize_t n, orig_n;
+
+  cmark_chunk_rtrim(ch);
+  orig_n = n = ch->len - 1;
+
+  // if string ends in space followed by #s, remove these:
+  while (n >= 0 && peek_at(ch, n) == '#')
+    n--;
+
+  // Check for a space before the final #s:
+  if (n != orig_n && n >= 0 && S_is_space_or_tab(peek_at(ch, n))) {
+    ch->len = n;
+    cmark_chunk_rtrim(ch);
+  }
+}
+
+// Check for thematic break.  On failure, return 0 and update
+// thematic_break_kill_pos with the index at which the
+// parse fails.  On success, return length of match.
+// "...three or more hyphens, asterisks,
+// or underscores on a line by themselves. If you wish, you may use
+// spaces between the hyphens or asterisks."
+static int S_scan_thematic_break(cmark_parser *parser, cmark_chunk *input,
+                                 bufsize_t offset) {
+  bufsize_t i;
+  char c;
+  char nextc = '\0';
+  int count;
+  i = offset;
+  c = peek_at(input, i);
+  if (!(c == '*' || c == '_' || c == '-')) {
+    parser->thematic_break_kill_pos = i;
+    return 0;
+  }
+  count = 1;
+  while ((nextc = peek_at(input, ++i))) {
+    if (nextc == c) {
+      count++;
+    } else if (nextc != ' ' && nextc != '\t') {
+      break;
+    }
+  }
+  if (count >= 3 && (nextc == '\r' || nextc == '\n')) {
+    return (i - offset) + 1;
+  } else {
+    parser->thematic_break_kill_pos = i;
+    return 0;
+  }
+}
+
+// Find first nonspace character from current offset, setting
+// parser->first_nonspace, parser->first_nonspace_column,
+// parser->indent, and parser->blank. Does not advance parser->offset.
+static void S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input) {
+  char c;
+  int chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);
+
+  if (parser->first_nonspace <= parser->offset) {
+    parser->first_nonspace = parser->offset;
+    parser->first_nonspace_column = parser->column;
+    while ((c = peek_at(input, parser->first_nonspace))) {
+      if (c == ' ') {
+        parser->first_nonspace += 1;
+        parser->first_nonspace_column += 1;
+        chars_to_tab = chars_to_tab - 1;
+        if (chars_to_tab == 0) {
+          chars_to_tab = TAB_STOP;
+        }
+      } else if (c == '\t') {
+        parser->first_nonspace += 1;
+        parser->first_nonspace_column += chars_to_tab;
+        chars_to_tab = TAB_STOP;
+      } else {
+        break;
+      }
+    }
+  }
+
+  parser->indent = parser->first_nonspace_column - parser->column;
+  parser->blank = S_is_line_end_char(peek_at(input, parser->first_nonspace));
+}
+
+// Advance parser->offset and parser->column.  parser->offset is the
+// byte position in input; parser->column is a virtual column number
+// that takes into account tabs. (Multibyte characters are not taken
+// into account, because the Markdown line prefixes we are interested in
+// analyzing are entirely ASCII.)  The count parameter indicates
+// how far to advance the offset.  If columns is true, then count
+// indicates a number of columns; otherwise, a number of bytes.
+// If advancing a certain number of columns partially consumes
+// a tab character, parser->partially_consumed_tab is set to true.
+static void S_advance_offset(cmark_parser *parser, cmark_chunk *input,
+                             bufsize_t count, bool columns) {
+  char c;
+  int chars_to_tab;
+  int chars_to_advance;
+  while (count > 0 && (c = peek_at(input, parser->offset))) {
+    if (c == '\t') {
+      chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);
+      if (columns) {
+        parser->partially_consumed_tab = chars_to_tab > count;
+        chars_to_advance = MIN(count, chars_to_tab);
+        parser->column += chars_to_advance;
+        parser->offset += (parser->partially_consumed_tab ? 0 : 1);
+        count -= chars_to_advance;
+      } else {
+        parser->partially_consumed_tab = false;
+        parser->column += chars_to_tab;
+        parser->offset += 1;
+        count -= 1;
+      }
+    } else {
+      parser->partially_consumed_tab = false;
+      parser->offset += 1;
+      parser->column += 1; // assume ascii; block starts are ascii
+      count -= 1;
+    }
+  }
+}
+
+static bool S_last_child_is_open(cmark_node *container) {
+  return container->last_child &&
+         (container->last_child->flags & CMARK_NODE__OPEN);
+}
+
+static bool parse_block_quote_prefix(cmark_parser *parser, cmark_chunk *input) {
+  bool res = false;
+  bufsize_t matched = 0;
+
+  matched =
+      parser->indent <= 3 && peek_at(input, parser->first_nonspace) == '>';
+  if (matched) {
+
+    S_advance_offset(parser, input, parser->indent + 1, true);
+
+    if (S_is_space_or_tab(peek_at(input, parser->offset))) {
+      S_advance_offset(parser, input, 1, true);
+    }
+
+    res = true;
+  }
+  return res;
+}
+
+static bool parse_node_item_prefix(cmark_parser *parser, cmark_chunk *input,
+                                   cmark_node *container) {
+  bool res = false;
+
+  if (parser->indent >=
+      container->as.list.marker_offset + container->as.list.padding) {
+    S_advance_offset(parser, input, container->as.list.marker_offset +
+                                        container->as.list.padding,
+                     true);
+    res = true;
+  } else if (parser->blank && container->first_child != NULL) {
+    // if container->first_child is NULL, then the opening line
+    // of the list item was blank after the list marker; in this
+    // case, we are done with the list item.
+    S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+                     false);
+    res = true;
+  }
+  return res;
+}
+
+static bool parse_code_block_prefix(cmark_parser *parser, cmark_chunk *input,
+                                    cmark_node *container,
+                                    bool *should_continue) {
+  bool res = false;
+
+  if (!container->as.code.fenced) { // indented
+    if (parser->indent >= CODE_INDENT) {
+      S_advance_offset(parser, input, CODE_INDENT, true);
+      res = true;
+    } else if (parser->blank) {
+      S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+                       false);
+      res = true;
+    }
+  } else { // fenced
+    bufsize_t matched = 0;
+
+    if (parser->indent <= 3 && (peek_at(input, parser->first_nonspace) ==
+                                container->as.code.fence_char)) {
+      matched = scan_close_code_fence(input, parser->first_nonspace);
+    }
+
+    if (matched >= container->as.code.fence_length) {
+      // closing fence - and since we're at
+      // the end of a line, we can stop processing it:
+      *should_continue = false;
+      S_advance_offset(parser, input, matched, false);
+      parser->current = finalize(parser, container);
+    } else {
+      // skip opt. spaces of fence parser->offset
+      int i = container->as.code.fence_offset;
+
+      while (i > 0 && S_is_space_or_tab(peek_at(input, parser->offset))) {
+        S_advance_offset(parser, input, 1, true);
+        i--;
+      }
+      res = true;
+    }
+  }
+
+  return res;
+}
+
+static bool parse_html_block_prefix(cmark_parser *parser,
+                                    cmark_node *container) {
+  bool res = false;
+  int html_block_type = container->as.html_block_type;
+
+  assert(html_block_type >= 1 && html_block_type <= 7);
+  switch (html_block_type) {
+  case 1:
+  case 2:
+  case 3:
+  case 4:
+  case 5:
+    // these types of blocks can accept blanks
+    res = true;
+    break;
+  case 6:
+  case 7:
+    res = !parser->blank;
+    break;
+  }
+
+  return res;
+}
+
+/**
+ * For each containing node, try to parse the associated line start.
+ *
+ * Will not close unmatched blocks, as we may have a lazy continuation
+ * line -> http://spec.commonmark.org/0.24/#lazy-continuation-line
+ *
+ * Returns: The last matching node, or NULL
+ */
+static cmark_node *check_open_blocks(cmark_parser *parser, cmark_chunk *input,
+                                     bool *all_matched) {
+  bool should_continue = true;
+  *all_matched = false;
+  cmark_node *container = parser->root;
+  cmark_node_type cont_type;
+
+  while (S_last_child_is_open(container)) {
+    container = container->last_child;
+    cont_type = S_type(container);
+
+    S_find_first_nonspace(parser, input);
+
+    switch (cont_type) {
+    case CMARK_NODE_BLOCK_QUOTE:
+      if (!parse_block_quote_prefix(parser, input))
+        goto done;
+      break;
+    case CMARK_NODE_LIST:
+      // Avoid quadratic behavior caused by iterating deeply nested lists
+      // for each blank line.
+      if (parser->blank) {
+        if (container->flags & CMARK_NODE__LIST_LAST_LINE_BLANK &&
+            parser->indent == 0) {
+          // Abort early if we encounter multiple blank lines. Returning
+          // NULL will cause S_process_line to skip the calls to
+          // open_new_blocks and add_text_to_container. open_new_blocks
+          // is a no-op for blank lines. add_text_to_container closes
+          // remaining open nodes, but since we have a second blank
+          // line, all open nodes have already been closed when the
+          // first blank line was processed. Certain block types accept
+          // empty lines as content, so add them here.
+          if (parser->current->type == CMARK_NODE_CODE_BLOCK ||
+              parser->current->type == CMARK_NODE_HTML_BLOCK) {
+            add_line(input, parser);
+          }
+          return NULL;
+        }
+        container->flags |= CMARK_NODE__LIST_LAST_LINE_BLANK;
+      } else {
+        container->flags &= ~CMARK_NODE__LIST_LAST_LINE_BLANK;
+      }
+      break;
+    case CMARK_NODE_ITEM:
+      if (!parse_node_item_prefix(parser, input, container))
+        goto done;
+      break;
+    case CMARK_NODE_CODE_BLOCK:
+      if (!parse_code_block_prefix(parser, input, container, &should_continue))
+        goto done;
+      break;
+    case CMARK_NODE_HEADING:
+      // a heading can never contain more than one line
+      goto done;
+    case CMARK_NODE_HTML_BLOCK:
+      if (!parse_html_block_prefix(parser, container))
+        goto done;
+      break;
+    case CMARK_NODE_PARAGRAPH:
+      if (parser->blank)
+        goto done;
+      break;
+    default:
+      break;
+    }
+  }
+
+  *all_matched = true;
+
+done:
+  if (!*all_matched) {
+    container = container->parent; // back up to last matching node
+  }
+
+  if (!should_continue) {
+    container = NULL;
+  }
+
+  return container;
+}
+
+static void open_new_blocks(cmark_parser *parser, cmark_node **container,
+                            cmark_chunk *input, bool all_matched) {
+  bool indented;
+  cmark_list *data = NULL;
+  bool maybe_lazy = S_type(parser->current) == CMARK_NODE_PARAGRAPH;
+  cmark_node_type cont_type = S_type(*container);
+  bufsize_t matched = 0;
+  int lev = 0;
+  bool save_partially_consumed_tab;
+  bool has_content;
+  int save_offset;
+  int save_column;
+
+  while (cont_type != CMARK_NODE_CODE_BLOCK &&
+         cont_type != CMARK_NODE_HTML_BLOCK) {
+
+    S_find_first_nonspace(parser, input);
+    indented = parser->indent >= CODE_INDENT;
+
+    if (!indented && peek_at(input, parser->first_nonspace) == '>') {
+
+      bufsize_t blockquote_startpos = parser->first_nonspace;
+
+      S_advance_offset(parser, input,
+                       parser->first_nonspace + 1 - parser->offset, false);
+      // optional following character
+      if (S_is_space_or_tab(peek_at(input, parser->offset))) {
+        S_advance_offset(parser, input, 1, true);
+      }
+      *container = add_child(parser, *container, CMARK_NODE_BLOCK_QUOTE,
+                             blockquote_startpos + 1);
+
+    } else if (!indented && (matched = scan_atx_heading_start(
+                                 input, parser->first_nonspace))) {
+      bufsize_t hashpos;
+      int level = 0;
+      bufsize_t heading_startpos = parser->first_nonspace;
+
+      S_advance_offset(parser, input,
+                       parser->first_nonspace + matched - parser->offset,
+                       false);
+      *container = add_child(parser, *container, CMARK_NODE_HEADING,
+                             heading_startpos + 1);
+
+      hashpos = cmark_chunk_strchr(input, '#', parser->first_nonspace);
+
+      while (peek_at(input, hashpos) == '#') {
+        level++;
+        hashpos++;
+      }
+
+      (*container)->as.heading.level = level;
+      (*container)->as.heading.setext = false;
+      (*container)->as.heading.internal_offset = matched;
+
+    } else if (!indented && (matched = scan_open_code_fence(
+                                 input, parser->first_nonspace))) {
+      *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK,
+                             parser->first_nonspace + 1);
+      (*container)->as.code.fenced = true;
+      (*container)->as.code.fence_char = peek_at(input, parser->first_nonspace);
+      (*container)->as.code.fence_length = (matched > 255) ? 255 : matched;
+      (*container)->as.code.fence_offset =
+          (int8_t)(parser->first_nonspace - parser->offset);
+      (*container)->as.code.info = NULL;
+      S_advance_offset(parser, input,
+                       parser->first_nonspace + matched - parser->offset,
+                       false);
+
+    } else if (!indented && ((matched = scan_html_block_start(
+                                  input, parser->first_nonspace)) ||
+                             (cont_type != CMARK_NODE_PARAGRAPH &&
+                              !maybe_lazy &&
+                              (matched = scan_html_block_start_7(
+                                   input, parser->first_nonspace))))) {
+      *container = add_child(parser, *container, CMARK_NODE_HTML_BLOCK,
+                             parser->first_nonspace + 1);
+      (*container)->as.html_block_type = matched;
+      // note, we don't adjust parser->offset because the tag is part of the
+      // text
+    } else if (!indented && cont_type == CMARK_NODE_PARAGRAPH &&
+               (lev =
+                    scan_setext_heading_line(input, parser->first_nonspace))) {
+      // finalize paragraph, resolving reference links
+      has_content = resolve_reference_link_definitions(parser);
+
+      if (has_content) {
+
+        (*container)->type = (uint16_t)CMARK_NODE_HEADING;
+        (*container)->as.heading.level = lev;
+        (*container)->as.heading.setext = true;
+        S_advance_offset(parser, input, input->len - 1 - parser->offset, false);
+      }
+    } else if (!indented &&
+               !(cont_type == CMARK_NODE_PARAGRAPH && !all_matched) &&
+               (parser->thematic_break_kill_pos <= parser->first_nonspace) &&
+               S_scan_thematic_break(parser, input, parser->first_nonspace)) {
+      // it's only now that we know the line is not part of a setext heading:
+      *container = add_child(parser, *container, CMARK_NODE_THEMATIC_BREAK,
+                             parser->first_nonspace + 1);
+      S_advance_offset(parser, input, input->len - 1 - parser->offset, false);
+    } else if ((!indented || cont_type == CMARK_NODE_LIST) &&
+               parser->indent < 4 &&
+               (matched = parse_list_marker(
+                    parser->mem, input, parser->first_nonspace,
+                    (*container)->type == CMARK_NODE_PARAGRAPH, &data))) {
+
+      // Note that we can have new list items starting with >= 4
+      // spaces indent, as long as the list container is still open.
+      int i = 0;
+
+      // compute padding:
+      S_advance_offset(parser, input,
+                       parser->first_nonspace + matched - parser->offset,
+                       false);
+
+      save_partially_consumed_tab = parser->partially_consumed_tab;
+      save_offset = parser->offset;
+      save_column = parser->column;
+
+      while (parser->column - save_column <= 5 &&
+             S_is_space_or_tab(peek_at(input, parser->offset))) {
+        S_advance_offset(parser, input, 1, true);
+      }
+
+      i = parser->column - save_column;
+      if (i >= 5 || i < 1 ||
+          // only spaces after list marker:
+          S_is_line_end_char(peek_at(input, parser->offset))) {
+        data->padding = matched + 1;
+        parser->offset = save_offset;
+        parser->column = save_column;
+        parser->partially_consumed_tab = save_partially_consumed_tab;
+        if (i > 0) {
+          S_advance_offset(parser, input, 1, true);
+        }
+      } else {
+        data->padding = matched + i;
+      }
+
+      // check container; if it's a list, see if this list item
+      // can continue the list; otherwise, create a list container.
+
+      data->marker_offset = parser->indent;
+
+      if (cont_type != CMARK_NODE_LIST ||
+          !lists_match(&((*container)->as.list), data)) {
+        *container = add_child(parser, *container, CMARK_NODE_LIST,
+                               parser->first_nonspace + 1);
+
+        memcpy(&((*container)->as.list), data, sizeof(*data));
+      }
+
+      // add the list item
+      *container = add_child(parser, *container, CMARK_NODE_ITEM,
+                             parser->first_nonspace + 1);
+      /* TODO: static */
+      memcpy(&((*container)->as.list), data, sizeof(*data));
+      parser->mem->free(data);
+    } else if (indented && !maybe_lazy && !parser->blank) {
+      S_advance_offset(parser, input, CODE_INDENT, true);
+      *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK,
+                             parser->offset + 1);
+      (*container)->as.code.fenced = false;
+      (*container)->as.code.fence_char = 0;
+      (*container)->as.code.fence_length = 0;
+      (*container)->as.code.fence_offset = 0;
+      (*container)->as.code.info = NULL;
+
+    } else {
+      break;
+    }
+
+    if (accepts_lines(S_type(*container))) {
+      // if it's a line container, it can't contain other containers
+      break;
+    }
+
+    cont_type = S_type(*container);
+    maybe_lazy = false;
+  }
+}
+
+static void add_text_to_container(cmark_parser *parser, cmark_node *container,
+                                  cmark_node *last_matched_container,
+                                  cmark_chunk *input) {
+  cmark_node *tmp;
+  // what remains at parser->offset is a text line.  add the text to the
+  // appropriate container.
+
+  S_find_first_nonspace(parser, input);
+
+  if (parser->blank && container->last_child)
+    S_set_last_line_blank(container->last_child, true);
+
+  // block quote lines are never blank as they start with >
+  // and we don't count blanks in fenced code for purposes of tight/loose
+  // lists or breaking out of lists.  we also don't set last_line_blank
+  // on an empty list item.
+  const cmark_node_type ctype = S_type(container);
+  const bool last_line_blank =
+      (parser->blank && ctype != CMARK_NODE_BLOCK_QUOTE &&
+       ctype != CMARK_NODE_HEADING && ctype != CMARK_NODE_THEMATIC_BREAK &&
+       !(ctype == CMARK_NODE_CODE_BLOCK && container->as.code.fenced) &&
+       !(ctype == CMARK_NODE_ITEM && container->first_child == NULL &&
+         container->start_line == parser->line_number));
+
+  S_set_last_line_blank(container, last_line_blank);
+
+  tmp = container;
+  while (tmp->parent) {
+    S_set_last_line_blank(tmp->parent, false);
+    tmp = tmp->parent;
+  }
+
+  // If the last line processed belonged to a paragraph node,
+  // and we didn't match all of the line prefixes for the open containers,
+  // and we didn't start any new containers,
+  // and the line isn't blank,
+  // then treat this as a "lazy continuation line" and add it to
+  // the open paragraph.
+  if (parser->current != last_matched_container &&
+      container == last_matched_container && !parser->blank &&
+      S_type(parser->current) == CMARK_NODE_PARAGRAPH) {
+    add_line(input, parser);
+  } else { // not a lazy continuation
+    // Finalize any blocks that were not matched and set cur to container:
+    while (parser->current != last_matched_container) {
+      parser->current = finalize(parser, parser->current);
+      assert(parser->current != NULL);
+    }
+
+    if (S_type(container) == CMARK_NODE_CODE_BLOCK) {
+      add_line(input, parser);
+    } else if (S_type(container) == CMARK_NODE_HTML_BLOCK) {
+      add_line(input, parser);
+
+      int matches_end_condition;
+      switch (container->as.html_block_type) {
+      case 1:
+        // </script>, </style>, </textarea>, </pre>
+        matches_end_condition =
+            scan_html_block_end_1(input, parser->first_nonspace);
+        break;
+      case 2:
+        // -->
+        matches_end_condition =
+            scan_html_block_end_2(input, parser->first_nonspace);
+        break;
+      case 3:
+        // ?>
+        matches_end_condition =
+            scan_html_block_end_3(input, parser->first_nonspace);
+        break;
+      case 4:
+        // >
+        matches_end_condition =
+            scan_html_block_end_4(input, parser->first_nonspace);
+        break;
+      case 5:
+        // ]]>
+        matches_end_condition =
+            scan_html_block_end_5(input, parser->first_nonspace);
+        break;
+      default:
+        matches_end_condition = 0;
+        break;
+      }
+
+      if (matches_end_condition) {
+        container = finalize(parser, container);
+        assert(parser->current != NULL);
+      }
+    } else if (parser->blank) {
+      // ??? do nothing
+    } else if (accepts_lines(S_type(container))) {
+      if (S_type(container) == CMARK_NODE_HEADING &&
+          container->as.heading.setext == false) {
+        chop_trailing_hashtags(input);
+      }
+      S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+                       false);
+      add_line(input, parser);
+    } else {
+      // create paragraph container for line
+      container = add_child(parser, container, CMARK_NODE_PARAGRAPH,
+                            parser->first_nonspace + 1);
+      S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+                       false);
+      add_line(input, parser);
+    }
+
+    parser->current = container;
+  }
+}
+
+/* See http://spec.commonmark.org/0.24/#phase-1-block-structure */
+static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
+                           bufsize_t bytes) {
+  cmark_node *last_matched_container;
+  bool all_matched = true;
+  cmark_node *container;
+  cmark_chunk input;
+
+  if (parser->options & CMARK_OPT_VALIDATE_UTF8)
+    cmark_utf8proc_check(&parser->curline, buffer, bytes);
+  else
+    cmark_strbuf_put(&parser->curline, buffer, bytes);
+
+  bytes = parser->curline.size;
+
+  // ensure line ends with a newline:
+  if (bytes == 0 || !S_is_line_end_char(parser->curline.ptr[bytes - 1]))
+    cmark_strbuf_putc(&parser->curline, '\n');
+
+  parser->offset = 0;
+  parser->column = 0;
+  parser->first_nonspace = 0;
+  parser->first_nonspace_column = 0;
+  parser->thematic_break_kill_pos = 0;
+  parser->indent = 0;
+  parser->blank = false;
+  parser->partially_consumed_tab = false;
+
+  input.data = parser->curline.ptr;
+  input.len = parser->curline.size;
+
+  parser->line_number++;
+
+  last_matched_container = check_open_blocks(parser, &input, &all_matched);
+
+  if (!last_matched_container)
+    goto finished;
+
+  container = last_matched_container;
+
+  open_new_blocks(parser, &container, &input, all_matched);
+
+  add_text_to_container(parser, container, last_matched_container, &input);
+
+finished:
+  parser->last_line_length = input.len;
+  if (parser->last_line_length &&
+      input.data[parser->last_line_length - 1] == '\n')
+    parser->last_line_length -= 1;
+  if (parser->last_line_length &&
+      input.data[parser->last_line_length - 1] == '\r')
+    parser->last_line_length -= 1;
+
+  cmark_strbuf_clear(&parser->curline);
+}
+
+cmark_node *cmark_parser_finish(cmark_parser *parser) {
+  if (parser->linebuf.size) {
+    S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size);
+    cmark_strbuf_clear(&parser->linebuf);
+  }
+
+  finalize_document(parser);
+
+  cmark_consolidate_text_nodes(parser->root);
+
+  cmark_strbuf_free(&parser->curline);
+
+#if CMARK_DEBUG_NODES
+  if (cmark_node_check(parser->root, stderr)) {
+    abort();
+  }
+#endif
+  return parser->root;
+}
diff --git a/cmark/src/buffer.c b/cmark/src/buffer.c
new file mode 100644
index 0000000000..f3159948ce
--- /dev/null
+++ b/cmark/src/buffer.c
@@ -0,0 +1,209 @@
+#include <assert.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmark_ctype.h"
+#include "buffer.h"
+
+/* Used as default value for cmark_strbuf->ptr so that people can always
+ * assume ptr is non-NULL and zero terminated even for new cmark_strbufs.
+ */
+unsigned char cmark_strbuf__initbuf[1];
+
+#ifndef MIN
+#define MIN(x, y) ((x < y) ? x : y)
+#endif
+
+void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf,
+                       bufsize_t initial_size) {
+  buf->mem = mem;
+  buf->asize = 0;
+  buf->size = 0;
+  buf->ptr = cmark_strbuf__initbuf;
+
+  if (initial_size > 0)
+    cmark_strbuf_grow(buf, initial_size);
+}
+
+static inline void S_strbuf_grow_by(cmark_strbuf *buf, bufsize_t add) {
+  cmark_strbuf_grow(buf, buf->size + add);
+}
+
+void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) {
+  assert(target_size > 0);
+
+  if (target_size < buf->asize)
+    return;
+
+  if (target_size > (bufsize_t)(INT32_MAX / 2)) {
+    fprintf(stderr,
+      "[cmark] cmark_strbuf_grow requests buffer with size > %d, aborting\n",
+         (INT32_MAX / 2));
+    abort();
+  }
+
+  /* Oversize the buffer by 50% to guarantee amortized linear time
+   * complexity on append operations. */
+  bufsize_t new_size = target_size + target_size / 2;
+  new_size += 1;
+  new_size = (new_size + 7) & ~7;
+
+  buf->ptr = (unsigned char *)buf->mem->realloc(buf->asize ? buf->ptr : NULL,
+                                                new_size);
+  buf->asize = new_size;
+}
+
+void cmark_strbuf_free(cmark_strbuf *buf) {
+  if (!buf)
+    return;
+
+  if (buf->ptr != cmark_strbuf__initbuf)
+    buf->mem->free(buf->ptr);
+
+  cmark_strbuf_init(buf->mem, buf, 0);
+}
+
+void cmark_strbuf_clear(cmark_strbuf *buf) {
+  buf->size = 0;
+
+  if (buf->asize > 0)
+    buf->ptr[0] = '\0';
+}
+
+void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data,
+                      bufsize_t len) {
+  if (len <= 0 || data == NULL) {
+    cmark_strbuf_clear(buf);
+  } else {
+    if (data != buf->ptr) {
+      if (len >= buf->asize)
+        cmark_strbuf_grow(buf, len);
+      memmove(buf->ptr, data, len);
+    }
+    buf->size = len;
+    buf->ptr[buf->size] = '\0';
+  }
+}
+
+void cmark_strbuf_putc(cmark_strbuf *buf, int c) {
+  S_strbuf_grow_by(buf, 1);
+  buf->ptr[buf->size++] = (unsigned char)(c & 0xFF);
+  buf->ptr[buf->size] = '\0';
+}
+
+void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
+                      bufsize_t len) {
+  if (len <= 0)
+    return;
+
+  S_strbuf_grow_by(buf, len);
+  memmove(buf->ptr + buf->size, data, len);
+  buf->size += len;
+  buf->ptr[buf->size] = '\0';
+}
+
+void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) {
+  cmark_strbuf_put(buf, (const unsigned char *)string, (bufsize_t)strlen(string));
+}
+
+unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) {
+  unsigned char *data = buf->ptr;
+
+  if (buf->asize == 0) {
+    /* return an empty string */
+    return (unsigned char *)buf->mem->calloc(1, 1);
+  }
+
+  cmark_strbuf_init(buf->mem, buf, 0);
+  return data;
+}
+
+void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len) {
+  if (len < 0)
+    len = 0;
+
+  if (len < buf->size) {
+    buf->size = len;
+    buf->ptr[buf->size] = '\0';
+  }
+}
+
+void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n) {
+  if (n > 0) {
+    if (n > buf->size)
+      n = buf->size;
+    buf->size = buf->size - n;
+    if (buf->size)
+      memmove(buf->ptr, buf->ptr + n, buf->size);
+
+    buf->ptr[buf->size] = '\0';
+  }
+}
+
+void cmark_strbuf_rtrim(cmark_strbuf *buf) {
+  if (!buf->size)
+    return;
+
+  while (buf->size > 0) {
+    if (!cmark_isspace(buf->ptr[buf->size - 1]))
+      break;
+
+    buf->size--;
+  }
+
+  buf->ptr[buf->size] = '\0';
+}
+
+void cmark_strbuf_trim(cmark_strbuf *buf) {
+  bufsize_t i = 0;
+
+  if (!buf->size)
+    return;
+
+  while (i < buf->size && cmark_isspace(buf->ptr[i]))
+    i++;
+
+  cmark_strbuf_drop(buf, i);
+
+  cmark_strbuf_rtrim(buf);
+}
+
+// Destructively modify string, collapsing consecutive
+// space and newline characters into a single space.
+void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) {
+  bool last_char_was_space = false;
+  bufsize_t r, w;
+
+  for (r = 0, w = 0; r < s->size; ++r) {
+    if (cmark_isspace(s->ptr[r])) {
+      if (!last_char_was_space) {
+        s->ptr[w++] = ' ';
+        last_char_was_space = true;
+      }
+    } else {
+      s->ptr[w++] = s->ptr[r];
+      last_char_was_space = false;
+    }
+  }
+
+  cmark_strbuf_truncate(s, w);
+}
+
+// Destructively unescape a string: remove backslashes before punctuation chars.
+void cmark_strbuf_unescape(cmark_strbuf *buf) {
+  bufsize_t r, w;
+
+  for (r = 0, w = 0; r < buf->size; ++r) {
+    if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1]))
+      r++;
+
+    buf->ptr[w++] = buf->ptr[r];
+  }
+
+  cmark_strbuf_truncate(buf, w);
+}
diff --git a/cmark/src/buffer.h b/cmark/src/buffer.h
new file mode 100644
index 0000000000..e6a085724c
--- /dev/null
+++ b/cmark/src/buffer.h
@@ -0,0 +1,74 @@
+#ifndef CMARK_BUFFER_H
+#define CMARK_BUFFER_H
+
+#include <limits.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "cmark.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef int32_t bufsize_t;
+
+typedef struct {
+  cmark_mem *mem;
+  unsigned char *ptr;
+  bufsize_t asize, size;
+} cmark_strbuf;
+
+extern unsigned char cmark_strbuf__initbuf[];
+
+#define CMARK_BUF_INIT(mem)                                                    \
+  { mem, cmark_strbuf__initbuf, 0, 0 }
+
+/**
+ * Initialize a cmark_strbuf structure.
+ *
+ * For the cases where CMARK_BUF_INIT cannot be used to do static
+ * initialization.
+ */
+void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf,
+                       bufsize_t initial_size);
+
+/**
+ * Grow the buffer to hold at least `target_size` bytes.
+ */
+void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size);
+
+void cmark_strbuf_free(cmark_strbuf *buf);
+
+unsigned char *cmark_strbuf_detach(cmark_strbuf *buf);
+
+/*
+static inline const char *cmark_strbuf_cstr(const cmark_strbuf *buf) {
+ return (char *)buf->ptr;
+}
+*/
+
+#define cmark_strbuf_at(buf, n) ((buf)->ptr[n])
+
+void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data,
+                      bufsize_t len);
+void cmark_strbuf_putc(cmark_strbuf *buf, int c);
+void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
+                      bufsize_t len);
+void cmark_strbuf_puts(cmark_strbuf *buf, const char *string);
+void cmark_strbuf_clear(cmark_strbuf *buf);
+
+void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n);
+void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len);
+void cmark_strbuf_rtrim(cmark_strbuf *buf);
+void cmark_strbuf_trim(cmark_strbuf *buf);
+void cmark_strbuf_normalize_whitespace(cmark_strbuf *s);
+void cmark_strbuf_unescape(cmark_strbuf *s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/case_fold.inc b/cmark/src/case_fold.inc
new file mode 100644
index 0000000000..b309d3e24f
--- /dev/null
+++ b/cmark/src/case_fold.inc
@@ -0,0 +1,722 @@
+// Generated by tools/make_case_fold_inc.py
+
+#define CF_MAX            (1 << 17)
+#define CF_TABLE_SIZE     1559
+#define CF_CODE_POINT(x)  ((x) & 0x1FFFF)
+#define CF_REPL_IDX(x)    ((((x) >> 17) & 0xFFF) * 2)
+#define CF_REPL_SIZE(x)   ((x) >> 29)
+
+static const uint32_t cf_table[1559] = {
+  0x400000B5, 0x400200C0, 0x400400C1, 0x400600C2, 0x400800C3, 0x400A00C4,
+  0x400C00C5, 0x400E00C6, 0x401000C7, 0x401200C8, 0x401400C9, 0x401600CA,
+  0x401800CB, 0x401A00CC, 0x401C00CD, 0x401E00CE, 0x402000CF, 0x402200D0,
+  0x402400D1, 0x402600D2, 0x402800D3, 0x402A00D4, 0x402C00D5, 0x402E00D6,
+  0x403000D8, 0x403200D9, 0x403400DA, 0x403600DB, 0x403800DC, 0x403A00DD,
+  0x403C00DE, 0x403E00DF, 0x40400100, 0x40420102, 0x40440104, 0x40460106,
+  0x40480108, 0x404A010A, 0x404C010C, 0x404E010E, 0x40500110, 0x40520112,
+  0x40540114, 0x40560116, 0x40580118, 0x405A011A, 0x405C011C, 0x405E011E,
+  0x40600120, 0x40620122, 0x40640124, 0x40660126, 0x40680128, 0x406A012A,
+  0x406C012C, 0x406E012E, 0x60700130, 0x40740132, 0x40760134, 0x40780136,
+  0x407A0139, 0x407C013B, 0x407E013D, 0x4080013F, 0x40820141, 0x40840143,
+  0x40860145, 0x40880147, 0x608A0149, 0x408E014A, 0x4090014C, 0x4092014E,
+  0x40940150, 0x40960152, 0x40980154, 0x409A0156, 0x409C0158, 0x409E015A,
+  0x40A0015C, 0x40A2015E, 0x40A40160, 0x40A60162, 0x40A80164, 0x40AA0166,
+  0x40AC0168, 0x40AE016A, 0x40B0016C, 0x40B2016E, 0x40B40170, 0x40B60172,
+  0x40B80174, 0x40BA0176, 0x40BC0178, 0x40BE0179, 0x40C0017B, 0x40C2017D,
+  0x20C4017F, 0x40C60181, 0x40C80182, 0x40CA0184, 0x40CC0186, 0x40CE0187,
+  0x40D00189, 0x40D2018A, 0x40D4018B, 0x40D6018E, 0x40D8018F, 0x40DA0190,
+  0x40DC0191, 0x40DE0193, 0x40E00194, 0x40E20196, 0x40E40197, 0x40E60198,
+  0x40E8019C, 0x40EA019D, 0x40EC019F, 0x40EE01A0, 0x40F001A2, 0x40F201A4,
+  0x40F401A6, 0x40F601A7, 0x40F801A9, 0x40FA01AC, 0x40FC01AE, 0x40FE01AF,
+  0x410001B1, 0x410201B2, 0x410401B3, 0x410601B5, 0x410801B7, 0x410A01B8,
+  0x410C01BC, 0x410E01C4, 0x411001C5, 0x411201C7, 0x411401C8, 0x411601CA,
+  0x411801CB, 0x411A01CD, 0x411C01CF, 0x411E01D1, 0x412001D3, 0x412201D5,
+  0x412401D7, 0x412601D9, 0x412801DB, 0x412A01DE, 0x412C01E0, 0x412E01E2,
+  0x413001E4, 0x413201E6, 0x413401E8, 0x413601EA, 0x413801EC, 0x413A01EE,
+  0x613C01F0, 0x414001F1, 0x414201F2, 0x414401F4, 0x414601F6, 0x414801F7,
+  0x414A01F8, 0x414C01FA, 0x414E01FC, 0x415001FE, 0x41520200, 0x41540202,
+  0x41560204, 0x41580206, 0x415A0208, 0x415C020A, 0x415E020C, 0x4160020E,
+  0x41620210, 0x41640212, 0x41660214, 0x41680216, 0x416A0218, 0x416C021A,
+  0x416E021C, 0x4170021E, 0x41720220, 0x41740222, 0x41760224, 0x41780226,
+  0x417A0228, 0x417C022A, 0x417E022C, 0x4180022E, 0x41820230, 0x41840232,
+  0x6186023A, 0x418A023B, 0x418C023D, 0x618E023E, 0x41920241, 0x41940243,
+  0x41960244, 0x41980245, 0x419A0246, 0x419C0248, 0x419E024A, 0x41A0024C,
+  0x41A2024E, 0x41A40345, 0x41A60370, 0x41A80372, 0x41AA0376, 0x41AC037F,
+  0x41AE0386, 0x41B00388, 0x41B20389, 0x41B4038A, 0x41B6038C, 0x41B8038E,
+  0x41BA038F, 0xC1BC0390, 0x41C20391, 0x41C40392, 0x41C60393, 0x41C80394,
+  0x41CA0395, 0x41CC0396, 0x41CE0397, 0x41D00398, 0x41D20399, 0x41D4039A,
+  0x41D6039B, 0x41D8039C, 0x41DA039D, 0x41DC039E, 0x41DE039F, 0x41E003A0,
+  0x41E203A1, 0x41E403A3, 0x41E603A4, 0x41E803A5, 0x41EA03A6, 0x41EC03A7,
+  0x41EE03A8, 0x41F003A9, 0x41F203AA, 0x41F403AB, 0xC1F603B0, 0x41FC03C2,
+  0x41FE03CF, 0x420003D0, 0x420203D1, 0x420403D5, 0x420603D6, 0x420803D8,
+  0x420A03DA, 0x420C03DC, 0x420E03DE, 0x421003E0, 0x421203E2, 0x421403E4,
+  0x421603E6, 0x421803E8, 0x421A03EA, 0x421C03EC, 0x421E03EE, 0x422003F0,
+  0x422203F1, 0x422403F4, 0x422603F5, 0x422803F7, 0x422A03F9, 0x422C03FA,
+  0x422E03FD, 0x423003FE, 0x423203FF, 0x42340400, 0x42360401, 0x42380402,
+  0x423A0403, 0x423C0404, 0x423E0405, 0x42400406, 0x42420407, 0x42440408,
+  0x42460409, 0x4248040A, 0x424A040B, 0x424C040C, 0x424E040D, 0x4250040E,
+  0x4252040F, 0x42540410, 0x42560411, 0x42580412, 0x425A0413, 0x425C0414,
+  0x425E0415, 0x42600416, 0x42620417, 0x42640418, 0x42660419, 0x4268041A,
+  0x426A041B, 0x426C041C, 0x426E041D, 0x4270041E, 0x4272041F, 0x42740420,
+  0x42760421, 0x42780422, 0x427A0423, 0x427C0424, 0x427E0425, 0x42800426,
+  0x42820427, 0x42840428, 0x42860429, 0x4288042A, 0x428A042B, 0x428C042C,
+  0x428E042D, 0x4290042E, 0x4292042F, 0x42940460, 0x42960462, 0x42980464,
+  0x429A0466, 0x429C0468, 0x429E046A, 0x42A0046C, 0x42A2046E, 0x42A40470,
+  0x42A60472, 0x42A80474, 0x42AA0476, 0x42AC0478, 0x42AE047A, 0x42B0047C,
+  0x42B2047E, 0x42B40480, 0x42B6048A, 0x42B8048C, 0x42BA048E, 0x42BC0490,
+  0x42BE0492, 0x42C00494, 0x42C20496, 0x42C40498, 0x42C6049A, 0x42C8049C,
+  0x42CA049E, 0x42CC04A0, 0x42CE04A2, 0x42D004A4, 0x42D204A6, 0x42D404A8,
+  0x42D604AA, 0x42D804AC, 0x42DA04AE, 0x42DC04B0, 0x42DE04B2, 0x42E004B4,
+  0x42E204B6, 0x42E404B8, 0x42E604BA, 0x42E804BC, 0x42EA04BE, 0x42EC04C0,
+  0x42EE04C1, 0x42F004C3, 0x42F204C5, 0x42F404C7, 0x42F604C9, 0x42F804CB,
+  0x42FA04CD, 0x42FC04D0, 0x42FE04D2, 0x430004D4, 0x430204D6, 0x430404D8,
+  0x430604DA, 0x430804DC, 0x430A04DE, 0x430C04E0, 0x430E04E2, 0x431004E4,
+  0x431204E6, 0x431404E8, 0x431604EA, 0x431804EC, 0x431A04EE, 0x431C04F0,
+  0x431E04F2, 0x432004F4, 0x432204F6, 0x432404F8, 0x432604FA, 0x432804FC,
+  0x432A04FE, 0x432C0500, 0x432E0502, 0x43300504, 0x43320506, 0x43340508,
+  0x4336050A, 0x4338050C, 0x433A050E, 0x433C0510, 0x433E0512, 0x43400514,
+  0x43420516, 0x43440518, 0x4346051A, 0x4348051C, 0x434A051E, 0x434C0520,
+  0x434E0522, 0x43500524, 0x43520526, 0x43540528, 0x4356052A, 0x4358052C,
+  0x435A052E, 0x435C0531, 0x435E0532, 0x43600533, 0x43620534, 0x43640535,
+  0x43660536, 0x43680537, 0x436A0538, 0x436C0539, 0x436E053A, 0x4370053B,
+  0x4372053C, 0x4374053D, 0x4376053E, 0x4378053F, 0x437A0540, 0x437C0541,
+  0x437E0542, 0x43800543, 0x43820544, 0x43840545, 0x43860546, 0x43880547,
+  0x438A0548, 0x438C0549, 0x438E054A, 0x4390054B, 0x4392054C, 0x4394054D,
+  0x4396054E, 0x4398054F, 0x439A0550, 0x439C0551, 0x439E0552, 0x43A00553,
+  0x43A20554, 0x43A40555, 0x43A60556, 0x83A80587, 0x63AC10A0, 0x63B010A1,
+  0x63B410A2, 0x63B810A3, 0x63BC10A4, 0x63C010A5, 0x63C410A6, 0x63C810A7,
+  0x63CC10A8, 0x63D010A9, 0x63D410AA, 0x63D810AB, 0x63DC10AC, 0x63E010AD,
+  0x63E410AE, 0x63E810AF, 0x63EC10B0, 0x63F010B1, 0x63F410B2, 0x63F810B3,
+  0x63FC10B4, 0x640010B5, 0x640410B6, 0x640810B7, 0x640C10B8, 0x641010B9,
+  0x641410BA, 0x641810BB, 0x641C10BC, 0x642010BD, 0x642410BE, 0x642810BF,
+  0x642C10C0, 0x643010C1, 0x643410C2, 0x643810C3, 0x643C10C4, 0x644010C5,
+  0x644410C7, 0x644810CD, 0x644C13F8, 0x645013F9, 0x645413FA, 0x645813FB,
+  0x645C13FC, 0x646013FD, 0x44641C80, 0x44661C81, 0x44681C82, 0x446A1C83,
+  0x446C1C84, 0x446E1C85, 0x44701C86, 0x44721C87, 0x64741C88, 0x64781C89,
+  0x647C1C90, 0x64801C91, 0x64841C92, 0x64881C93, 0x648C1C94, 0x64901C95,
+  0x64941C96, 0x64981C97, 0x649C1C98, 0x64A01C99, 0x64A41C9A, 0x64A81C9B,
+  0x64AC1C9C, 0x64B01C9D, 0x64B41C9E, 0x64B81C9F, 0x64BC1CA0, 0x64C01CA1,
+  0x64C41CA2, 0x64C81CA3, 0x64CC1CA4, 0x64D01CA5, 0x64D41CA6, 0x64D81CA7,
+  0x64DC1CA8, 0x64E01CA9, 0x64E41CAA, 0x64E81CAB, 0x64EC1CAC, 0x64F01CAD,
+  0x64F41CAE, 0x64F81CAF, 0x64FC1CB0, 0x65001CB1, 0x65041CB2, 0x65081CB3,
+  0x650C1CB4, 0x65101CB5, 0x65141CB6, 0x65181CB7, 0x651C1CB8, 0x65201CB9,
+  0x65241CBA, 0x65281CBD, 0x652C1CBE, 0x65301CBF, 0x65341E00, 0x65381E02,
+  0x653C1E04, 0x65401E06, 0x65441E08, 0x65481E0A, 0x654C1E0C, 0x65501E0E,
+  0x65541E10, 0x65581E12, 0x655C1E14, 0x65601E16, 0x65641E18, 0x65681E1A,
+  0x656C1E1C, 0x65701E1E, 0x65741E20, 0x65781E22, 0x657C1E24, 0x65801E26,
+  0x65841E28, 0x65881E2A, 0x658C1E2C, 0x65901E2E, 0x65941E30, 0x65981E32,
+  0x659C1E34, 0x65A01E36, 0x65A41E38, 0x65A81E3A, 0x65AC1E3C, 0x65B01E3E,
+  0x65B41E40, 0x65B81E42, 0x65BC1E44, 0x65C01E46, 0x65C41E48, 0x65C81E4A,
+  0x65CC1E4C, 0x65D01E4E, 0x65D41E50, 0x65D81E52, 0x65DC1E54, 0x65E01E56,
+  0x65E41E58, 0x65E81E5A, 0x65EC1E5C, 0x65F01E5E, 0x65F41E60, 0x65F81E62,
+  0x65FC1E64, 0x66001E66, 0x66041E68, 0x66081E6A, 0x660C1E6C, 0x66101E6E,
+  0x66141E70, 0x66181E72, 0x661C1E74, 0x66201E76, 0x66241E78, 0x66281E7A,
+  0x662C1E7C, 0x66301E7E, 0x66341E80, 0x66381E82, 0x663C1E84, 0x66401E86,
+  0x66441E88, 0x66481E8A, 0x664C1E8C, 0x66501E8E, 0x66541E90, 0x66581E92,
+  0x665C1E94, 0x66601E96, 0x66641E97, 0x66681E98, 0x666C1E99, 0x66701E9A,
+  0x66741E9B, 0x46781E9E, 0x667A1EA0, 0x667E1EA2, 0x66821EA4, 0x66861EA6,
+  0x668A1EA8, 0x668E1EAA, 0x66921EAC, 0x66961EAE, 0x669A1EB0, 0x669E1EB2,
+  0x66A21EB4, 0x66A61EB6, 0x66AA1EB8, 0x66AE1EBA, 0x66B21EBC, 0x66B61EBE,
+  0x66BA1EC0, 0x66BE1EC2, 0x66C21EC4, 0x66C61EC6, 0x66CA1EC8, 0x66CE1ECA,
+  0x66D21ECC, 0x66D61ECE, 0x66DA1ED0, 0x66DE1ED2, 0x66E21ED4, 0x66E61ED6,
+  0x66EA1ED8, 0x66EE1EDA, 0x66F21EDC, 0x66F61EDE, 0x66FA1EE0, 0x66FE1EE2,
+  0x67021EE4, 0x67061EE6, 0x670A1EE8, 0x670E1EEA, 0x67121EEC, 0x67161EEE,
+  0x671A1EF0, 0x671E1EF2, 0x67221EF4, 0x67261EF6, 0x672A1EF8, 0x672E1EFA,
+  0x67321EFC, 0x67361EFE, 0x673A1F08, 0x673E1F09, 0x67421F0A, 0x67461F0B,
+  0x674A1F0C, 0x674E1F0D, 0x67521F0E, 0x67561F0F, 0x675A1F18, 0x675E1F19,
+  0x67621F1A, 0x67661F1B, 0x676A1F1C, 0x676E1F1D, 0x67721F28, 0x67761F29,
+  0x677A1F2A, 0x677E1F2B, 0x67821F2C, 0x67861F2D, 0x678A1F2E, 0x678E1F2F,
+  0x67921F38, 0x67961F39, 0x679A1F3A, 0x679E1F3B, 0x67A21F3C, 0x67A61F3D,
+  0x67AA1F3E, 0x67AE1F3F, 0x67B21F48, 0x67B61F49, 0x67BA1F4A, 0x67BE1F4B,
+  0x67C21F4C, 0x67C61F4D, 0x87CA1F50, 0xC7CE1F52, 0xC7D41F54, 0xC7DA1F56,
+  0x67E01F59, 0x67E41F5B, 0x67E81F5D, 0x67EC1F5F, 0x67F01F68, 0x67F41F69,
+  0x67F81F6A, 0x67FC1F6B, 0x68001F6C, 0x68041F6D, 0x68081F6E, 0x680C1F6F,
+  0xA8101F80, 0xA8161F81, 0xA81C1F82, 0xA8221F83, 0xA8281F84, 0xA82E1F85,
+  0xA8341F86, 0xA83A1F87, 0xA8401F88, 0xA8461F89, 0xA84C1F8A, 0xA8521F8B,
+  0xA8581F8C, 0xA85E1F8D, 0xA8641F8E, 0xA86A1F8F, 0xA8701F90, 0xA8761F91,
+  0xA87C1F92, 0xA8821F93, 0xA8881F94, 0xA88E1F95, 0xA8941F96, 0xA89A1F97,
+  0xA8A01F98, 0xA8A61F99, 0xA8AC1F9A, 0xA8B21F9B, 0xA8B81F9C, 0xA8BE1F9D,
+  0xA8C41F9E, 0xA8CA1F9F, 0xA8D01FA0, 0xA8D61FA1, 0xA8DC1FA2, 0xA8E21FA3,
+  0xA8E81FA4, 0xA8EE1FA5, 0xA8F41FA6, 0xA8FA1FA7, 0xA9001FA8, 0xA9061FA9,
+  0xA90C1FAA, 0xA9121FAB, 0xA9181FAC, 0xA91E1FAD, 0xA9241FAE, 0xA92A1FAF,
+  0xA9301FB2, 0x89361FB3, 0x893A1FB4, 0x893E1FB6, 0xC9421FB7, 0x69481FB8,
+  0x694C1FB9, 0x69501FBA, 0x69541FBB, 0x89581FBC, 0x495C1FBE, 0xA95E1FC2,
+  0x89641FC3, 0x89681FC4, 0x896C1FC6, 0xC9701FC7, 0x69761FC8, 0x697A1FC9,
+  0x697E1FCA, 0x69821FCB, 0x89861FCC, 0xC98A1FD2, 0xC9901FD3, 0x89961FD6,
+  0xC99A1FD7, 0x69A01FD8, 0x69A41FD9, 0x69A81FDA, 0x69AC1FDB, 0xC9B01FE2,
+  0xC9B61FE3, 0x89BC1FE4, 0x89C01FE6, 0xC9C41FE7, 0x69CA1FE8, 0x69CE1FE9,
+  0x69D21FEA, 0x69D61FEB, 0x69DA1FEC, 0xA9DE1FF2, 0x89E41FF3, 0x89E81FF4,
+  0x89EC1FF6, 0xC9F01FF7, 0x69F61FF8, 0x69FA1FF9, 0x69FE1FFA, 0x6A021FFB,
+  0x8A061FFC, 0x4A0A2126, 0x2A0C212A, 0x4A0E212B, 0x6A102132, 0x6A142160,
+  0x6A182161, 0x6A1C2162, 0x6A202163, 0x6A242164, 0x6A282165, 0x6A2C2166,
+  0x6A302167, 0x6A342168, 0x6A382169, 0x6A3C216A, 0x6A40216B, 0x6A44216C,
+  0x6A48216D, 0x6A4C216E, 0x6A50216F, 0x6A542183, 0x6A5824B6, 0x6A5C24B7,
+  0x6A6024B8, 0x6A6424B9, 0x6A6824BA, 0x6A6C24BB, 0x6A7024BC, 0x6A7424BD,
+  0x6A7824BE, 0x6A7C24BF, 0x6A8024C0, 0x6A8424C1, 0x6A8824C2, 0x6A8C24C3,
+  0x6A9024C4, 0x6A9424C5, 0x6A9824C6, 0x6A9C24C7, 0x6AA024C8, 0x6AA424C9,
+  0x6AA824CA, 0x6AAC24CB, 0x6AB024CC, 0x6AB424CD, 0x6AB824CE, 0x6ABC24CF,
+  0x6AC02C00, 0x6AC42C01, 0x6AC82C02, 0x6ACC2C03, 0x6AD02C04, 0x6AD42C05,
+  0x6AD82C06, 0x6ADC2C07, 0x6AE02C08, 0x6AE42C09, 0x6AE82C0A, 0x6AEC2C0B,
+  0x6AF02C0C, 0x6AF42C0D, 0x6AF82C0E, 0x6AFC2C0F, 0x6B002C10, 0x6B042C11,
+  0x6B082C12, 0x6B0C2C13, 0x6B102C14, 0x6B142C15, 0x6B182C16, 0x6B1C2C17,
+  0x6B202C18, 0x6B242C19, 0x6B282C1A, 0x6B2C2C1B, 0x6B302C1C, 0x6B342C1D,
+  0x6B382C1E, 0x6B3C2C1F, 0x6B402C20, 0x6B442C21, 0x6B482C22, 0x6B4C2C23,
+  0x6B502C24, 0x6B542C25, 0x6B582C26, 0x6B5C2C27, 0x6B602C28, 0x6B642C29,
+  0x6B682C2A, 0x6B6C2C2B, 0x6B702C2C, 0x6B742C2D, 0x6B782C2E, 0x6B7C2C2F,
+  0x6B802C60, 0x4B842C62, 0x6B862C63, 0x4B8A2C64, 0x6B8C2C67, 0x6B902C69,
+  0x6B942C6B, 0x4B982C6D, 0x4B9A2C6E, 0x4B9C2C6F, 0x4B9E2C70, 0x6BA02C72,
+  0x6BA42C75, 0x4BA82C7E, 0x4BAA2C7F, 0x6BAC2C80, 0x6BB02C82, 0x6BB42C84,
+  0x6BB82C86, 0x6BBC2C88, 0x6BC02C8A, 0x6BC42C8C, 0x6BC82C8E, 0x6BCC2C90,
+  0x6BD02C92, 0x6BD42C94, 0x6BD82C96, 0x6BDC2C98, 0x6BE02C9A, 0x6BE42C9C,
+  0x6BE82C9E, 0x6BEC2CA0, 0x6BF02CA2, 0x6BF42CA4, 0x6BF82CA6, 0x6BFC2CA8,
+  0x6C002CAA, 0x6C042CAC, 0x6C082CAE, 0x6C0C2CB0, 0x6C102CB2, 0x6C142CB4,
+  0x6C182CB6, 0x6C1C2CB8, 0x6C202CBA, 0x6C242CBC, 0x6C282CBE, 0x6C2C2CC0,
+  0x6C302CC2, 0x6C342CC4, 0x6C382CC6, 0x6C3C2CC8, 0x6C402CCA, 0x6C442CCC,
+  0x6C482CCE, 0x6C4C2CD0, 0x6C502CD2, 0x6C542CD4, 0x6C582CD6, 0x6C5C2CD8,
+  0x6C602CDA, 0x6C642CDC, 0x6C682CDE, 0x6C6C2CE0, 0x6C702CE2, 0x6C742CEB,
+  0x6C782CED, 0x6C7C2CF2, 0x6C80A640, 0x6C84A642, 0x6C88A644, 0x6C8CA646,
+  0x6C90A648, 0x6C94A64A, 0x6C98A64C, 0x6C9CA64E, 0x6CA0A650, 0x6CA4A652,
+  0x6CA8A654, 0x6CACA656, 0x6CB0A658, 0x6CB4A65A, 0x6CB8A65C, 0x6CBCA65E,
+  0x6CC0A660, 0x6CC4A662, 0x6CC8A664, 0x6CCCA666, 0x6CD0A668, 0x6CD4A66A,
+  0x6CD8A66C, 0x6CDCA680, 0x6CE0A682, 0x6CE4A684, 0x6CE8A686, 0x6CECA688,
+  0x6CF0A68A, 0x6CF4A68C, 0x6CF8A68E, 0x6CFCA690, 0x6D00A692, 0x6D04A694,
+  0x6D08A696, 0x6D0CA698, 0x6D10A69A, 0x6D14A722, 0x6D18A724, 0x6D1CA726,
+  0x6D20A728, 0x6D24A72A, 0x6D28A72C, 0x6D2CA72E, 0x6D30A732, 0x6D34A734,
+  0x6D38A736, 0x6D3CA738, 0x6D40A73A, 0x6D44A73C, 0x6D48A73E, 0x6D4CA740,
+  0x6D50A742, 0x6D54A744, 0x6D58A746, 0x6D5CA748, 0x6D60A74A, 0x6D64A74C,
+  0x6D68A74E, 0x6D6CA750, 0x6D70A752, 0x6D74A754, 0x6D78A756, 0x6D7CA758,
+  0x6D80A75A, 0x6D84A75C, 0x6D88A75E, 0x6D8CA760, 0x6D90A762, 0x6D94A764,
+  0x6D98A766, 0x6D9CA768, 0x6DA0A76A, 0x6DA4A76C, 0x6DA8A76E, 0x6DACA779,
+  0x6DB0A77B, 0x6DB4A77D, 0x6DB8A77E, 0x6DBCA780, 0x6DC0A782, 0x6DC4A784,
+  0x6DC8A786, 0x6DCCA78B, 0x4DD0A78D, 0x6DD2A790, 0x6DD6A792, 0x6DDAA796,
+  0x6DDEA798, 0x6DE2A79A, 0x6DE6A79C, 0x6DEAA79E, 0x6DEEA7A0, 0x6DF2A7A2,
+  0x6DF6A7A4, 0x6DFAA7A6, 0x6DFEA7A8, 0x4E02A7AA, 0x4E04A7AB, 0x4E06A7AC,
+  0x4E08A7AD, 0x4E0AA7AE, 0x4E0CA7B0, 0x4E0EA7B1, 0x4E10A7B2, 0x6E12A7B3,
+  0x6E16A7B4, 0x6E1AA7B6, 0x6E1EA7B8, 0x6E22A7BA, 0x6E26A7BC, 0x6E2AA7BE,
+  0x6E2EA7C0, 0x6E32A7C2, 0x6E36A7C4, 0x4E3AA7C5, 0x6E3CA7C6, 0x6E40A7C7,
+  0x6E44A7C9, 0x4E48A7CB, 0x6E4AA7CC, 0x6E4EA7CE, 0x6E52A7D0, 0x6E56A7D2,
+  0x6E5AA7D4, 0x6E5EA7D6, 0x6E62A7D8, 0x6E66A7DA, 0x4E6AA7DC, 0x6E6CA7F5,
+  0x6E70AB70, 0x6E74AB71, 0x6E78AB72, 0x6E7CAB73, 0x6E80AB74, 0x6E84AB75,
+  0x6E88AB76, 0x6E8CAB77, 0x6E90AB78, 0x6E94AB79, 0x6E98AB7A, 0x6E9CAB7B,
+  0x6EA0AB7C, 0x6EA4AB7D, 0x6EA8AB7E, 0x6EACAB7F, 0x6EB0AB80, 0x6EB4AB81,
+  0x6EB8AB82, 0x6EBCAB83, 0x6EC0AB84, 0x6EC4AB85, 0x6EC8AB86, 0x6ECCAB87,
+  0x6ED0AB88, 0x6ED4AB89, 0x6ED8AB8A, 0x6EDCAB8B, 0x6EE0AB8C, 0x6EE4AB8D,
+  0x6EE8AB8E, 0x6EECAB8F, 0x6EF0AB90, 0x6EF4AB91, 0x6EF8AB92, 0x6EFCAB93,
+  0x6F00AB94, 0x6F04AB95, 0x6F08AB96, 0x6F0CAB97, 0x6F10AB98, 0x6F14AB99,
+  0x6F18AB9A, 0x6F1CAB9B, 0x6F20AB9C, 0x6F24AB9D, 0x6F28AB9E, 0x6F2CAB9F,
+  0x6F30ABA0, 0x6F34ABA1, 0x6F38ABA2, 0x6F3CABA3, 0x6F40ABA4, 0x6F44ABA5,
+  0x6F48ABA6, 0x6F4CABA7, 0x6F50ABA8, 0x6F54ABA9, 0x6F58ABAA, 0x6F5CABAB,
+  0x6F60ABAC, 0x6F64ABAD, 0x6F68ABAE, 0x6F6CABAF, 0x6F70ABB0, 0x6F74ABB1,
+  0x6F78ABB2, 0x6F7CABB3, 0x6F80ABB4, 0x6F84ABB5, 0x6F88ABB6, 0x6F8CABB7,
+  0x6F90ABB8, 0x6F94ABB9, 0x6F98ABBA, 0x6F9CABBB, 0x6FA0ABBC, 0x6FA4ABBD,
+  0x6FA8ABBE, 0x6FACABBF, 0x4FB0FB00, 0x4FB2FB01, 0x4FB4FB02, 0x6FB6FB03,
+  0x6FBAFB04, 0x4FBEFB05, 0x4FC0FB06, 0x8FC2FB13, 0x8FC6FB14, 0x8FCAFB15,
+  0x8FCEFB16, 0x8FD2FB17, 0x6FD6FF21, 0x6FDAFF22, 0x6FDEFF23, 0x6FE2FF24,
+  0x6FE6FF25, 0x6FEAFF26, 0x6FEEFF27, 0x6FF2FF28, 0x6FF6FF29, 0x6FFAFF2A,
+  0x6FFEFF2B, 0x7002FF2C, 0x7006FF2D, 0x700AFF2E, 0x700EFF2F, 0x7012FF30,
+  0x7016FF31, 0x701AFF32, 0x701EFF33, 0x7022FF34, 0x7026FF35, 0x702AFF36,
+  0x702EFF37, 0x7032FF38, 0x7036FF39, 0x703AFF3A, 0x903F0400, 0x90430401,
+  0x90470402, 0x904B0403, 0x904F0404, 0x90530405, 0x90570406, 0x905B0407,
+  0x905F0408, 0x90630409, 0x9067040A, 0x906B040B, 0x906F040C, 0x9073040D,
+  0x9077040E, 0x907B040F, 0x907F0410, 0x90830411, 0x90870412, 0x908B0413,
+  0x908F0414, 0x90930415, 0x90970416, 0x909B0417, 0x909F0418, 0x90A30419,
+  0x90A7041A, 0x90AB041B, 0x90AF041C, 0x90B3041D, 0x90B7041E, 0x90BB041F,
+  0x90BF0420, 0x90C30421, 0x90C70422, 0x90CB0423, 0x90CF0424, 0x90D30425,
+  0x90D70426, 0x90DB0427, 0x90DF04B0, 0x90E304B1, 0x90E704B2, 0x90EB04B3,
+  0x90EF04B4, 0x90F304B5, 0x90F704B6, 0x90FB04B7, 0x90FF04B8, 0x910304B9,
+  0x910704BA, 0x910B04BB, 0x910F04BC, 0x911304BD, 0x911704BE, 0x911B04BF,
+  0x911F04C0, 0x912304C1, 0x912704C2, 0x912B04C3, 0x912F04C4, 0x913304C5,
+  0x913704C6, 0x913B04C7, 0x913F04C8, 0x914304C9, 0x914704CA, 0x914B04CB,
+  0x914F04CC, 0x915304CD, 0x915704CE, 0x915B04CF, 0x915F04D0, 0x916304D1,
+  0x916704D2, 0x916B04D3, 0x916F0570, 0x91730571, 0x91770572, 0x917B0573,
+  0x917F0574, 0x91830575, 0x91870576, 0x918B0577, 0x918F0578, 0x91930579,
+  0x9197057A, 0x919B057C, 0x919F057D, 0x91A3057E, 0x91A7057F, 0x91AB0580,
+  0x91AF0581, 0x91B30582, 0x91B70583, 0x91BB0584, 0x91BF0585, 0x91C30586,
+  0x91C70587, 0x91CB0588, 0x91CF0589, 0x91D3058A, 0x91D7058C, 0x91DB058D,
+  0x91DF058E, 0x91E3058F, 0x91E70590, 0x91EB0591, 0x91EF0592, 0x91F30594,
+  0x91F70595, 0x91FB0C80, 0x91FF0C81, 0x92030C82, 0x92070C83, 0x920B0C84,
+  0x920F0C85, 0x92130C86, 0x92170C87, 0x921B0C88, 0x921F0C89, 0x92230C8A,
+  0x92270C8B, 0x922B0C8C, 0x922F0C8D, 0x92330C8E, 0x92370C8F, 0x923B0C90,
+  0x923F0C91, 0x92430C92, 0x92470C93, 0x924B0C94, 0x924F0C95, 0x92530C96,
+  0x92570C97, 0x925B0C98, 0x925F0C99, 0x92630C9A, 0x92670C9B, 0x926B0C9C,
+  0x926F0C9D, 0x92730C9E, 0x92770C9F, 0x927B0CA0, 0x927F0CA1, 0x92830CA2,
+  0x92870CA3, 0x928B0CA4, 0x928F0CA5, 0x92930CA6, 0x92970CA7, 0x929B0CA8,
+  0x929F0CA9, 0x92A30CAA, 0x92A70CAB, 0x92AB0CAC, 0x92AF0CAD, 0x92B30CAE,
+  0x92B70CAF, 0x92BB0CB0, 0x92BF0CB1, 0x92C30CB2, 0x92C70D50, 0x92CB0D51,
+  0x92CF0D52, 0x92D30D53, 0x92D70D54, 0x92DB0D55, 0x92DF0D56, 0x92E30D57,
+  0x92E70D58, 0x92EB0D59, 0x92EF0D5A, 0x92F30D5B, 0x92F70D5C, 0x92FB0D5D,
+  0x92FF0D5E, 0x93030D5F, 0x93070D60, 0x930B0D61, 0x930F0D62, 0x93130D63,
+  0x93170D64, 0x931B0D65, 0x931F18A0, 0x932318A1, 0x932718A2, 0x932B18A3,
+  0x932F18A4, 0x933318A5, 0x933718A6, 0x933B18A7, 0x933F18A8, 0x934318A9,
+  0x934718AA, 0x934B18AB, 0x934F18AC, 0x935318AD, 0x935718AE, 0x935B18AF,
+  0x935F18B0, 0x936318B1, 0x936718B2, 0x936B18B3, 0x936F18B4, 0x937318B5,
+  0x937718B6, 0x937B18B7, 0x937F18B8, 0x938318B9, 0x938718BA, 0x938B18BB,
+  0x938F18BC, 0x939318BD, 0x939718BE, 0x939B18BF, 0x939F6E40, 0x93A36E41,
+  0x93A76E42, 0x93AB6E43, 0x93AF6E44, 0x93B36E45, 0x93B76E46, 0x93BB6E47,
+  0x93BF6E48, 0x93C36E49, 0x93C76E4A, 0x93CB6E4B, 0x93CF6E4C, 0x93D36E4D,
+  0x93D76E4E, 0x93DB6E4F, 0x93DF6E50, 0x93E36E51, 0x93E76E52, 0x93EB6E53,
+  0x93EF6E54, 0x93F36E55, 0x93F76E56, 0x93FB6E57, 0x93FF6E58, 0x94036E59,
+  0x94076E5A, 0x940B6E5B, 0x940F6E5C, 0x94136E5D, 0x94176E5E, 0x941B6E5F,
+  0x941F6EA0, 0x94236EA1, 0x94276EA2, 0x942B6EA3, 0x942F6EA4, 0x94336EA5,
+  0x94376EA6, 0x943B6EA7, 0x943F6EA8, 0x94436EA9, 0x94476EAA, 0x944B6EAB,
+  0x944F6EAC, 0x94536EAD, 0x94576EAE, 0x945B6EAF, 0x945F6EB0, 0x94636EB1,
+  0x94676EB2, 0x946B6EB3, 0x946F6EB4, 0x94736EB5, 0x94776EB6, 0x947B6EB7,
+  0x947F6EB8, 0x9483E900, 0x9487E901, 0x948BE902, 0x948FE903, 0x9493E904,
+  0x9497E905, 0x949BE906, 0x949FE907, 0x94A3E908, 0x94A7E909, 0x94ABE90A,
+  0x94AFE90B, 0x94B3E90C, 0x94B7E90D, 0x94BBE90E, 0x94BFE90F, 0x94C3E910,
+  0x94C7E911, 0x94CBE912, 0x94CFE913, 0x94D3E914, 0x94D7E915, 0x94DBE916,
+  0x94DFE917, 0x94E3E918, 0x94E7E919, 0x94EBE91A, 0x94EFE91B, 0x94F3E91C,
+  0x94F7E91D, 0x94FBE91E, 0x94FFE91F, 0x9503E920, 0x9507E921
+};
+
+static const unsigned char cf_repl[5386] = {
+  0xCE, 0xBC, 0xC3, 0xA0, 0xC3, 0xA1, 0xC3, 0xA2, 0xC3, 0xA3, 0xC3, 0xA4,
+  0xC3, 0xA5, 0xC3, 0xA6, 0xC3, 0xA7, 0xC3, 0xA8, 0xC3, 0xA9, 0xC3, 0xAA,
+  0xC3, 0xAB, 0xC3, 0xAC, 0xC3, 0xAD, 0xC3, 0xAE, 0xC3, 0xAF, 0xC3, 0xB0,
+  0xC3, 0xB1, 0xC3, 0xB2, 0xC3, 0xB3, 0xC3, 0xB4, 0xC3, 0xB5, 0xC3, 0xB6,
+  0xC3, 0xB8, 0xC3, 0xB9, 0xC3, 0xBA, 0xC3, 0xBB, 0xC3, 0xBC, 0xC3, 0xBD,
+  0xC3, 0xBE, 0x73, 0x73, 0xC4, 0x81, 0xC4, 0x83, 0xC4, 0x85, 0xC4, 0x87,
+  0xC4, 0x89, 0xC4, 0x8B, 0xC4, 0x8D, 0xC4, 0x8F, 0xC4, 0x91, 0xC4, 0x93,
+  0xC4, 0x95, 0xC4, 0x97, 0xC4, 0x99, 0xC4, 0x9B, 0xC4, 0x9D, 0xC4, 0x9F,
+  0xC4, 0xA1, 0xC4, 0xA3, 0xC4, 0xA5, 0xC4, 0xA7, 0xC4, 0xA9, 0xC4, 0xAB,
+  0xC4, 0xAD, 0xC4, 0xAF, 0x69, 0xCC, 0x87, 0x00, 0xC4, 0xB3, 0xC4, 0xB5,
+  0xC4, 0xB7, 0xC4, 0xBA, 0xC4, 0xBC, 0xC4, 0xBE, 0xC5, 0x80, 0xC5, 0x82,
+  0xC5, 0x84, 0xC5, 0x86, 0xC5, 0x88, 0xCA, 0xBC, 0x6E, 0x00, 0xC5, 0x8B,
+  0xC5, 0x8D, 0xC5, 0x8F, 0xC5, 0x91, 0xC5, 0x93, 0xC5, 0x95, 0xC5, 0x97,
+  0xC5, 0x99, 0xC5, 0x9B, 0xC5, 0x9D, 0xC5, 0x9F, 0xC5, 0xA1, 0xC5, 0xA3,
+  0xC5, 0xA5, 0xC5, 0xA7, 0xC5, 0xA9, 0xC5, 0xAB, 0xC5, 0xAD, 0xC5, 0xAF,
+  0xC5, 0xB1, 0xC5, 0xB3, 0xC5, 0xB5, 0xC5, 0xB7, 0xC3, 0xBF, 0xC5, 0xBA,
+  0xC5, 0xBC, 0xC5, 0xBE, 0x73, 0x00, 0xC9, 0x93, 0xC6, 0x83, 0xC6, 0x85,
+  0xC9, 0x94, 0xC6, 0x88, 0xC9, 0x96, 0xC9, 0x97, 0xC6, 0x8C, 0xC7, 0x9D,
+  0xC9, 0x99, 0xC9, 0x9B, 0xC6, 0x92, 0xC9, 0xA0, 0xC9, 0xA3, 0xC9, 0xA9,
+  0xC9, 0xA8, 0xC6, 0x99, 0xC9, 0xAF, 0xC9, 0xB2, 0xC9, 0xB5, 0xC6, 0xA1,
+  0xC6, 0xA3, 0xC6, 0xA5, 0xCA, 0x80, 0xC6, 0xA8, 0xCA, 0x83, 0xC6, 0xAD,
+  0xCA, 0x88, 0xC6, 0xB0, 0xCA, 0x8A, 0xCA, 0x8B, 0xC6, 0xB4, 0xC6, 0xB6,
+  0xCA, 0x92, 0xC6, 0xB9, 0xC6, 0xBD, 0xC7, 0x86, 0xC7, 0x86, 0xC7, 0x89,
+  0xC7, 0x89, 0xC7, 0x8C, 0xC7, 0x8C, 0xC7, 0x8E, 0xC7, 0x90, 0xC7, 0x92,
+  0xC7, 0x94, 0xC7, 0x96, 0xC7, 0x98, 0xC7, 0x9A, 0xC7, 0x9C, 0xC7, 0x9F,
+  0xC7, 0xA1, 0xC7, 0xA3, 0xC7, 0xA5, 0xC7, 0xA7, 0xC7, 0xA9, 0xC7, 0xAB,
+  0xC7, 0xAD, 0xC7, 0xAF, 0x6A, 0xCC, 0x8C, 0x00, 0xC7, 0xB3, 0xC7, 0xB3,
+  0xC7, 0xB5, 0xC6, 0x95, 0xC6, 0xBF, 0xC7, 0xB9, 0xC7, 0xBB, 0xC7, 0xBD,
+  0xC7, 0xBF, 0xC8, 0x81, 0xC8, 0x83, 0xC8, 0x85, 0xC8, 0x87, 0xC8, 0x89,
+  0xC8, 0x8B, 0xC8, 0x8D, 0xC8, 0x8F, 0xC8, 0x91, 0xC8, 0x93, 0xC8, 0x95,
+  0xC8, 0x97, 0xC8, 0x99, 0xC8, 0x9B, 0xC8, 0x9D, 0xC8, 0x9F, 0xC6, 0x9E,
+  0xC8, 0xA3, 0xC8, 0xA5, 0xC8, 0xA7, 0xC8, 0xA9, 0xC8, 0xAB, 0xC8, 0xAD,
+  0xC8, 0xAF, 0xC8, 0xB1, 0xC8, 0xB3, 0xE2, 0xB1, 0xA5, 0x00, 0xC8, 0xBC,
+  0xC6, 0x9A, 0xE2, 0xB1, 0xA6, 0x00, 0xC9, 0x82, 0xC6, 0x80, 0xCA, 0x89,
+  0xCA, 0x8C, 0xC9, 0x87, 0xC9, 0x89, 0xC9, 0x8B, 0xC9, 0x8D, 0xC9, 0x8F,
+  0xCE, 0xB9, 0xCD, 0xB1, 0xCD, 0xB3, 0xCD, 0xB7, 0xCF, 0xB3, 0xCE, 0xAC,
+  0xCE, 0xAD, 0xCE, 0xAE, 0xCE, 0xAF, 0xCF, 0x8C, 0xCF, 0x8D, 0xCF, 0x8E,
+  0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x81, 0xCE, 0xB1, 0xCE, 0xB2, 0xCE, 0xB3,
+  0xCE, 0xB4, 0xCE, 0xB5, 0xCE, 0xB6, 0xCE, 0xB7, 0xCE, 0xB8, 0xCE, 0xB9,
+  0xCE, 0xBA, 0xCE, 0xBB, 0xCE, 0xBC, 0xCE, 0xBD, 0xCE, 0xBE, 0xCE, 0xBF,
+  0xCF, 0x80, 0xCF, 0x81, 0xCF, 0x83, 0xCF, 0x84, 0xCF, 0x85, 0xCF, 0x86,
+  0xCF, 0x87, 0xCF, 0x88, 0xCF, 0x89, 0xCF, 0x8A, 0xCF, 0x8B, 0xCF, 0x85,
+  0xCC, 0x88, 0xCC, 0x81, 0xCF, 0x83, 0xCF, 0x97, 0xCE, 0xB2, 0xCE, 0xB8,
+  0xCF, 0x86, 0xCF, 0x80, 0xCF, 0x99, 0xCF, 0x9B, 0xCF, 0x9D, 0xCF, 0x9F,
+  0xCF, 0xA1, 0xCF, 0xA3, 0xCF, 0xA5, 0xCF, 0xA7, 0xCF, 0xA9, 0xCF, 0xAB,
+  0xCF, 0xAD, 0xCF, 0xAF, 0xCE, 0xBA, 0xCF, 0x81, 0xCE, 0xB8, 0xCE, 0xB5,
+  0xCF, 0xB8, 0xCF, 0xB2, 0xCF, 0xBB, 0xCD, 0xBB, 0xCD, 0xBC, 0xCD, 0xBD,
+  0xD1, 0x90, 0xD1, 0x91, 0xD1, 0x92, 0xD1, 0x93, 0xD1, 0x94, 0xD1, 0x95,
+  0xD1, 0x96, 0xD1, 0x97, 0xD1, 0x98, 0xD1, 0x99, 0xD1, 0x9A, 0xD1, 0x9B,
+  0xD1, 0x9C, 0xD1, 0x9D, 0xD1, 0x9E, 0xD1, 0x9F, 0xD0, 0xB0, 0xD0, 0xB1,
+  0xD0, 0xB2, 0xD0, 0xB3, 0xD0, 0xB4, 0xD0, 0xB5, 0xD0, 0xB6, 0xD0, 0xB7,
+  0xD0, 0xB8, 0xD0, 0xB9, 0xD0, 0xBA, 0xD0, 0xBB, 0xD0, 0xBC, 0xD0, 0xBD,
+  0xD0, 0xBE, 0xD0, 0xBF, 0xD1, 0x80, 0xD1, 0x81, 0xD1, 0x82, 0xD1, 0x83,
+  0xD1, 0x84, 0xD1, 0x85, 0xD1, 0x86, 0xD1, 0x87, 0xD1, 0x88, 0xD1, 0x89,
+  0xD1, 0x8A, 0xD1, 0x8B, 0xD1, 0x8C, 0xD1, 0x8D, 0xD1, 0x8E, 0xD1, 0x8F,
+  0xD1, 0xA1, 0xD1, 0xA3, 0xD1, 0xA5, 0xD1, 0xA7, 0xD1, 0xA9, 0xD1, 0xAB,
+  0xD1, 0xAD, 0xD1, 0xAF, 0xD1, 0xB1, 0xD1, 0xB3, 0xD1, 0xB5, 0xD1, 0xB7,
+  0xD1, 0xB9, 0xD1, 0xBB, 0xD1, 0xBD, 0xD1, 0xBF, 0xD2, 0x81, 0xD2, 0x8B,
+  0xD2, 0x8D, 0xD2, 0x8F, 0xD2, 0x91, 0xD2, 0x93, 0xD2, 0x95, 0xD2, 0x97,
+  0xD2, 0x99, 0xD2, 0x9B, 0xD2, 0x9D, 0xD2, 0x9F, 0xD2, 0xA1, 0xD2, 0xA3,
+  0xD2, 0xA5, 0xD2, 0xA7, 0xD2, 0xA9, 0xD2, 0xAB, 0xD2, 0xAD, 0xD2, 0xAF,
+  0xD2, 0xB1, 0xD2, 0xB3, 0xD2, 0xB5, 0xD2, 0xB7, 0xD2, 0xB9, 0xD2, 0xBB,
+  0xD2, 0xBD, 0xD2, 0xBF, 0xD3, 0x8F, 0xD3, 0x82, 0xD3, 0x84, 0xD3, 0x86,
+  0xD3, 0x88, 0xD3, 0x8A, 0xD3, 0x8C, 0xD3, 0x8E, 0xD3, 0x91, 0xD3, 0x93,
+  0xD3, 0x95, 0xD3, 0x97, 0xD3, 0x99, 0xD3, 0x9B, 0xD3, 0x9D, 0xD3, 0x9F,
+  0xD3, 0xA1, 0xD3, 0xA3, 0xD3, 0xA5, 0xD3, 0xA7, 0xD3, 0xA9, 0xD3, 0xAB,
+  0xD3, 0xAD, 0xD3, 0xAF, 0xD3, 0xB1, 0xD3, 0xB3, 0xD3, 0xB5, 0xD3, 0xB7,
+  0xD3, 0xB9, 0xD3, 0xBB, 0xD3, 0xBD, 0xD3, 0xBF, 0xD4, 0x81, 0xD4, 0x83,
+  0xD4, 0x85, 0xD4, 0x87, 0xD4, 0x89, 0xD4, 0x8B, 0xD4, 0x8D, 0xD4, 0x8F,
+  0xD4, 0x91, 0xD4, 0x93, 0xD4, 0x95, 0xD4, 0x97, 0xD4, 0x99, 0xD4, 0x9B,
+  0xD4, 0x9D, 0xD4, 0x9F, 0xD4, 0xA1, 0xD4, 0xA3, 0xD4, 0xA5, 0xD4, 0xA7,
+  0xD4, 0xA9, 0xD4, 0xAB, 0xD4, 0xAD, 0xD4, 0xAF, 0xD5, 0xA1, 0xD5, 0xA2,
+  0xD5, 0xA3, 0xD5, 0xA4, 0xD5, 0xA5, 0xD5, 0xA6, 0xD5, 0xA7, 0xD5, 0xA8,
+  0xD5, 0xA9, 0xD5, 0xAA, 0xD5, 0xAB, 0xD5, 0xAC, 0xD5, 0xAD, 0xD5, 0xAE,
+  0xD5, 0xAF, 0xD5, 0xB0, 0xD5, 0xB1, 0xD5, 0xB2, 0xD5, 0xB3, 0xD5, 0xB4,
+  0xD5, 0xB5, 0xD5, 0xB6, 0xD5, 0xB7, 0xD5, 0xB8, 0xD5, 0xB9, 0xD5, 0xBA,
+  0xD5, 0xBB, 0xD5, 0xBC, 0xD5, 0xBD, 0xD5, 0xBE, 0xD5, 0xBF, 0xD6, 0x80,
+  0xD6, 0x81, 0xD6, 0x82, 0xD6, 0x83, 0xD6, 0x84, 0xD6, 0x85, 0xD6, 0x86,
+  0xD5, 0xA5, 0xD6, 0x82, 0xE2, 0xB4, 0x80, 0x00, 0xE2, 0xB4, 0x81, 0x00,
+  0xE2, 0xB4, 0x82, 0x00, 0xE2, 0xB4, 0x83, 0x00, 0xE2, 0xB4, 0x84, 0x00,
+  0xE2, 0xB4, 0x85, 0x00, 0xE2, 0xB4, 0x86, 0x00, 0xE2, 0xB4, 0x87, 0x00,
+  0xE2, 0xB4, 0x88, 0x00, 0xE2, 0xB4, 0x89, 0x00, 0xE2, 0xB4, 0x8A, 0x00,
+  0xE2, 0xB4, 0x8B, 0x00, 0xE2, 0xB4, 0x8C, 0x00, 0xE2, 0xB4, 0x8D, 0x00,
+  0xE2, 0xB4, 0x8E, 0x00, 0xE2, 0xB4, 0x8F, 0x00, 0xE2, 0xB4, 0x90, 0x00,
+  0xE2, 0xB4, 0x91, 0x00, 0xE2, 0xB4, 0x92, 0x00, 0xE2, 0xB4, 0x93, 0x00,
+  0xE2, 0xB4, 0x94, 0x00, 0xE2, 0xB4, 0x95, 0x00, 0xE2, 0xB4, 0x96, 0x00,
+  0xE2, 0xB4, 0x97, 0x00, 0xE2, 0xB4, 0x98, 0x00, 0xE2, 0xB4, 0x99, 0x00,
+  0xE2, 0xB4, 0x9A, 0x00, 0xE2, 0xB4, 0x9B, 0x00, 0xE2, 0xB4, 0x9C, 0x00,
+  0xE2, 0xB4, 0x9D, 0x00, 0xE2, 0xB4, 0x9E, 0x00, 0xE2, 0xB4, 0x9F, 0x00,
+  0xE2, 0xB4, 0xA0, 0x00, 0xE2, 0xB4, 0xA1, 0x00, 0xE2, 0xB4, 0xA2, 0x00,
+  0xE2, 0xB4, 0xA3, 0x00, 0xE2, 0xB4, 0xA4, 0x00, 0xE2, 0xB4, 0xA5, 0x00,
+  0xE2, 0xB4, 0xA7, 0x00, 0xE2, 0xB4, 0xAD, 0x00, 0xE1, 0x8F, 0xB0, 0x00,
+  0xE1, 0x8F, 0xB1, 0x00, 0xE1, 0x8F, 0xB2, 0x00, 0xE1, 0x8F, 0xB3, 0x00,
+  0xE1, 0x8F, 0xB4, 0x00, 0xE1, 0x8F, 0xB5, 0x00, 0xD0, 0xB2, 0xD0, 0xB4,
+  0xD0, 0xBE, 0xD1, 0x81, 0xD1, 0x82, 0xD1, 0x82, 0xD1, 0x8A, 0xD1, 0xA3,
+  0xEA, 0x99, 0x8B, 0x00, 0xE1, 0xB2, 0x8A, 0x00, 0xE1, 0x83, 0x90, 0x00,
+  0xE1, 0x83, 0x91, 0x00, 0xE1, 0x83, 0x92, 0x00, 0xE1, 0x83, 0x93, 0x00,
+  0xE1, 0x83, 0x94, 0x00, 0xE1, 0x83, 0x95, 0x00, 0xE1, 0x83, 0x96, 0x00,
+  0xE1, 0x83, 0x97, 0x00, 0xE1, 0x83, 0x98, 0x00, 0xE1, 0x83, 0x99, 0x00,
+  0xE1, 0x83, 0x9A, 0x00, 0xE1, 0x83, 0x9B, 0x00, 0xE1, 0x83, 0x9C, 0x00,
+  0xE1, 0x83, 0x9D, 0x00, 0xE1, 0x83, 0x9E, 0x00, 0xE1, 0x83, 0x9F, 0x00,
+  0xE1, 0x83, 0xA0, 0x00, 0xE1, 0x83, 0xA1, 0x00, 0xE1, 0x83, 0xA2, 0x00,
+  0xE1, 0x83, 0xA3, 0x00, 0xE1, 0x83, 0xA4, 0x00, 0xE1, 0x83, 0xA5, 0x00,
+  0xE1, 0x83, 0xA6, 0x00, 0xE1, 0x83, 0xA7, 0x00, 0xE1, 0x83, 0xA8, 0x00,
+  0xE1, 0x83, 0xA9, 0x00, 0xE1, 0x83, 0xAA, 0x00, 0xE1, 0x83, 0xAB, 0x00,
+  0xE1, 0x83, 0xAC, 0x00, 0xE1, 0x83, 0xAD, 0x00, 0xE1, 0x83, 0xAE, 0x00,
+  0xE1, 0x83, 0xAF, 0x00, 0xE1, 0x83, 0xB0, 0x00, 0xE1, 0x83, 0xB1, 0x00,
+  0xE1, 0x83, 0xB2, 0x00, 0xE1, 0x83, 0xB3, 0x00, 0xE1, 0x83, 0xB4, 0x00,
+  0xE1, 0x83, 0xB5, 0x00, 0xE1, 0x83, 0xB6, 0x00, 0xE1, 0x83, 0xB7, 0x00,
+  0xE1, 0x83, 0xB8, 0x00, 0xE1, 0x83, 0xB9, 0x00, 0xE1, 0x83, 0xBA, 0x00,
+  0xE1, 0x83, 0xBD, 0x00, 0xE1, 0x83, 0xBE, 0x00, 0xE1, 0x83, 0xBF, 0x00,
+  0xE1, 0xB8, 0x81, 0x00, 0xE1, 0xB8, 0x83, 0x00, 0xE1, 0xB8, 0x85, 0x00,
+  0xE1, 0xB8, 0x87, 0x00, 0xE1, 0xB8, 0x89, 0x00, 0xE1, 0xB8, 0x8B, 0x00,
+  0xE1, 0xB8, 0x8D, 0x00, 0xE1, 0xB8, 0x8F, 0x00, 0xE1, 0xB8, 0x91, 0x00,
+  0xE1, 0xB8, 0x93, 0x00, 0xE1, 0xB8, 0x95, 0x00, 0xE1, 0xB8, 0x97, 0x00,
+  0xE1, 0xB8, 0x99, 0x00, 0xE1, 0xB8, 0x9B, 0x00, 0xE1, 0xB8, 0x9D, 0x00,
+  0xE1, 0xB8, 0x9F, 0x00, 0xE1, 0xB8, 0xA1, 0x00, 0xE1, 0xB8, 0xA3, 0x00,
+  0xE1, 0xB8, 0xA5, 0x00, 0xE1, 0xB8, 0xA7, 0x00, 0xE1, 0xB8, 0xA9, 0x00,
+  0xE1, 0xB8, 0xAB, 0x00, 0xE1, 0xB8, 0xAD, 0x00, 0xE1, 0xB8, 0xAF, 0x00,
+  0xE1, 0xB8, 0xB1, 0x00, 0xE1, 0xB8, 0xB3, 0x00, 0xE1, 0xB8, 0xB5, 0x00,
+  0xE1, 0xB8, 0xB7, 0x00, 0xE1, 0xB8, 0xB9, 0x00, 0xE1, 0xB8, 0xBB, 0x00,
+  0xE1, 0xB8, 0xBD, 0x00, 0xE1, 0xB8, 0xBF, 0x00, 0xE1, 0xB9, 0x81, 0x00,
+  0xE1, 0xB9, 0x83, 0x00, 0xE1, 0xB9, 0x85, 0x00, 0xE1, 0xB9, 0x87, 0x00,
+  0xE1, 0xB9, 0x89, 0x00, 0xE1, 0xB9, 0x8B, 0x00, 0xE1, 0xB9, 0x8D, 0x00,
+  0xE1, 0xB9, 0x8F, 0x00, 0xE1, 0xB9, 0x91, 0x00, 0xE1, 0xB9, 0x93, 0x00,
+  0xE1, 0xB9, 0x95, 0x00, 0xE1, 0xB9, 0x97, 0x00, 0xE1, 0xB9, 0x99, 0x00,
+  0xE1, 0xB9, 0x9B, 0x00, 0xE1, 0xB9, 0x9D, 0x00, 0xE1, 0xB9, 0x9F, 0x00,
+  0xE1, 0xB9, 0xA1, 0x00, 0xE1, 0xB9, 0xA3, 0x00, 0xE1, 0xB9, 0xA5, 0x00,
+  0xE1, 0xB9, 0xA7, 0x00, 0xE1, 0xB9, 0xA9, 0x00, 0xE1, 0xB9, 0xAB, 0x00,
+  0xE1, 0xB9, 0xAD, 0x00, 0xE1, 0xB9, 0xAF, 0x00, 0xE1, 0xB9, 0xB1, 0x00,
+  0xE1, 0xB9, 0xB3, 0x00, 0xE1, 0xB9, 0xB5, 0x00, 0xE1, 0xB9, 0xB7, 0x00,
+  0xE1, 0xB9, 0xB9, 0x00, 0xE1, 0xB9, 0xBB, 0x00, 0xE1, 0xB9, 0xBD, 0x00,
+  0xE1, 0xB9, 0xBF, 0x00, 0xE1, 0xBA, 0x81, 0x00, 0xE1, 0xBA, 0x83, 0x00,
+  0xE1, 0xBA, 0x85, 0x00, 0xE1, 0xBA, 0x87, 0x00, 0xE1, 0xBA, 0x89, 0x00,
+  0xE1, 0xBA, 0x8B, 0x00, 0xE1, 0xBA, 0x8D, 0x00, 0xE1, 0xBA, 0x8F, 0x00,
+  0xE1, 0xBA, 0x91, 0x00, 0xE1, 0xBA, 0x93, 0x00, 0xE1, 0xBA, 0x95, 0x00,
+  0x68, 0xCC, 0xB1, 0x00, 0x74, 0xCC, 0x88, 0x00, 0x77, 0xCC, 0x8A, 0x00,
+  0x79, 0xCC, 0x8A, 0x00, 0x61, 0xCA, 0xBE, 0x00, 0xE1, 0xB9, 0xA1, 0x00,
+  0x73, 0x73, 0xE1, 0xBA, 0xA1, 0x00, 0xE1, 0xBA, 0xA3, 0x00, 0xE1, 0xBA,
+  0xA5, 0x00, 0xE1, 0xBA, 0xA7, 0x00, 0xE1, 0xBA, 0xA9, 0x00, 0xE1, 0xBA,
+  0xAB, 0x00, 0xE1, 0xBA, 0xAD, 0x00, 0xE1, 0xBA, 0xAF, 0x00, 0xE1, 0xBA,
+  0xB1, 0x00, 0xE1, 0xBA, 0xB3, 0x00, 0xE1, 0xBA, 0xB5, 0x00, 0xE1, 0xBA,
+  0xB7, 0x00, 0xE1, 0xBA, 0xB9, 0x00, 0xE1, 0xBA, 0xBB, 0x00, 0xE1, 0xBA,
+  0xBD, 0x00, 0xE1, 0xBA, 0xBF, 0x00, 0xE1, 0xBB, 0x81, 0x00, 0xE1, 0xBB,
+  0x83, 0x00, 0xE1, 0xBB, 0x85, 0x00, 0xE1, 0xBB, 0x87, 0x00, 0xE1, 0xBB,
+  0x89, 0x00, 0xE1, 0xBB, 0x8B, 0x00, 0xE1, 0xBB, 0x8D, 0x00, 0xE1, 0xBB,
+  0x8F, 0x00, 0xE1, 0xBB, 0x91, 0x00, 0xE1, 0xBB, 0x93, 0x00, 0xE1, 0xBB,
+  0x95, 0x00, 0xE1, 0xBB, 0x97, 0x00, 0xE1, 0xBB, 0x99, 0x00, 0xE1, 0xBB,
+  0x9B, 0x00, 0xE1, 0xBB, 0x9D, 0x00, 0xE1, 0xBB, 0x9F, 0x00, 0xE1, 0xBB,
+  0xA1, 0x00, 0xE1, 0xBB, 0xA3, 0x00, 0xE1, 0xBB, 0xA5, 0x00, 0xE1, 0xBB,
+  0xA7, 0x00, 0xE1, 0xBB, 0xA9, 0x00, 0xE1, 0xBB, 0xAB, 0x00, 0xE1, 0xBB,
+  0xAD, 0x00, 0xE1, 0xBB, 0xAF, 0x00, 0xE1, 0xBB, 0xB1, 0x00, 0xE1, 0xBB,
+  0xB3, 0x00, 0xE1, 0xBB, 0xB5, 0x00, 0xE1, 0xBB, 0xB7, 0x00, 0xE1, 0xBB,
+  0xB9, 0x00, 0xE1, 0xBB, 0xBB, 0x00, 0xE1, 0xBB, 0xBD, 0x00, 0xE1, 0xBB,
+  0xBF, 0x00, 0xE1, 0xBC, 0x80, 0x00, 0xE1, 0xBC, 0x81, 0x00, 0xE1, 0xBC,
+  0x82, 0x00, 0xE1, 0xBC, 0x83, 0x00, 0xE1, 0xBC, 0x84, 0x00, 0xE1, 0xBC,
+  0x85, 0x00, 0xE1, 0xBC, 0x86, 0x00, 0xE1, 0xBC, 0x87, 0x00, 0xE1, 0xBC,
+  0x90, 0x00, 0xE1, 0xBC, 0x91, 0x00, 0xE1, 0xBC, 0x92, 0x00, 0xE1, 0xBC,
+  0x93, 0x00, 0xE1, 0xBC, 0x94, 0x00, 0xE1, 0xBC, 0x95, 0x00, 0xE1, 0xBC,
+  0xA0, 0x00, 0xE1, 0xBC, 0xA1, 0x00, 0xE1, 0xBC, 0xA2, 0x00, 0xE1, 0xBC,
+  0xA3, 0x00, 0xE1, 0xBC, 0xA4, 0x00, 0xE1, 0xBC, 0xA5, 0x00, 0xE1, 0xBC,
+  0xA6, 0x00, 0xE1, 0xBC, 0xA7, 0x00, 0xE1, 0xBC, 0xB0, 0x00, 0xE1, 0xBC,
+  0xB1, 0x00, 0xE1, 0xBC, 0xB2, 0x00, 0xE1, 0xBC, 0xB3, 0x00, 0xE1, 0xBC,
+  0xB4, 0x00, 0xE1, 0xBC, 0xB5, 0x00, 0xE1, 0xBC, 0xB6, 0x00, 0xE1, 0xBC,
+  0xB7, 0x00, 0xE1, 0xBD, 0x80, 0x00, 0xE1, 0xBD, 0x81, 0x00, 0xE1, 0xBD,
+  0x82, 0x00, 0xE1, 0xBD, 0x83, 0x00, 0xE1, 0xBD, 0x84, 0x00, 0xE1, 0xBD,
+  0x85, 0x00, 0xCF, 0x85, 0xCC, 0x93, 0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x80,
+  0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x81, 0xCF, 0x85, 0xCC, 0x93, 0xCD, 0x82,
+  0xE1, 0xBD, 0x91, 0x00, 0xE1, 0xBD, 0x93, 0x00, 0xE1, 0xBD, 0x95, 0x00,
+  0xE1, 0xBD, 0x97, 0x00, 0xE1, 0xBD, 0xA0, 0x00, 0xE1, 0xBD, 0xA1, 0x00,
+  0xE1, 0xBD, 0xA2, 0x00, 0xE1, 0xBD, 0xA3, 0x00, 0xE1, 0xBD, 0xA4, 0x00,
+  0xE1, 0xBD, 0xA5, 0x00, 0xE1, 0xBD, 0xA6, 0x00, 0xE1, 0xBD, 0xA7, 0x00,
+  0xE1, 0xBC, 0x80, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x81, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0x82, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x83, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0x84, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x85, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0x86, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x87, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0x80, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x81, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0x82, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x83, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0x84, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x85, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0x86, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0x87, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0xA0, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA1, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0xA2, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA3, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0xA4, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA5, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0xA6, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA7, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0xA0, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA1, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0xA2, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA3, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0xA4, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA5, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBC, 0xA6, 0xCE, 0xB9, 0x00, 0xE1, 0xBC, 0xA7, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBD, 0xA0, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA1, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBD, 0xA2, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA3, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBD, 0xA4, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA5, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBD, 0xA6, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA7, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBD, 0xA0, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA1, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBD, 0xA2, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA3, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBD, 0xA4, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA5, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBD, 0xA6, 0xCE, 0xB9, 0x00, 0xE1, 0xBD, 0xA7, 0xCE, 0xB9, 0x00,
+  0xE1, 0xBD, 0xB0, 0xCE, 0xB9, 0x00, 0xCE, 0xB1, 0xCE, 0xB9, 0xCE, 0xAC,
+  0xCE, 0xB9, 0xCE, 0xB1, 0xCD, 0x82, 0xCE, 0xB1, 0xCD, 0x82, 0xCE, 0xB9,
+  0xE1, 0xBE, 0xB0, 0x00, 0xE1, 0xBE, 0xB1, 0x00, 0xE1, 0xBD, 0xB0, 0x00,
+  0xE1, 0xBD, 0xB1, 0x00, 0xCE, 0xB1, 0xCE, 0xB9, 0xCE, 0xB9, 0xE1, 0xBD,
+  0xB4, 0xCE, 0xB9, 0x00, 0xCE, 0xB7, 0xCE, 0xB9, 0xCE, 0xAE, 0xCE, 0xB9,
+  0xCE, 0xB7, 0xCD, 0x82, 0xCE, 0xB7, 0xCD, 0x82, 0xCE, 0xB9, 0xE1, 0xBD,
+  0xB2, 0x00, 0xE1, 0xBD, 0xB3, 0x00, 0xE1, 0xBD, 0xB4, 0x00, 0xE1, 0xBD,
+  0xB5, 0x00, 0xCE, 0xB7, 0xCE, 0xB9, 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x80,
+  0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x81, 0xCE, 0xB9, 0xCD, 0x82, 0xCE, 0xB9,
+  0xCC, 0x88, 0xCD, 0x82, 0xE1, 0xBF, 0x90, 0x00, 0xE1, 0xBF, 0x91, 0x00,
+  0xE1, 0xBD, 0xB6, 0x00, 0xE1, 0xBD, 0xB7, 0x00, 0xCF, 0x85, 0xCC, 0x88,
+  0xCC, 0x80, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x81, 0xCF, 0x81, 0xCC, 0x93,
+  0xCF, 0x85, 0xCD, 0x82, 0xCF, 0x85, 0xCC, 0x88, 0xCD, 0x82, 0xE1, 0xBF,
+  0xA0, 0x00, 0xE1, 0xBF, 0xA1, 0x00, 0xE1, 0xBD, 0xBA, 0x00, 0xE1, 0xBD,
+  0xBB, 0x00, 0xE1, 0xBF, 0xA5, 0x00, 0xE1, 0xBD, 0xBC, 0xCE, 0xB9, 0x00,
+  0xCF, 0x89, 0xCE, 0xB9, 0xCF, 0x8E, 0xCE, 0xB9, 0xCF, 0x89, 0xCD, 0x82,
+  0xCF, 0x89, 0xCD, 0x82, 0xCE, 0xB9, 0xE1, 0xBD, 0xB8, 0x00, 0xE1, 0xBD,
+  0xB9, 0x00, 0xE1, 0xBD, 0xBC, 0x00, 0xE1, 0xBD, 0xBD, 0x00, 0xCF, 0x89,
+  0xCE, 0xB9, 0xCF, 0x89, 0x6B, 0x00, 0xC3, 0xA5, 0xE2, 0x85, 0x8E, 0x00,
+  0xE2, 0x85, 0xB0, 0x00, 0xE2, 0x85, 0xB1, 0x00, 0xE2, 0x85, 0xB2, 0x00,
+  0xE2, 0x85, 0xB3, 0x00, 0xE2, 0x85, 0xB4, 0x00, 0xE2, 0x85, 0xB5, 0x00,
+  0xE2, 0x85, 0xB6, 0x00, 0xE2, 0x85, 0xB7, 0x00, 0xE2, 0x85, 0xB8, 0x00,
+  0xE2, 0x85, 0xB9, 0x00, 0xE2, 0x85, 0xBA, 0x00, 0xE2, 0x85, 0xBB, 0x00,
+  0xE2, 0x85, 0xBC, 0x00, 0xE2, 0x85, 0xBD, 0x00, 0xE2, 0x85, 0xBE, 0x00,
+  0xE2, 0x85, 0xBF, 0x00, 0xE2, 0x86, 0x84, 0x00, 0xE2, 0x93, 0x90, 0x00,
+  0xE2, 0x93, 0x91, 0x00, 0xE2, 0x93, 0x92, 0x00, 0xE2, 0x93, 0x93, 0x00,
+  0xE2, 0x93, 0x94, 0x00, 0xE2, 0x93, 0x95, 0x00, 0xE2, 0x93, 0x96, 0x00,
+  0xE2, 0x93, 0x97, 0x00, 0xE2, 0x93, 0x98, 0x00, 0xE2, 0x93, 0x99, 0x00,
+  0xE2, 0x93, 0x9A, 0x00, 0xE2, 0x93, 0x9B, 0x00, 0xE2, 0x93, 0x9C, 0x00,
+  0xE2, 0x93, 0x9D, 0x00, 0xE2, 0x93, 0x9E, 0x00, 0xE2, 0x93, 0x9F, 0x00,
+  0xE2, 0x93, 0xA0, 0x00, 0xE2, 0x93, 0xA1, 0x00, 0xE2, 0x93, 0xA2, 0x00,
+  0xE2, 0x93, 0xA3, 0x00, 0xE2, 0x93, 0xA4, 0x00, 0xE2, 0x93, 0xA5, 0x00,
+  0xE2, 0x93, 0xA6, 0x00, 0xE2, 0x93, 0xA7, 0x00, 0xE2, 0x93, 0xA8, 0x00,
+  0xE2, 0x93, 0xA9, 0x00, 0xE2, 0xB0, 0xB0, 0x00, 0xE2, 0xB0, 0xB1, 0x00,
+  0xE2, 0xB0, 0xB2, 0x00, 0xE2, 0xB0, 0xB3, 0x00, 0xE2, 0xB0, 0xB4, 0x00,
+  0xE2, 0xB0, 0xB5, 0x00, 0xE2, 0xB0, 0xB6, 0x00, 0xE2, 0xB0, 0xB7, 0x00,
+  0xE2, 0xB0, 0xB8, 0x00, 0xE2, 0xB0, 0xB9, 0x00, 0xE2, 0xB0, 0xBA, 0x00,
+  0xE2, 0xB0, 0xBB, 0x00, 0xE2, 0xB0, 0xBC, 0x00, 0xE2, 0xB0, 0xBD, 0x00,
+  0xE2, 0xB0, 0xBE, 0x00, 0xE2, 0xB0, 0xBF, 0x00, 0xE2, 0xB1, 0x80, 0x00,
+  0xE2, 0xB1, 0x81, 0x00, 0xE2, 0xB1, 0x82, 0x00, 0xE2, 0xB1, 0x83, 0x00,
+  0xE2, 0xB1, 0x84, 0x00, 0xE2, 0xB1, 0x85, 0x00, 0xE2, 0xB1, 0x86, 0x00,
+  0xE2, 0xB1, 0x87, 0x00, 0xE2, 0xB1, 0x88, 0x00, 0xE2, 0xB1, 0x89, 0x00,
+  0xE2, 0xB1, 0x8A, 0x00, 0xE2, 0xB1, 0x8B, 0x00, 0xE2, 0xB1, 0x8C, 0x00,
+  0xE2, 0xB1, 0x8D, 0x00, 0xE2, 0xB1, 0x8E, 0x00, 0xE2, 0xB1, 0x8F, 0x00,
+  0xE2, 0xB1, 0x90, 0x00, 0xE2, 0xB1, 0x91, 0x00, 0xE2, 0xB1, 0x92, 0x00,
+  0xE2, 0xB1, 0x93, 0x00, 0xE2, 0xB1, 0x94, 0x00, 0xE2, 0xB1, 0x95, 0x00,
+  0xE2, 0xB1, 0x96, 0x00, 0xE2, 0xB1, 0x97, 0x00, 0xE2, 0xB1, 0x98, 0x00,
+  0xE2, 0xB1, 0x99, 0x00, 0xE2, 0xB1, 0x9A, 0x00, 0xE2, 0xB1, 0x9B, 0x00,
+  0xE2, 0xB1, 0x9C, 0x00, 0xE2, 0xB1, 0x9D, 0x00, 0xE2, 0xB1, 0x9E, 0x00,
+  0xE2, 0xB1, 0x9F, 0x00, 0xE2, 0xB1, 0xA1, 0x00, 0xC9, 0xAB, 0xE1, 0xB5,
+  0xBD, 0x00, 0xC9, 0xBD, 0xE2, 0xB1, 0xA8, 0x00, 0xE2, 0xB1, 0xAA, 0x00,
+  0xE2, 0xB1, 0xAC, 0x00, 0xC9, 0x91, 0xC9, 0xB1, 0xC9, 0x90, 0xC9, 0x92,
+  0xE2, 0xB1, 0xB3, 0x00, 0xE2, 0xB1, 0xB6, 0x00, 0xC8, 0xBF, 0xC9, 0x80,
+  0xE2, 0xB2, 0x81, 0x00, 0xE2, 0xB2, 0x83, 0x00, 0xE2, 0xB2, 0x85, 0x00,
+  0xE2, 0xB2, 0x87, 0x00, 0xE2, 0xB2, 0x89, 0x00, 0xE2, 0xB2, 0x8B, 0x00,
+  0xE2, 0xB2, 0x8D, 0x00, 0xE2, 0xB2, 0x8F, 0x00, 0xE2, 0xB2, 0x91, 0x00,
+  0xE2, 0xB2, 0x93, 0x00, 0xE2, 0xB2, 0x95, 0x00, 0xE2, 0xB2, 0x97, 0x00,
+  0xE2, 0xB2, 0x99, 0x00, 0xE2, 0xB2, 0x9B, 0x00, 0xE2, 0xB2, 0x9D, 0x00,
+  0xE2, 0xB2, 0x9F, 0x00, 0xE2, 0xB2, 0xA1, 0x00, 0xE2, 0xB2, 0xA3, 0x00,
+  0xE2, 0xB2, 0xA5, 0x00, 0xE2, 0xB2, 0xA7, 0x00, 0xE2, 0xB2, 0xA9, 0x00,
+  0xE2, 0xB2, 0xAB, 0x00, 0xE2, 0xB2, 0xAD, 0x00, 0xE2, 0xB2, 0xAF, 0x00,
+  0xE2, 0xB2, 0xB1, 0x00, 0xE2, 0xB2, 0xB3, 0x00, 0xE2, 0xB2, 0xB5, 0x00,
+  0xE2, 0xB2, 0xB7, 0x00, 0xE2, 0xB2, 0xB9, 0x00, 0xE2, 0xB2, 0xBB, 0x00,
+  0xE2, 0xB2, 0xBD, 0x00, 0xE2, 0xB2, 0xBF, 0x00, 0xE2, 0xB3, 0x81, 0x00,
+  0xE2, 0xB3, 0x83, 0x00, 0xE2, 0xB3, 0x85, 0x00, 0xE2, 0xB3, 0x87, 0x00,
+  0xE2, 0xB3, 0x89, 0x00, 0xE2, 0xB3, 0x8B, 0x00, 0xE2, 0xB3, 0x8D, 0x00,
+  0xE2, 0xB3, 0x8F, 0x00, 0xE2, 0xB3, 0x91, 0x00, 0xE2, 0xB3, 0x93, 0x00,
+  0xE2, 0xB3, 0x95, 0x00, 0xE2, 0xB3, 0x97, 0x00, 0xE2, 0xB3, 0x99, 0x00,
+  0xE2, 0xB3, 0x9B, 0x00, 0xE2, 0xB3, 0x9D, 0x00, 0xE2, 0xB3, 0x9F, 0x00,
+  0xE2, 0xB3, 0xA1, 0x00, 0xE2, 0xB3, 0xA3, 0x00, 0xE2, 0xB3, 0xAC, 0x00,
+  0xE2, 0xB3, 0xAE, 0x00, 0xE2, 0xB3, 0xB3, 0x00, 0xEA, 0x99, 0x81, 0x00,
+  0xEA, 0x99, 0x83, 0x00, 0xEA, 0x99, 0x85, 0x00, 0xEA, 0x99, 0x87, 0x00,
+  0xEA, 0x99, 0x89, 0x00, 0xEA, 0x99, 0x8B, 0x00, 0xEA, 0x99, 0x8D, 0x00,
+  0xEA, 0x99, 0x8F, 0x00, 0xEA, 0x99, 0x91, 0x00, 0xEA, 0x99, 0x93, 0x00,
+  0xEA, 0x99, 0x95, 0x00, 0xEA, 0x99, 0x97, 0x00, 0xEA, 0x99, 0x99, 0x00,
+  0xEA, 0x99, 0x9B, 0x00, 0xEA, 0x99, 0x9D, 0x00, 0xEA, 0x99, 0x9F, 0x00,
+  0xEA, 0x99, 0xA1, 0x00, 0xEA, 0x99, 0xA3, 0x00, 0xEA, 0x99, 0xA5, 0x00,
+  0xEA, 0x99, 0xA7, 0x00, 0xEA, 0x99, 0xA9, 0x00, 0xEA, 0x99, 0xAB, 0x00,
+  0xEA, 0x99, 0xAD, 0x00, 0xEA, 0x9A, 0x81, 0x00, 0xEA, 0x9A, 0x83, 0x00,
+  0xEA, 0x9A, 0x85, 0x00, 0xEA, 0x9A, 0x87, 0x00, 0xEA, 0x9A, 0x89, 0x00,
+  0xEA, 0x9A, 0x8B, 0x00, 0xEA, 0x9A, 0x8D, 0x00, 0xEA, 0x9A, 0x8F, 0x00,
+  0xEA, 0x9A, 0x91, 0x00, 0xEA, 0x9A, 0x93, 0x00, 0xEA, 0x9A, 0x95, 0x00,
+  0xEA, 0x9A, 0x97, 0x00, 0xEA, 0x9A, 0x99, 0x00, 0xEA, 0x9A, 0x9B, 0x00,
+  0xEA, 0x9C, 0xA3, 0x00, 0xEA, 0x9C, 0xA5, 0x00, 0xEA, 0x9C, 0xA7, 0x00,
+  0xEA, 0x9C, 0xA9, 0x00, 0xEA, 0x9C, 0xAB, 0x00, 0xEA, 0x9C, 0xAD, 0x00,
+  0xEA, 0x9C, 0xAF, 0x00, 0xEA, 0x9C, 0xB3, 0x00, 0xEA, 0x9C, 0xB5, 0x00,
+  0xEA, 0x9C, 0xB7, 0x00, 0xEA, 0x9C, 0xB9, 0x00, 0xEA, 0x9C, 0xBB, 0x00,
+  0xEA, 0x9C, 0xBD, 0x00, 0xEA, 0x9C, 0xBF, 0x00, 0xEA, 0x9D, 0x81, 0x00,
+  0xEA, 0x9D, 0x83, 0x00, 0xEA, 0x9D, 0x85, 0x00, 0xEA, 0x9D, 0x87, 0x00,
+  0xEA, 0x9D, 0x89, 0x00, 0xEA, 0x9D, 0x8B, 0x00, 0xEA, 0x9D, 0x8D, 0x00,
+  0xEA, 0x9D, 0x8F, 0x00, 0xEA, 0x9D, 0x91, 0x00, 0xEA, 0x9D, 0x93, 0x00,
+  0xEA, 0x9D, 0x95, 0x00, 0xEA, 0x9D, 0x97, 0x00, 0xEA, 0x9D, 0x99, 0x00,
+  0xEA, 0x9D, 0x9B, 0x00, 0xEA, 0x9D, 0x9D, 0x00, 0xEA, 0x9D, 0x9F, 0x00,
+  0xEA, 0x9D, 0xA1, 0x00, 0xEA, 0x9D, 0xA3, 0x00, 0xEA, 0x9D, 0xA5, 0x00,
+  0xEA, 0x9D, 0xA7, 0x00, 0xEA, 0x9D, 0xA9, 0x00, 0xEA, 0x9D, 0xAB, 0x00,
+  0xEA, 0x9D, 0xAD, 0x00, 0xEA, 0x9D, 0xAF, 0x00, 0xEA, 0x9D, 0xBA, 0x00,
+  0xEA, 0x9D, 0xBC, 0x00, 0xE1, 0xB5, 0xB9, 0x00, 0xEA, 0x9D, 0xBF, 0x00,
+  0xEA, 0x9E, 0x81, 0x00, 0xEA, 0x9E, 0x83, 0x00, 0xEA, 0x9E, 0x85, 0x00,
+  0xEA, 0x9E, 0x87, 0x00, 0xEA, 0x9E, 0x8C, 0x00, 0xC9, 0xA5, 0xEA, 0x9E,
+  0x91, 0x00, 0xEA, 0x9E, 0x93, 0x00, 0xEA, 0x9E, 0x97, 0x00, 0xEA, 0x9E,
+  0x99, 0x00, 0xEA, 0x9E, 0x9B, 0x00, 0xEA, 0x9E, 0x9D, 0x00, 0xEA, 0x9E,
+  0x9F, 0x00, 0xEA, 0x9E, 0xA1, 0x00, 0xEA, 0x9E, 0xA3, 0x00, 0xEA, 0x9E,
+  0xA5, 0x00, 0xEA, 0x9E, 0xA7, 0x00, 0xEA, 0x9E, 0xA9, 0x00, 0xC9, 0xA6,
+  0xC9, 0x9C, 0xC9, 0xA1, 0xC9, 0xAC, 0xC9, 0xAA, 0xCA, 0x9E, 0xCA, 0x87,
+  0xCA, 0x9D, 0xEA, 0xAD, 0x93, 0x00, 0xEA, 0x9E, 0xB5, 0x00, 0xEA, 0x9E,
+  0xB7, 0x00, 0xEA, 0x9E, 0xB9, 0x00, 0xEA, 0x9E, 0xBB, 0x00, 0xEA, 0x9E,
+  0xBD, 0x00, 0xEA, 0x9E, 0xBF, 0x00, 0xEA, 0x9F, 0x81, 0x00, 0xEA, 0x9F,
+  0x83, 0x00, 0xEA, 0x9E, 0x94, 0x00, 0xCA, 0x82, 0xE1, 0xB6, 0x8E, 0x00,
+  0xEA, 0x9F, 0x88, 0x00, 0xEA, 0x9F, 0x8A, 0x00, 0xC9, 0xA4, 0xEA, 0x9F,
+  0x8D, 0x00, 0xEA, 0x9F, 0x8F, 0x00, 0xEA, 0x9F, 0x91, 0x00, 0xEA, 0x9F,
+  0x93, 0x00, 0xEA, 0x9F, 0x95, 0x00, 0xEA, 0x9F, 0x97, 0x00, 0xEA, 0x9F,
+  0x99, 0x00, 0xEA, 0x9F, 0x9B, 0x00, 0xC6, 0x9B, 0xEA, 0x9F, 0xB6, 0x00,
+  0xE1, 0x8E, 0xA0, 0x00, 0xE1, 0x8E, 0xA1, 0x00, 0xE1, 0x8E, 0xA2, 0x00,
+  0xE1, 0x8E, 0xA3, 0x00, 0xE1, 0x8E, 0xA4, 0x00, 0xE1, 0x8E, 0xA5, 0x00,
+  0xE1, 0x8E, 0xA6, 0x00, 0xE1, 0x8E, 0xA7, 0x00, 0xE1, 0x8E, 0xA8, 0x00,
+  0xE1, 0x8E, 0xA9, 0x00, 0xE1, 0x8E, 0xAA, 0x00, 0xE1, 0x8E, 0xAB, 0x00,
+  0xE1, 0x8E, 0xAC, 0x00, 0xE1, 0x8E, 0xAD, 0x00, 0xE1, 0x8E, 0xAE, 0x00,
+  0xE1, 0x8E, 0xAF, 0x00, 0xE1, 0x8E, 0xB0, 0x00, 0xE1, 0x8E, 0xB1, 0x00,
+  0xE1, 0x8E, 0xB2, 0x00, 0xE1, 0x8E, 0xB3, 0x00, 0xE1, 0x8E, 0xB4, 0x00,
+  0xE1, 0x8E, 0xB5, 0x00, 0xE1, 0x8E, 0xB6, 0x00, 0xE1, 0x8E, 0xB7, 0x00,
+  0xE1, 0x8E, 0xB8, 0x00, 0xE1, 0x8E, 0xB9, 0x00, 0xE1, 0x8E, 0xBA, 0x00,
+  0xE1, 0x8E, 0xBB, 0x00, 0xE1, 0x8E, 0xBC, 0x00, 0xE1, 0x8E, 0xBD, 0x00,
+  0xE1, 0x8E, 0xBE, 0x00, 0xE1, 0x8E, 0xBF, 0x00, 0xE1, 0x8F, 0x80, 0x00,
+  0xE1, 0x8F, 0x81, 0x00, 0xE1, 0x8F, 0x82, 0x00, 0xE1, 0x8F, 0x83, 0x00,
+  0xE1, 0x8F, 0x84, 0x00, 0xE1, 0x8F, 0x85, 0x00, 0xE1, 0x8F, 0x86, 0x00,
+  0xE1, 0x8F, 0x87, 0x00, 0xE1, 0x8F, 0x88, 0x00, 0xE1, 0x8F, 0x89, 0x00,
+  0xE1, 0x8F, 0x8A, 0x00, 0xE1, 0x8F, 0x8B, 0x00, 0xE1, 0x8F, 0x8C, 0x00,
+  0xE1, 0x8F, 0x8D, 0x00, 0xE1, 0x8F, 0x8E, 0x00, 0xE1, 0x8F, 0x8F, 0x00,
+  0xE1, 0x8F, 0x90, 0x00, 0xE1, 0x8F, 0x91, 0x00, 0xE1, 0x8F, 0x92, 0x00,
+  0xE1, 0x8F, 0x93, 0x00, 0xE1, 0x8F, 0x94, 0x00, 0xE1, 0x8F, 0x95, 0x00,
+  0xE1, 0x8F, 0x96, 0x00, 0xE1, 0x8F, 0x97, 0x00, 0xE1, 0x8F, 0x98, 0x00,
+  0xE1, 0x8F, 0x99, 0x00, 0xE1, 0x8F, 0x9A, 0x00, 0xE1, 0x8F, 0x9B, 0x00,
+  0xE1, 0x8F, 0x9C, 0x00, 0xE1, 0x8F, 0x9D, 0x00, 0xE1, 0x8F, 0x9E, 0x00,
+  0xE1, 0x8F, 0x9F, 0x00, 0xE1, 0x8F, 0xA0, 0x00, 0xE1, 0x8F, 0xA1, 0x00,
+  0xE1, 0x8F, 0xA2, 0x00, 0xE1, 0x8F, 0xA3, 0x00, 0xE1, 0x8F, 0xA4, 0x00,
+  0xE1, 0x8F, 0xA5, 0x00, 0xE1, 0x8F, 0xA6, 0x00, 0xE1, 0x8F, 0xA7, 0x00,
+  0xE1, 0x8F, 0xA8, 0x00, 0xE1, 0x8F, 0xA9, 0x00, 0xE1, 0x8F, 0xAA, 0x00,
+  0xE1, 0x8F, 0xAB, 0x00, 0xE1, 0x8F, 0xAC, 0x00, 0xE1, 0x8F, 0xAD, 0x00,
+  0xE1, 0x8F, 0xAE, 0x00, 0xE1, 0x8F, 0xAF, 0x00, 0x66, 0x66, 0x66, 0x69,
+  0x66, 0x6C, 0x66, 0x66, 0x69, 0x00, 0x66, 0x66, 0x6C, 0x00, 0x73, 0x74,
+  0x73, 0x74, 0xD5, 0xB4, 0xD5, 0xB6, 0xD5, 0xB4, 0xD5, 0xA5, 0xD5, 0xB4,
+  0xD5, 0xAB, 0xD5, 0xBE, 0xD5, 0xB6, 0xD5, 0xB4, 0xD5, 0xAD, 0xEF, 0xBD,
+  0x81, 0x00, 0xEF, 0xBD, 0x82, 0x00, 0xEF, 0xBD, 0x83, 0x00, 0xEF, 0xBD,
+  0x84, 0x00, 0xEF, 0xBD, 0x85, 0x00, 0xEF, 0xBD, 0x86, 0x00, 0xEF, 0xBD,
+  0x87, 0x00, 0xEF, 0xBD, 0x88, 0x00, 0xEF, 0xBD, 0x89, 0x00, 0xEF, 0xBD,
+  0x8A, 0x00, 0xEF, 0xBD, 0x8B, 0x00, 0xEF, 0xBD, 0x8C, 0x00, 0xEF, 0xBD,
+  0x8D, 0x00, 0xEF, 0xBD, 0x8E, 0x00, 0xEF, 0xBD, 0x8F, 0x00, 0xEF, 0xBD,
+  0x90, 0x00, 0xEF, 0xBD, 0x91, 0x00, 0xEF, 0xBD, 0x92, 0x00, 0xEF, 0xBD,
+  0x93, 0x00, 0xEF, 0xBD, 0x94, 0x00, 0xEF, 0xBD, 0x95, 0x00, 0xEF, 0xBD,
+  0x96, 0x00, 0xEF, 0xBD, 0x97, 0x00, 0xEF, 0xBD, 0x98, 0x00, 0xEF, 0xBD,
+  0x99, 0x00, 0xEF, 0xBD, 0x9A, 0x00, 0xF0, 0x90, 0x90, 0xA8, 0xF0, 0x90,
+  0x90, 0xA9, 0xF0, 0x90, 0x90, 0xAA, 0xF0, 0x90, 0x90, 0xAB, 0xF0, 0x90,
+  0x90, 0xAC, 0xF0, 0x90, 0x90, 0xAD, 0xF0, 0x90, 0x90, 0xAE, 0xF0, 0x90,
+  0x90, 0xAF, 0xF0, 0x90, 0x90, 0xB0, 0xF0, 0x90, 0x90, 0xB1, 0xF0, 0x90,
+  0x90, 0xB2, 0xF0, 0x90, 0x90, 0xB3, 0xF0, 0x90, 0x90, 0xB4, 0xF0, 0x90,
+  0x90, 0xB5, 0xF0, 0x90, 0x90, 0xB6, 0xF0, 0x90, 0x90, 0xB7, 0xF0, 0x90,
+  0x90, 0xB8, 0xF0, 0x90, 0x90, 0xB9, 0xF0, 0x90, 0x90, 0xBA, 0xF0, 0x90,
+  0x90, 0xBB, 0xF0, 0x90, 0x90, 0xBC, 0xF0, 0x90, 0x90, 0xBD, 0xF0, 0x90,
+  0x90, 0xBE, 0xF0, 0x90, 0x90, 0xBF, 0xF0, 0x90, 0x91, 0x80, 0xF0, 0x90,
+  0x91, 0x81, 0xF0, 0x90, 0x91, 0x82, 0xF0, 0x90, 0x91, 0x83, 0xF0, 0x90,
+  0x91, 0x84, 0xF0, 0x90, 0x91, 0x85, 0xF0, 0x90, 0x91, 0x86, 0xF0, 0x90,
+  0x91, 0x87, 0xF0, 0x90, 0x91, 0x88, 0xF0, 0x90, 0x91, 0x89, 0xF0, 0x90,
+  0x91, 0x8A, 0xF0, 0x90, 0x91, 0x8B, 0xF0, 0x90, 0x91, 0x8C, 0xF0, 0x90,
+  0x91, 0x8D, 0xF0, 0x90, 0x91, 0x8E, 0xF0, 0x90, 0x91, 0x8F, 0xF0, 0x90,
+  0x93, 0x98, 0xF0, 0x90, 0x93, 0x99, 0xF0, 0x90, 0x93, 0x9A, 0xF0, 0x90,
+  0x93, 0x9B, 0xF0, 0x90, 0x93, 0x9C, 0xF0, 0x90, 0x93, 0x9D, 0xF0, 0x90,
+  0x93, 0x9E, 0xF0, 0x90, 0x93, 0x9F, 0xF0, 0x90, 0x93, 0xA0, 0xF0, 0x90,
+  0x93, 0xA1, 0xF0, 0x90, 0x93, 0xA2, 0xF0, 0x90, 0x93, 0xA3, 0xF0, 0x90,
+  0x93, 0xA4, 0xF0, 0x90, 0x93, 0xA5, 0xF0, 0x90, 0x93, 0xA6, 0xF0, 0x90,
+  0x93, 0xA7, 0xF0, 0x90, 0x93, 0xA8, 0xF0, 0x90, 0x93, 0xA9, 0xF0, 0x90,
+  0x93, 0xAA, 0xF0, 0x90, 0x93, 0xAB, 0xF0, 0x90, 0x93, 0xAC, 0xF0, 0x90,
+  0x93, 0xAD, 0xF0, 0x90, 0x93, 0xAE, 0xF0, 0x90, 0x93, 0xAF, 0xF0, 0x90,
+  0x93, 0xB0, 0xF0, 0x90, 0x93, 0xB1, 0xF0, 0x90, 0x93, 0xB2, 0xF0, 0x90,
+  0x93, 0xB3, 0xF0, 0x90, 0x93, 0xB4, 0xF0, 0x90, 0x93, 0xB5, 0xF0, 0x90,
+  0x93, 0xB6, 0xF0, 0x90, 0x93, 0xB7, 0xF0, 0x90, 0x93, 0xB8, 0xF0, 0x90,
+  0x93, 0xB9, 0xF0, 0x90, 0x93, 0xBA, 0xF0, 0x90, 0x93, 0xBB, 0xF0, 0x90,
+  0x96, 0x97, 0xF0, 0x90, 0x96, 0x98, 0xF0, 0x90, 0x96, 0x99, 0xF0, 0x90,
+  0x96, 0x9A, 0xF0, 0x90, 0x96, 0x9B, 0xF0, 0x90, 0x96, 0x9C, 0xF0, 0x90,
+  0x96, 0x9D, 0xF0, 0x90, 0x96, 0x9E, 0xF0, 0x90, 0x96, 0x9F, 0xF0, 0x90,
+  0x96, 0xA0, 0xF0, 0x90, 0x96, 0xA1, 0xF0, 0x90, 0x96, 0xA3, 0xF0, 0x90,
+  0x96, 0xA4, 0xF0, 0x90, 0x96, 0xA5, 0xF0, 0x90, 0x96, 0xA6, 0xF0, 0x90,
+  0x96, 0xA7, 0xF0, 0x90, 0x96, 0xA8, 0xF0, 0x90, 0x96, 0xA9, 0xF0, 0x90,
+  0x96, 0xAA, 0xF0, 0x90, 0x96, 0xAB, 0xF0, 0x90, 0x96, 0xAC, 0xF0, 0x90,
+  0x96, 0xAD, 0xF0, 0x90, 0x96, 0xAE, 0xF0, 0x90, 0x96, 0xAF, 0xF0, 0x90,
+  0x96, 0xB0, 0xF0, 0x90, 0x96, 0xB1, 0xF0, 0x90, 0x96, 0xB3, 0xF0, 0x90,
+  0x96, 0xB4, 0xF0, 0x90, 0x96, 0xB5, 0xF0, 0x90, 0x96, 0xB6, 0xF0, 0x90,
+  0x96, 0xB7, 0xF0, 0x90, 0x96, 0xB8, 0xF0, 0x90, 0x96, 0xB9, 0xF0, 0x90,
+  0x96, 0xBB, 0xF0, 0x90, 0x96, 0xBC, 0xF0, 0x90, 0xB3, 0x80, 0xF0, 0x90,
+  0xB3, 0x81, 0xF0, 0x90, 0xB3, 0x82, 0xF0, 0x90, 0xB3, 0x83, 0xF0, 0x90,
+  0xB3, 0x84, 0xF0, 0x90, 0xB3, 0x85, 0xF0, 0x90, 0xB3, 0x86, 0xF0, 0x90,
+  0xB3, 0x87, 0xF0, 0x90, 0xB3, 0x88, 0xF0, 0x90, 0xB3, 0x89, 0xF0, 0x90,
+  0xB3, 0x8A, 0xF0, 0x90, 0xB3, 0x8B, 0xF0, 0x90, 0xB3, 0x8C, 0xF0, 0x90,
+  0xB3, 0x8D, 0xF0, 0x90, 0xB3, 0x8E, 0xF0, 0x90, 0xB3, 0x8F, 0xF0, 0x90,
+  0xB3, 0x90, 0xF0, 0x90, 0xB3, 0x91, 0xF0, 0x90, 0xB3, 0x92, 0xF0, 0x90,
+  0xB3, 0x93, 0xF0, 0x90, 0xB3, 0x94, 0xF0, 0x90, 0xB3, 0x95, 0xF0, 0x90,
+  0xB3, 0x96, 0xF0, 0x90, 0xB3, 0x97, 0xF0, 0x90, 0xB3, 0x98, 0xF0, 0x90,
+  0xB3, 0x99, 0xF0, 0x90, 0xB3, 0x9A, 0xF0, 0x90, 0xB3, 0x9B, 0xF0, 0x90,
+  0xB3, 0x9C, 0xF0, 0x90, 0xB3, 0x9D, 0xF0, 0x90, 0xB3, 0x9E, 0xF0, 0x90,
+  0xB3, 0x9F, 0xF0, 0x90, 0xB3, 0xA0, 0xF0, 0x90, 0xB3, 0xA1, 0xF0, 0x90,
+  0xB3, 0xA2, 0xF0, 0x90, 0xB3, 0xA3, 0xF0, 0x90, 0xB3, 0xA4, 0xF0, 0x90,
+  0xB3, 0xA5, 0xF0, 0x90, 0xB3, 0xA6, 0xF0, 0x90, 0xB3, 0xA7, 0xF0, 0x90,
+  0xB3, 0xA8, 0xF0, 0x90, 0xB3, 0xA9, 0xF0, 0x90, 0xB3, 0xAA, 0xF0, 0x90,
+  0xB3, 0xAB, 0xF0, 0x90, 0xB3, 0xAC, 0xF0, 0x90, 0xB3, 0xAD, 0xF0, 0x90,
+  0xB3, 0xAE, 0xF0, 0x90, 0xB3, 0xAF, 0xF0, 0x90, 0xB3, 0xB0, 0xF0, 0x90,
+  0xB3, 0xB1, 0xF0, 0x90, 0xB3, 0xB2, 0xF0, 0x90, 0xB5, 0xB0, 0xF0, 0x90,
+  0xB5, 0xB1, 0xF0, 0x90, 0xB5, 0xB2, 0xF0, 0x90, 0xB5, 0xB3, 0xF0, 0x90,
+  0xB5, 0xB4, 0xF0, 0x90, 0xB5, 0xB5, 0xF0, 0x90, 0xB5, 0xB6, 0xF0, 0x90,
+  0xB5, 0xB7, 0xF0, 0x90, 0xB5, 0xB8, 0xF0, 0x90, 0xB5, 0xB9, 0xF0, 0x90,
+  0xB5, 0xBA, 0xF0, 0x90, 0xB5, 0xBB, 0xF0, 0x90, 0xB5, 0xBC, 0xF0, 0x90,
+  0xB5, 0xBD, 0xF0, 0x90, 0xB5, 0xBE, 0xF0, 0x90, 0xB5, 0xBF, 0xF0, 0x90,
+  0xB6, 0x80, 0xF0, 0x90, 0xB6, 0x81, 0xF0, 0x90, 0xB6, 0x82, 0xF0, 0x90,
+  0xB6, 0x83, 0xF0, 0x90, 0xB6, 0x84, 0xF0, 0x90, 0xB6, 0x85, 0xF0, 0x91,
+  0xA3, 0x80, 0xF0, 0x91, 0xA3, 0x81, 0xF0, 0x91, 0xA3, 0x82, 0xF0, 0x91,
+  0xA3, 0x83, 0xF0, 0x91, 0xA3, 0x84, 0xF0, 0x91, 0xA3, 0x85, 0xF0, 0x91,
+  0xA3, 0x86, 0xF0, 0x91, 0xA3, 0x87, 0xF0, 0x91, 0xA3, 0x88, 0xF0, 0x91,
+  0xA3, 0x89, 0xF0, 0x91, 0xA3, 0x8A, 0xF0, 0x91, 0xA3, 0x8B, 0xF0, 0x91,
+  0xA3, 0x8C, 0xF0, 0x91, 0xA3, 0x8D, 0xF0, 0x91, 0xA3, 0x8E, 0xF0, 0x91,
+  0xA3, 0x8F, 0xF0, 0x91, 0xA3, 0x90, 0xF0, 0x91, 0xA3, 0x91, 0xF0, 0x91,
+  0xA3, 0x92, 0xF0, 0x91, 0xA3, 0x93, 0xF0, 0x91, 0xA3, 0x94, 0xF0, 0x91,
+  0xA3, 0x95, 0xF0, 0x91, 0xA3, 0x96, 0xF0, 0x91, 0xA3, 0x97, 0xF0, 0x91,
+  0xA3, 0x98, 0xF0, 0x91, 0xA3, 0x99, 0xF0, 0x91, 0xA3, 0x9A, 0xF0, 0x91,
+  0xA3, 0x9B, 0xF0, 0x91, 0xA3, 0x9C, 0xF0, 0x91, 0xA3, 0x9D, 0xF0, 0x91,
+  0xA3, 0x9E, 0xF0, 0x91, 0xA3, 0x9F, 0xF0, 0x96, 0xB9, 0xA0, 0xF0, 0x96,
+  0xB9, 0xA1, 0xF0, 0x96, 0xB9, 0xA2, 0xF0, 0x96, 0xB9, 0xA3, 0xF0, 0x96,
+  0xB9, 0xA4, 0xF0, 0x96, 0xB9, 0xA5, 0xF0, 0x96, 0xB9, 0xA6, 0xF0, 0x96,
+  0xB9, 0xA7, 0xF0, 0x96, 0xB9, 0xA8, 0xF0, 0x96, 0xB9, 0xA9, 0xF0, 0x96,
+  0xB9, 0xAA, 0xF0, 0x96, 0xB9, 0xAB, 0xF0, 0x96, 0xB9, 0xAC, 0xF0, 0x96,
+  0xB9, 0xAD, 0xF0, 0x96, 0xB9, 0xAE, 0xF0, 0x96, 0xB9, 0xAF, 0xF0, 0x96,
+  0xB9, 0xB0, 0xF0, 0x96, 0xB9, 0xB1, 0xF0, 0x96, 0xB9, 0xB2, 0xF0, 0x96,
+  0xB9, 0xB3, 0xF0, 0x96, 0xB9, 0xB4, 0xF0, 0x96, 0xB9, 0xB5, 0xF0, 0x96,
+  0xB9, 0xB6, 0xF0, 0x96, 0xB9, 0xB7, 0xF0, 0x96, 0xB9, 0xB8, 0xF0, 0x96,
+  0xB9, 0xB9, 0xF0, 0x96, 0xB9, 0xBA, 0xF0, 0x96, 0xB9, 0xBB, 0xF0, 0x96,
+  0xB9, 0xBC, 0xF0, 0x96, 0xB9, 0xBD, 0xF0, 0x96, 0xB9, 0xBE, 0xF0, 0x96,
+  0xB9, 0xBF, 0xF0, 0x96, 0xBA, 0xBB, 0xF0, 0x96, 0xBA, 0xBC, 0xF0, 0x96,
+  0xBA, 0xBD, 0xF0, 0x96, 0xBA, 0xBE, 0xF0, 0x96, 0xBA, 0xBF, 0xF0, 0x96,
+  0xBB, 0x80, 0xF0, 0x96, 0xBB, 0x81, 0xF0, 0x96, 0xBB, 0x82, 0xF0, 0x96,
+  0xBB, 0x83, 0xF0, 0x96, 0xBB, 0x84, 0xF0, 0x96, 0xBB, 0x85, 0xF0, 0x96,
+  0xBB, 0x86, 0xF0, 0x96, 0xBB, 0x87, 0xF0, 0x96, 0xBB, 0x88, 0xF0, 0x96,
+  0xBB, 0x89, 0xF0, 0x96, 0xBB, 0x8A, 0xF0, 0x96, 0xBB, 0x8B, 0xF0, 0x96,
+  0xBB, 0x8C, 0xF0, 0x96, 0xBB, 0x8D, 0xF0, 0x96, 0xBB, 0x8E, 0xF0, 0x96,
+  0xBB, 0x8F, 0xF0, 0x96, 0xBB, 0x90, 0xF0, 0x96, 0xBB, 0x91, 0xF0, 0x96,
+  0xBB, 0x92, 0xF0, 0x96, 0xBB, 0x93, 0xF0, 0x9E, 0xA4, 0xA2, 0xF0, 0x9E,
+  0xA4, 0xA3, 0xF0, 0x9E, 0xA4, 0xA4, 0xF0, 0x9E, 0xA4, 0xA5, 0xF0, 0x9E,
+  0xA4, 0xA6, 0xF0, 0x9E, 0xA4, 0xA7, 0xF0, 0x9E, 0xA4, 0xA8, 0xF0, 0x9E,
+  0xA4, 0xA9, 0xF0, 0x9E, 0xA4, 0xAA, 0xF0, 0x9E, 0xA4, 0xAB, 0xF0, 0x9E,
+  0xA4, 0xAC, 0xF0, 0x9E, 0xA4, 0xAD, 0xF0, 0x9E, 0xA4, 0xAE, 0xF0, 0x9E,
+  0xA4, 0xAF, 0xF0, 0x9E, 0xA4, 0xB0, 0xF0, 0x9E, 0xA4, 0xB1, 0xF0, 0x9E,
+  0xA4, 0xB2, 0xF0, 0x9E, 0xA4, 0xB3, 0xF0, 0x9E, 0xA4, 0xB4, 0xF0, 0x9E,
+  0xA4, 0xB5, 0xF0, 0x9E, 0xA4, 0xB6, 0xF0, 0x9E, 0xA4, 0xB7, 0xF0, 0x9E,
+  0xA4, 0xB8, 0xF0, 0x9E, 0xA4, 0xB9, 0xF0, 0x9E, 0xA4, 0xBA, 0xF0, 0x9E,
+  0xA4, 0xBB, 0xF0, 0x9E, 0xA4, 0xBC, 0xF0, 0x9E, 0xA4, 0xBD, 0xF0, 0x9E,
+  0xA4, 0xBE, 0xF0, 0x9E, 0xA4, 0xBF, 0xF0, 0x9E, 0xA5, 0x80, 0xF0, 0x9E,
+  0xA5, 0x81, 0xF0, 0x9E, 0xA5, 0x82, 0xF0, 0x9E, 0xA5, 0x83
+};
diff --git a/cmark/src/chunk.h b/cmark/src/chunk.h
new file mode 100644
index 0000000000..54c28f8b82
--- /dev/null
+++ b/cmark/src/chunk.h
@@ -0,0 +1,69 @@
+#ifndef CMARK_CHUNK_H
+#define CMARK_CHUNK_H
+
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "cmark.h"
+#include "buffer.h"
+#include "cmark_ctype.h"
+
+#define CMARK_CHUNK_EMPTY                                                      \
+  { NULL, 0 }
+
+typedef struct {
+  const unsigned char *data;
+  bufsize_t len;
+} cmark_chunk;
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static inline void cmark_chunk_free(cmark_chunk *c) {
+  c->data = NULL;
+  c->len = 0;
+}
+
+static inline void cmark_chunk_ltrim(cmark_chunk *c) {
+  while (c->len && cmark_isspace(c->data[0])) {
+    c->data++;
+    c->len--;
+  }
+}
+
+static inline void cmark_chunk_rtrim(cmark_chunk *c) {
+  while (c->len > 0) {
+    if (!cmark_isspace(c->data[c->len - 1]))
+      break;
+
+    c->len--;
+  }
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static inline void cmark_chunk_trim(cmark_chunk *c) {
+  cmark_chunk_ltrim(c);
+  cmark_chunk_rtrim(c);
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static inline bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c,
+                                           bufsize_t offset) {
+  const unsigned char *p =
+      (unsigned char *)memchr(ch->data + offset, c, ch->len - offset);
+  return p ? (bufsize_t)(p - ch->data) : ch->len;
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static inline cmark_chunk cmark_chunk_literal(const char *data) {
+  bufsize_t len = data ? (bufsize_t)strlen(data) : 0;
+  cmark_chunk c = {(unsigned char *)data, len};
+  return c;
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static inline cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, bufsize_t pos,
+                                          bufsize_t len) {
+  cmark_chunk c = {ch->data + pos, len};
+  return c;
+}
+
+#endif
diff --git a/cmark/src/cmark.c b/cmark/src/cmark.c
new file mode 100644
index 0000000000..60aedbc6f1
--- /dev/null
+++ b/cmark/src/cmark.c
@@ -0,0 +1,48 @@
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include "node.h"
+#include "houdini.h"
+#include "cmark.h"
+#include "buffer.h"
+
+int cmark_version(void) { return CMARK_VERSION; }
+
+const char *cmark_version_string(void) { return CMARK_VERSION_STRING; }
+
+static void *xcalloc(size_t nmem, size_t size) {
+  void *ptr = calloc(nmem, size);
+  if (!ptr) {
+    fprintf(stderr, "[cmark] calloc returned null pointer, aborting\n");
+    abort();
+  }
+  return ptr;
+}
+
+static void *xrealloc(void *ptr, size_t size) {
+  void *new_ptr = realloc(ptr, size);
+  if (!new_ptr) {
+    fprintf(stderr, "[cmark] realloc returned null pointer, aborting\n");
+    abort();
+  }
+  return new_ptr;
+}
+
+cmark_mem DEFAULT_MEM_ALLOCATOR = {xcalloc, xrealloc, free};
+
+cmark_mem *cmark_get_default_mem_allocator(void) {
+  return &DEFAULT_MEM_ALLOCATOR;
+}
+
+
+char *cmark_markdown_to_html(const char *text, size_t len, int options) {
+  cmark_node *doc;
+  char *result;
+
+  doc = cmark_parse_document(text, len, options);
+
+  result = cmark_render_html(doc, options);
+  cmark_node_free(doc);
+
+  return result;
+}
diff --git a/cmark/src/cmark.h b/cmark/src/cmark.h
new file mode 100644
index 0000000000..6626b06273
--- /dev/null
+++ b/cmark/src/cmark.h
@@ -0,0 +1,704 @@
+#ifndef CMARK_H
+#define CMARK_H
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <cmark_export.h>
+#include <cmark_version.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** # NAME
+ *
+ * **cmark** - CommonMark parsing, manipulating, and rendering
+ */
+
+/** # DESCRIPTION
+ *
+ * ## Simple Interface
+ */
+
+/** Convert 'text' (assumed to be a UTF-8 encoded string with length
+ * 'len') from CommonMark Markdown to HTML, returning a null-terminated,
+ * UTF-8-encoded string. It is the caller's responsibility
+ * to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_markdown_to_html(const char *text, size_t len, int options);
+
+/** ## Node Structure
+ */
+
+typedef enum {
+  /* Error status */
+  CMARK_NODE_NONE,
+
+  /* Block */
+  CMARK_NODE_DOCUMENT,
+  CMARK_NODE_BLOCK_QUOTE,
+  CMARK_NODE_LIST,
+  CMARK_NODE_ITEM,
+  CMARK_NODE_CODE_BLOCK,
+  CMARK_NODE_HTML_BLOCK,
+  CMARK_NODE_CUSTOM_BLOCK,
+  CMARK_NODE_PARAGRAPH,
+  CMARK_NODE_HEADING,
+  CMARK_NODE_THEMATIC_BREAK,
+
+  CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT,
+  CMARK_NODE_LAST_BLOCK = CMARK_NODE_THEMATIC_BREAK,
+
+  /* Inline */
+  CMARK_NODE_TEXT,
+  CMARK_NODE_SOFTBREAK,
+  CMARK_NODE_LINEBREAK,
+  CMARK_NODE_CODE,
+  CMARK_NODE_HTML_INLINE,
+  CMARK_NODE_CUSTOM_INLINE,
+  CMARK_NODE_EMPH,
+  CMARK_NODE_STRONG,
+  CMARK_NODE_LINK,
+  CMARK_NODE_IMAGE,
+
+  CMARK_NODE_FIRST_INLINE = CMARK_NODE_TEXT,
+  CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE
+} cmark_node_type;
+
+/* For backwards compatibility: */
+#define CMARK_NODE_HEADER CMARK_NODE_HEADING
+#define CMARK_NODE_HRULE CMARK_NODE_THEMATIC_BREAK
+#define CMARK_NODE_HTML CMARK_NODE_HTML_BLOCK
+#define CMARK_NODE_INLINE_HTML CMARK_NODE_HTML_INLINE
+
+typedef enum {
+  CMARK_NO_LIST,
+  CMARK_BULLET_LIST,
+  CMARK_ORDERED_LIST
+} cmark_list_type;
+
+typedef enum {
+  CMARK_NO_DELIM,
+  CMARK_PERIOD_DELIM,
+  CMARK_PAREN_DELIM
+} cmark_delim_type;
+
+typedef struct cmark_node cmark_node;
+typedef struct cmark_parser cmark_parser;
+typedef struct cmark_iter cmark_iter;
+
+/**
+ * ## Custom memory allocator support
+ */
+
+/** Defines the memory allocation functions to be used by CMark
+ * when parsing and allocating a document tree
+ */
+typedef struct cmark_mem {
+  void *(*calloc)(size_t, size_t);
+  void *(*realloc)(void *, size_t);
+  void (*free)(void *);
+} cmark_mem;
+
+/** Returns a pointer to the default memory allocator.
+ */
+CMARK_EXPORT cmark_mem *cmark_get_default_mem_allocator(void);
+
+/**
+ * ## Classifying nodes
+ */
+
+/** Returns true if the node is a block node.
+  */
+CMARK_EXPORT bool cmark_node_is_block(cmark_node *node);
+
+/** Returns true if the node is an inline node.
+  */
+CMARK_EXPORT bool cmark_node_is_inline(cmark_node *node);
+
+/** Returns true if the node is a leaf node (a node that cannot
+    contain children).
+  */
+CMARK_EXPORT bool cmark_node_is_leaf(cmark_node *node);
+
+/**
+ * ## Creating and Destroying Nodes
+ */
+
+/** Creates a new node of type 'type'.  Note that the node may have
+ * other required properties, which it is the caller's responsibility
+ * to assign.
+ */
+CMARK_EXPORT cmark_node *cmark_node_new(cmark_node_type type);
+
+/** Same as `cmark_node_new`, but explicitly listing the memory
+ * allocator used to allocate the node.  Note:  be sure to use the same
+ * allocator for every node in a tree, or bad things can happen.
+ */
+CMARK_EXPORT cmark_node *cmark_node_new_with_mem(cmark_node_type type,
+                                                 cmark_mem *mem);
+
+/** Frees the memory allocated for a node and any children.
+ */
+CMARK_EXPORT void cmark_node_free(cmark_node *node);
+
+/**
+ * ## Tree Traversal
+ */
+
+/** Returns the next node in the sequence after 'node', or NULL if
+ * there is none.
+ */
+CMARK_EXPORT cmark_node *cmark_node_next(cmark_node *node);
+
+/** Returns the previous node in the sequence after 'node', or NULL if
+ * there is none.
+ */
+CMARK_EXPORT cmark_node *cmark_node_previous(cmark_node *node);
+
+/** Returns the parent of 'node', or NULL if there is none.
+ */
+CMARK_EXPORT cmark_node *cmark_node_parent(cmark_node *node);
+
+/** Returns the first child of 'node', or NULL if 'node' has no children.
+ */
+CMARK_EXPORT cmark_node *cmark_node_first_child(cmark_node *node);
+
+/** Returns the last child of 'node', or NULL if 'node' has no children.
+ */
+CMARK_EXPORT cmark_node *cmark_node_last_child(cmark_node *node);
+
+/**
+ * ## Iterator
+ *
+ * An iterator will walk through a tree of nodes, starting from a root
+ * node, returning one node at a time, together with information about
+ * whether the node is being entered or exited.  The iterator will
+ * first descend to a child node, if there is one.  When there is no
+ * child, the iterator will go to the next sibling.  When there is no
+ * next sibling, the iterator will return to the parent (but with
+ * a 'cmark_event_type' of `CMARK_EVENT_EXIT`).  The iterator will
+ * return `CMARK_EVENT_DONE` when it reaches the root node again.
+ * One natural application is an HTML renderer, where an `ENTER` event
+ * outputs an open tag and an `EXIT` event outputs a close tag.
+ * An iterator might also be used to transform an AST in some systematic
+ * way, for example, turning all level-3 headings into regular paragraphs.
+ *
+ *     void
+ *     usage_example(cmark_node *root) {
+ *         cmark_event_type ev_type;
+ *         cmark_iter *iter = cmark_iter_new(root);
+ *
+ *         while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+ *             cmark_node *cur = cmark_iter_get_node(iter);
+ *             // Do something with `cur` and `ev_type`
+ *         }
+ *
+ *         cmark_iter_free(iter);
+ *     }
+ *
+ * Iterators will never return `EXIT` events for leaf nodes, which are nodes
+ * of type:
+ *
+ * * CMARK_NODE_HTML_BLOCK
+ * * CMARK_NODE_THEMATIC_BREAK
+ * * CMARK_NODE_CODE_BLOCK
+ * * CMARK_NODE_TEXT
+ * * CMARK_NODE_SOFTBREAK
+ * * CMARK_NODE_LINEBREAK
+ * * CMARK_NODE_CODE
+ * * CMARK_NODE_HTML_INLINE
+ *
+ * Nodes must only be modified after an `EXIT` event, or an `ENTER` event for
+ * leaf nodes.
+ */
+
+typedef enum {
+  CMARK_EVENT_NONE,
+  CMARK_EVENT_DONE,
+  CMARK_EVENT_ENTER,
+  CMARK_EVENT_EXIT
+} cmark_event_type;
+
+/** Creates a new iterator starting at 'root'.  The current node and event
+ * type are undefined until 'cmark_iter_next' is called for the first time.
+ * The memory allocated for the iterator should be released using
+ * 'cmark_iter_free' when it is no longer needed.
+ */
+CMARK_EXPORT
+cmark_iter *cmark_iter_new(cmark_node *root);
+
+/** Frees the memory allocated for an iterator.
+ */
+CMARK_EXPORT
+void cmark_iter_free(cmark_iter *iter);
+
+/** Advances to the next node and returns the event type (`CMARK_EVENT_ENTER`,
+ * `CMARK_EVENT_EXIT` or `CMARK_EVENT_DONE`).
+ */
+CMARK_EXPORT
+cmark_event_type cmark_iter_next(cmark_iter *iter);
+
+/** Returns the current node.
+ */
+CMARK_EXPORT
+cmark_node *cmark_iter_get_node(cmark_iter *iter);
+
+/** Returns the current event type.
+ */
+CMARK_EXPORT
+cmark_event_type cmark_iter_get_event_type(cmark_iter *iter);
+
+/** Returns the root node.
+ */
+CMARK_EXPORT
+cmark_node *cmark_iter_get_root(cmark_iter *iter);
+
+/** Resets the iterator so that the current node is 'current' and
+ * the event type is 'event_type'.  The new current node must be a
+ * descendant of the root node or the root node itself.
+ */
+CMARK_EXPORT
+void cmark_iter_reset(cmark_iter *iter, cmark_node *current,
+                      cmark_event_type event_type);
+
+/**
+ * ## Accessors
+ */
+
+/** Returns the user data of 'node'.
+ */
+CMARK_EXPORT void *cmark_node_get_user_data(cmark_node *node);
+
+/** Sets arbitrary user data for 'node'.  Returns 1 on success,
+ * 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_user_data(cmark_node *node, void *user_data);
+
+/** Returns the type of 'node', or `CMARK_NODE_NONE` on error.
+ */
+CMARK_EXPORT cmark_node_type cmark_node_get_type(cmark_node *node);
+
+/** Like 'cmark_node_get_type', but returns a string representation
+    of the type, or `"<unknown>"`.
+ */
+CMARK_EXPORT
+const char *cmark_node_get_type_string(cmark_node *node);
+
+/** Returns the string contents of 'node', or an empty
+    string if none is set.  Returns NULL if called on a
+    node that does not have string content.
+ */
+CMARK_EXPORT const char *cmark_node_get_literal(cmark_node *node);
+
+/** Sets the string contents of 'node'.  Returns 1 on success,
+ * 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_literal(cmark_node *node, const char *content);
+
+/** Returns the heading level of 'node', or 0 if 'node' is not a heading.
+ */
+CMARK_EXPORT int cmark_node_get_heading_level(cmark_node *node);
+
+/* For backwards compatibility */
+#define cmark_node_get_header_level cmark_node_get_heading_level
+#define cmark_node_set_header_level cmark_node_set_heading_level
+
+/** Sets the heading level of 'node', returning 1 on success and 0 on error.
+ */
+CMARK_EXPORT int cmark_node_set_heading_level(cmark_node *node, int level);
+
+/** Returns the list type of 'node', or `CMARK_NO_LIST` if 'node'
+ * is not a list.
+ */
+CMARK_EXPORT cmark_list_type cmark_node_get_list_type(cmark_node *node);
+
+/** Sets the list type of 'node', returning 1 on success and 0 on error.
+ */
+CMARK_EXPORT int cmark_node_set_list_type(cmark_node *node,
+                                          cmark_list_type type);
+
+/** Returns the list delimiter type of 'node', or `CMARK_NO_DELIM` if 'node'
+ * is not a list.
+ */
+CMARK_EXPORT cmark_delim_type cmark_node_get_list_delim(cmark_node *node);
+
+/** Sets the list delimiter type of 'node', returning 1 on success and 0
+ * on error.
+ */
+CMARK_EXPORT int cmark_node_set_list_delim(cmark_node *node,
+                                           cmark_delim_type delim);
+
+/** Returns starting number of 'node', if it is an ordered list, otherwise 0.
+ */
+CMARK_EXPORT int cmark_node_get_list_start(cmark_node *node);
+
+/** Sets starting number of 'node', if it is an ordered list. Returns 1
+ * on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_list_start(cmark_node *node, int start);
+
+/** Returns 1 if 'node' is a tight list, 0 otherwise.
+ */
+CMARK_EXPORT int cmark_node_get_list_tight(cmark_node *node);
+
+/** Sets the "tightness" of a list.  Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_list_tight(cmark_node *node, int tight);
+
+/** Returns the info string from a fenced code block.
+ */
+CMARK_EXPORT const char *cmark_node_get_fence_info(cmark_node *node);
+
+/** Sets the info string in a fenced code block, returning 1 on
+ * success and 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_fence_info(cmark_node *node, const char *info);
+
+/** Returns the URL of a link or image 'node', or an empty string
+    if no URL is set.  Returns NULL if called on a node that is
+    not a link or image.
+ */
+CMARK_EXPORT const char *cmark_node_get_url(cmark_node *node);
+
+/** Sets the URL of a link or image 'node'. Returns 1 on success,
+ * 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_url(cmark_node *node, const char *url);
+
+/** Returns the title of a link or image 'node', or an empty
+    string if no title is set.  Returns NULL if called on a node
+    that is not a link or image.
+ */
+CMARK_EXPORT const char *cmark_node_get_title(cmark_node *node);
+
+/** Sets the title of a link or image 'node'. Returns 1 on success,
+ * 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_title(cmark_node *node, const char *title);
+
+/** Returns the literal "on enter" text for a custom 'node', or
+    an empty string if no on_enter is set.  Returns NULL if called
+    on a non-custom node.
+ */
+CMARK_EXPORT const char *cmark_node_get_on_enter(cmark_node *node);
+
+/** Sets the literal text to render "on enter" for a custom 'node'.
+    Any children of the node will be rendered after this text.
+    Returns 1 on success 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_on_enter(cmark_node *node,
+                                         const char *on_enter);
+
+/** Returns the literal "on exit" text for a custom 'node', or
+    an empty string if no on_exit is set.  Returns NULL if
+    called on a non-custom node.
+ */
+CMARK_EXPORT const char *cmark_node_get_on_exit(cmark_node *node);
+
+/** Sets the literal text to render "on exit" for a custom 'node'.
+    Any children of the node will be rendered before this text.
+    Returns 1 on success 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_on_exit(cmark_node *node, const char *on_exit);
+
+/** Returns the line on which 'node' begins.
+ */
+CMARK_EXPORT int cmark_node_get_start_line(cmark_node *node);
+
+/** Returns the column at which 'node' begins.
+ */
+CMARK_EXPORT int cmark_node_get_start_column(cmark_node *node);
+
+/** Returns the line on which 'node' ends.
+ */
+CMARK_EXPORT int cmark_node_get_end_line(cmark_node *node);
+
+/** Returns the column at which 'node' ends.
+ */
+CMARK_EXPORT int cmark_node_get_end_column(cmark_node *node);
+
+/**
+ * ## Tree Manipulation
+ */
+
+/** Unlinks a 'node', removing it from the tree, but not freeing its
+ * memory.  (Use 'cmark_node_free' for that.)
+ */
+CMARK_EXPORT void cmark_node_unlink(cmark_node *node);
+
+/** Inserts 'sibling' before 'node'.  Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_insert_before(cmark_node *node,
+                                          cmark_node *sibling);
+
+/** Inserts 'sibling' after 'node'. Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_insert_after(cmark_node *node, cmark_node *sibling);
+
+/** Replaces 'oldnode' with 'newnode' and unlinks 'oldnode' (but does
+ * not free its memory).
+ * Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode);
+
+/** Adds 'child' to the beginning of the children of 'node'.
+ * Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_prepend_child(cmark_node *node, cmark_node *child);
+
+/** Adds 'child' to the end of the children of 'node'.
+ * Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_append_child(cmark_node *node, cmark_node *child);
+
+/** Consolidates adjacent text nodes.
+ */
+CMARK_EXPORT void cmark_consolidate_text_nodes(cmark_node *root);
+
+/**
+ * ## Parsing
+ *
+ * Simple interface:
+ *
+ *     cmark_node *document = cmark_parse_document("Hello *world*", 13,
+ *                                                 CMARK_OPT_DEFAULT);
+ *
+ * Streaming interface:
+ *
+ *     cmark_parser *parser = cmark_parser_new(CMARK_OPT_DEFAULT);
+ *     FILE *fp = fopen("myfile.md", "rb");
+ *     while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
+ *         cmark_parser_feed(parser, buffer, bytes);
+ *         if (bytes < sizeof(buffer)) {
+ *             break;
+ *         }
+ *     }
+ *     document = cmark_parser_finish(parser);
+ *     cmark_parser_free(parser);
+ */
+
+/** Creates a new parser object.
+ */
+CMARK_EXPORT
+cmark_parser *cmark_parser_new(int options);
+
+/** Creates a new parser object with the given memory allocator
+ *
+ * A generalization of `cmark_parser_new`:
+ * ```c
+ * cmark_parser_new(options)
+ * ```
+ * is the same as:
+ * ```c
+ * cmark_parser_new_with_mem(options, cmark_get_default_mem_allocator())
+ * ```
+ */
+CMARK_EXPORT
+cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem);
+
+/** Creates a new parser object with the given node to use as the root
+ * node of the parsed AST.
+ *
+ * When parsing, children are always appended, not prepended; that means
+ * if `root` already has children, the newly-parsed children will appear
+ * after the given children.
+ *
+ * A generalization of `cmark_parser_new_with_mem`:
+ * ```c
+ * cmark_parser_new_with_mem(options, mem)
+ * ```
+ * is approximately the same as:
+ * ```c
+ * cmark_parser_new_with_mem_into_root(options, mem, cmark_node_new(CMARK_NODE_DOCUMENT))
+ * ```
+ *
+ * This is useful for creating a single document out of multiple parsed
+ * document fragments.
+ */
+CMARK_EXPORT
+cmark_parser *cmark_parser_new_with_mem_into_root(
+    int options, cmark_mem *mem, cmark_node *root);
+
+/** Frees memory allocated for a parser object.
+ */
+CMARK_EXPORT
+void cmark_parser_free(cmark_parser *parser);
+
+/** Feeds a string of length 'len' to 'parser'.
+ */
+CMARK_EXPORT
+void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len);
+
+/** Finish parsing and return a pointer to a tree of nodes.
+ */
+CMARK_EXPORT
+cmark_node *cmark_parser_finish(cmark_parser *parser);
+
+/** Parse a CommonMark document in 'buffer' of length 'len'.
+ * Returns a pointer to a tree of nodes.  The memory allocated for
+ * the node tree should be released using 'cmark_node_free'
+ * when it is no longer needed.
+ */
+CMARK_EXPORT
+cmark_node *cmark_parse_document(const char *buffer, size_t len, int options);
+
+/** Parse a CommonMark document in file 'f', returning a pointer to
+ * a tree of nodes.  The memory allocated for the node tree should be
+ * released using 'cmark_node_free' when it is no longer needed.
+ */
+CMARK_EXPORT
+cmark_node *cmark_parse_file(FILE *f, int options);
+
+/**
+ * ## Rendering
+ */
+
+/** Render a 'node' tree as XML.  It is the caller's responsibility
+ * to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_xml(cmark_node *root, int options);
+
+/** Render a 'node' tree as an HTML fragment.  It is up to the user
+ * to add an appropriate header and footer. It is the caller's
+ * responsibility to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_html(cmark_node *root, int options);
+
+/** Render a 'node' tree as a groff man page, without the header.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_man(cmark_node *root, int options, int width);
+
+/** Render a 'node' tree as a commonmark document.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_commonmark(cmark_node *root, int options, int width);
+
+/** Render a 'node' tree as a LaTeX document.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_latex(cmark_node *root, int options, int width);
+
+/**
+ * ## Options
+ */
+
+/** Default options.
+ */
+#define CMARK_OPT_DEFAULT 0
+
+/**
+ * ### Options affecting rendering
+ */
+
+/** Include a `data-sourcepos` attribute on all block elements.
+ */
+#define CMARK_OPT_SOURCEPOS (1 << 1)
+
+/** Render `softbreak` elements as hard line breaks.
+ */
+#define CMARK_OPT_HARDBREAKS (1 << 2)
+
+/** `CMARK_OPT_SAFE` is defined here for API compatibility,
+    but it no longer has any effect. "Safe" mode is now the default:
+    set `CMARK_OPT_UNSAFE` to disable it.
+ */
+#define CMARK_OPT_SAFE (1 << 3)
+
+/** Render raw HTML and unsafe links (`javascript:`, `vbscript:`,
+ * `file:`, and `data:`, except for `image/png`, `image/gif`,
+ * `image/jpeg`, or `image/webp` mime types).  By default,
+ * raw HTML is replaced by a placeholder HTML comment. Unsafe
+ * links are replaced by empty strings.
+ */
+#define CMARK_OPT_UNSAFE (1 << 17)
+
+/** Render `softbreak` elements as spaces.
+ */
+#define CMARK_OPT_NOBREAKS (1 << 4)
+
+/**
+ * ### Options affecting parsing
+ */
+
+/** Legacy option (no effect).
+ */
+#define CMARK_OPT_NORMALIZE (1 << 8)
+
+/** Validate UTF-8 in the input before parsing, replacing illegal
+ * sequences with the replacement character U+FFFD.
+ */
+#define CMARK_OPT_VALIDATE_UTF8 (1 << 9)
+
+/** Convert straight quotes to curly, `---` to em dashes, `--` to en dashes.
+ */
+#define CMARK_OPT_SMART (1 << 10)
+
+/**
+ * ## Version information
+ */
+
+/** The library version as integer for runtime checks. Also available as
+ * macro CMARK_VERSION for compile time checks.
+ *
+ * * Bits 16-23 contain the major version.
+ * * Bits 8-15 contain the minor version.
+ * * Bits 0-7 contain the patchlevel.
+ *
+ * In hexadecimal format, the number 0x010203 represents version 1.2.3.
+ */
+CMARK_EXPORT
+int cmark_version(void);
+
+/** The library version string for runtime checks. Also available as
+ * macro CMARK_VERSION_STRING for compile time checks.
+ */
+CMARK_EXPORT
+const char *cmark_version_string(void);
+
+/** # AUTHORS
+ *
+ * John MacFarlane, Vicent Marti,  Kārlis Gaņģis, Nick Wellnhofer.
+ */
+
+#ifndef CMARK_NO_SHORT_NAMES
+#define NODE_DOCUMENT CMARK_NODE_DOCUMENT
+#define NODE_BLOCK_QUOTE CMARK_NODE_BLOCK_QUOTE
+#define NODE_LIST CMARK_NODE_LIST
+#define NODE_ITEM CMARK_NODE_ITEM
+#define NODE_CODE_BLOCK CMARK_NODE_CODE_BLOCK
+#define NODE_HTML_BLOCK CMARK_NODE_HTML_BLOCK
+#define NODE_CUSTOM_BLOCK CMARK_NODE_CUSTOM_BLOCK
+#define NODE_PARAGRAPH CMARK_NODE_PARAGRAPH
+#define NODE_HEADING CMARK_NODE_HEADING
+#define NODE_HEADER CMARK_NODE_HEADER
+#define NODE_THEMATIC_BREAK CMARK_NODE_THEMATIC_BREAK
+#define NODE_HRULE CMARK_NODE_HRULE
+#define NODE_TEXT CMARK_NODE_TEXT
+#define NODE_SOFTBREAK CMARK_NODE_SOFTBREAK
+#define NODE_LINEBREAK CMARK_NODE_LINEBREAK
+#define NODE_CODE CMARK_NODE_CODE
+#define NODE_HTML_INLINE CMARK_NODE_HTML_INLINE
+#define NODE_CUSTOM_INLINE CMARK_NODE_CUSTOM_INLINE
+#define NODE_EMPH CMARK_NODE_EMPH
+#define NODE_STRONG CMARK_NODE_STRONG
+#define NODE_LINK CMARK_NODE_LINK
+#define NODE_IMAGE CMARK_NODE_IMAGE
+#define BULLET_LIST CMARK_BULLET_LIST
+#define ORDERED_LIST CMARK_ORDERED_LIST
+#define PERIOD_DELIM CMARK_PERIOD_DELIM
+#define PAREN_DELIM CMARK_PAREN_DELIM
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/cmarkConfig.cmake.in b/cmark/src/cmarkConfig.cmake.in
new file mode 100644
index 0000000000..3d865ff3f5
--- /dev/null
+++ b/cmark/src/cmarkConfig.cmake.in
@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/cmark-targets.cmake")
+check_required_components("cmark")
diff --git a/cmark/src/cmark_ctype.c b/cmark/src/cmark_ctype.c
new file mode 100644
index 0000000000..6280f0a424
--- /dev/null
+++ b/cmark/src/cmark_ctype.c
@@ -0,0 +1,38 @@
+#include <stdint.h>
+
+#include "cmark_ctype.h"
+
+/** 1 = space, 2 = punct, 3 = digit, 4 = alpha, 0 = other
+ */
+static const uint8_t cmark_ctype_class[256] = {
+    /*      0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
+    /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
+    /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 2 */ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    /* 3 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2,
+    /* 4 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    /* 5 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2,
+    /* 6 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    /* 7 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0,
+    /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* c */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* d */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* e */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+/**
+ * Returns 1 if c is a "whitespace" character as defined by the spec.
+ */
+int cmark_isspace(char c) { return cmark_ctype_class[(uint8_t)c] == 1; }
+
+/**
+ * Returns 1 if c is an ascii punctuation character.
+ */
+int cmark_ispunct(char c) { return cmark_ctype_class[(uint8_t)c] == 2; }
+
+int cmark_isdigit(char c) { return cmark_ctype_class[(uint8_t)c] == 3; }
+
+int cmark_isalpha(char c) { return cmark_ctype_class[(uint8_t)c] == 4; }
diff --git a/cmark/src/cmark_ctype.h b/cmark/src/cmark_ctype.h
new file mode 100644
index 0000000000..3ed63defda
--- /dev/null
+++ b/cmark/src/cmark_ctype.h
@@ -0,0 +1,24 @@
+#ifndef CMARK_CMARK_CTYPE_H
+#define CMARK_CMARK_CTYPE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Locale-independent versions of functions from ctype.h.
+ * We want cmark to behave the same no matter what the system locale.
+ */
+
+int cmark_isspace(char c);
+
+int cmark_ispunct(char c);
+
+int cmark_isdigit(char c);
+
+int cmark_isalpha(char c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/cmark_version.h.in b/cmark/src/cmark_version.h.in
new file mode 100644
index 0000000000..41de3ac675
--- /dev/null
+++ b/cmark/src/cmark_version.h.in
@@ -0,0 +1,7 @@
+#ifndef CMARK_VERSION_H
+#define CMARK_VERSION_H
+
+#define CMARK_VERSION ((@PROJECT_VERSION_MAJOR@ << 16) | (@PROJECT_VERSION_MINOR@ << 8)  | @PROJECT_VERSION_PATCH@)
+#define CMARK_VERSION_STRING "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@"
+
+#endif
diff --git a/cmark/src/commonmark.c b/cmark/src/commonmark.c
new file mode 100644
index 0000000000..ad805a630e
--- /dev/null
+++ b/cmark/src/commonmark.c
@@ -0,0 +1,473 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "utf8.h"
+#include "scanners.h"
+#include "render.h"
+
+#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define CR() renderer->cr(renderer)
+#define BLANKLINE() renderer->blankline(renderer)
+#define ENCODED_SIZE 20
+#define LISTMARKER_SIZE 20
+
+// Functions to convert cmark_nodes to commonmark strings.
+
+static inline void outc(cmark_renderer *renderer, cmark_escaping escape,
+                        int32_t c, unsigned char nextc) {
+  bool needs_escaping = false;
+  bool follows_digit =
+      renderer->buffer->size > 0 &&
+      cmark_isdigit(renderer->buffer->ptr[renderer->buffer->size - 1]);
+  char encoded[ENCODED_SIZE];
+  int options = renderer->options;
+
+  needs_escaping =
+      c < 0x80 && escape != LITERAL &&
+      ((escape == NORMAL &&
+        (c < 0x20 ||
+         c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' ||
+         c == '>' || c == '\\' || c == '`' ||
+	 (c == '!' && (!nextc || nextc == '[')) ||
+         (c == '&' && cmark_isalpha(nextc)) || (c == '!' && nextc == '[') ||
+         ((CMARK_OPT_SMART & options) &&
+            ((c == '-' && nextc == '-') ||
+             (c == '.' && nextc == '.') ||
+             c == '"' || c == '\'')) ||
+         (renderer->begin_content && (c == '-' || c == '+' || c == '=') &&
+          // begin_content doesn't get set to false til we've passed digits
+          // at the beginning of line, so...
+          !follows_digit) ||
+         (renderer->begin_content && (c == '.' || c == ')') && follows_digit &&
+          (nextc == 0 || cmark_isspace(nextc))))) ||
+       (escape == URL &&
+        (c == '`' || c == '<' || c == '>' || cmark_isspace(c) || c == '\\' ||
+         c == ')' || c == '(')) ||
+       (escape == TITLE &&
+        (c == '`' || c == '<' || c == '>' || c == '"' || c == '\\')));
+
+  if (needs_escaping) {
+    if (escape == URL && cmark_isspace(c)) {
+      // use percent encoding for spaces
+      snprintf(encoded, ENCODED_SIZE, "%%%2X", c);
+      cmark_strbuf_puts(renderer->buffer, encoded);
+      renderer->column += 3;
+    } else if (cmark_ispunct(c)) {
+      cmark_render_ascii(renderer, "\\");
+      cmark_render_code_point(renderer, c);
+    } else { // render as entity
+      snprintf(encoded, ENCODED_SIZE, "&#%d;", c);
+      cmark_strbuf_puts(renderer->buffer, encoded);
+      renderer->column += (int)strlen(encoded);
+    }
+  } else {
+    cmark_render_code_point(renderer, c);
+  }
+}
+
+static int longest_backtick_sequence(const char *code) {
+  int longest = 0;
+  int current = 0;
+  size_t i = 0;
+  size_t code_len = strlen(code);
+  while (i <= code_len) {
+    if (code[i] == '`') {
+      current++;
+    } else {
+      if (current > longest) {
+        longest = current;
+      }
+      current = 0;
+    }
+    i++;
+  }
+  return longest;
+}
+
+static int shortest_unused_backtick_sequence(const char *code) {
+  // note: if the shortest sequence is >= 32, this returns 32
+  // so as not to overflow the bit array.
+  uint32_t used = 1;
+  int current = 0;
+  size_t i = 0;
+  size_t code_len = strlen(code);
+  while (i <= code_len) {
+    if (code[i] == '`') {
+      current++;
+    } else {
+      if (current > 0 && current < 32) {
+        used |= (1U << current);
+      }
+      current = 0;
+    }
+    i++;
+  }
+  // return number of first bit that is 0:
+  i = 0;
+  while (i < 32 && used & 1) {
+    used = used >> 1;
+    i++;
+  }
+  return (int)i;
+}
+
+static bool is_autolink(cmark_node *node) {
+  const unsigned char *title;
+  const unsigned char *url;
+  cmark_node *link_text;
+
+  if (node->type != CMARK_NODE_LINK) {
+    return false;
+  }
+
+  url = node->as.link.url;
+  if (url == NULL || _scan_scheme(url) == 0) {
+    return false;
+  }
+
+  title = node->as.link.title;
+  // if it has a title, we can't treat it as an autolink:
+  if (title && title[0]) {
+    return false;
+  }
+
+  link_text = node->first_child;
+  if (link_text == NULL) {
+    return false;
+  }
+  cmark_consolidate_text_nodes(link_text);
+  if (strncmp((const char *)url, "mailto:", 7) == 0) {
+    url += 7;
+  }
+  return link_text->data != NULL &&
+         strcmp((const char *)url, (char *)link_text->data) == 0;
+}
+
+static int S_render_node(cmark_renderer *renderer, cmark_node *node,
+                         cmark_event_type ev_type, int options) {
+  cmark_node *tmp;
+  int list_number;
+  cmark_delim_type list_delim;
+  size_t numticks;
+  bool extra_spaces;
+  size_t i;
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  const char *info, *code, *title;
+  char fencechar[2] = {'\0', '\0'};
+  size_t code_len;
+  char listmarker[LISTMARKER_SIZE];
+  const char *emph_delim;
+  bool first_in_list_item;
+  bufsize_t marker_width;
+  bool has_nonspace;
+  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options) &&
+                    !(CMARK_OPT_HARDBREAKS & options);
+
+  // Don't adjust tight list status til we've started the list.
+  // Otherwise we lose the blank line between a paragraph and
+  // a following list.
+  if (entering) {
+    if (node->parent && node->parent->type == CMARK_NODE_ITEM) {
+      renderer->in_tight_list_item = node->parent->parent->as.list.tight;
+    }
+  } else {
+    if (node->type == CMARK_NODE_LIST) {
+      renderer->in_tight_list_item =
+        node->parent &&
+        node->parent->type == CMARK_NODE_ITEM &&
+        node->parent->parent->as.list.tight;
+    }
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    if (entering) {
+      LIT("> ");
+      renderer->begin_content = true;
+      cmark_strbuf_puts(renderer->prefix, "> ");
+    } else {
+      cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 2);
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_LIST:
+    if (!entering && node->next && (node->next->type == CMARK_NODE_LIST)) {
+      // this ensures that a following indented code block or list will be
+      // inteprereted correctly.
+      CR();
+      LIT("<!-- end list -->");
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_ITEM:
+    if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+      marker_width = 4;
+    } else {
+      list_number = cmark_node_get_list_start(node->parent);
+      list_delim = cmark_node_get_list_delim(node->parent);
+      tmp = node;
+      while (tmp->prev) {
+        tmp = tmp->prev;
+        list_number += 1;
+      }
+      // we ensure a width of at least 4 so
+      // we get nice transition from single digits
+      // to double
+      snprintf(listmarker, LISTMARKER_SIZE, "%d%s%s", list_number,
+               list_delim == CMARK_PAREN_DELIM ? ")" : ".",
+               list_number < 10 ? "  " : " ");
+      marker_width = (bufsize_t)strlen(listmarker);
+    }
+    if (entering) {
+      if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+        LIT("  - ");
+        renderer->begin_content = true;
+      } else {
+        LIT(listmarker);
+        renderer->begin_content = true;
+      }
+      if (node->first_child == NULL) {
+        BLANKLINE();
+      } else {
+        for (i = marker_width; i--;) {
+          cmark_strbuf_putc(renderer->prefix, ' ');
+        }
+      }
+    } else {
+      cmark_strbuf_truncate(renderer->prefix,
+                            renderer->prefix->size - marker_width);
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_HEADING:
+    if (entering) {
+      for (i = cmark_node_get_heading_level(node); i > 0; i--) {
+        LIT("#");
+      }
+      LIT(" ");
+      renderer->begin_content = true;
+      renderer->no_linebreaks = true;
+    } else {
+      renderer->no_linebreaks = false;
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_CODE_BLOCK:
+
+    first_in_list_item = node->prev == NULL && node->parent &&
+                         node->parent->type == CMARK_NODE_ITEM;
+
+    if (!first_in_list_item) {
+      BLANKLINE();
+    }
+    info = cmark_node_get_fence_info(node);
+    fencechar[0] = strchr(info, '`') == NULL ? '`' : '~';
+    code = cmark_node_get_literal(node);
+
+    numticks = longest_backtick_sequence(code) + 1;
+    if (numticks < 3) {
+      numticks = 3;
+    }
+    for (i = 0; i < numticks; i++) {
+      LIT(fencechar);
+    }
+    LIT(" ");
+    OUT(info, false, LITERAL);
+    CR();
+    OUT(cmark_node_get_literal(node), false, LITERAL);
+    CR();
+    for (i = 0; i < numticks; i++) {
+      LIT(fencechar);
+    }
+
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_HTML_BLOCK:
+    BLANKLINE();
+    OUT(cmark_node_get_literal(node), false, LITERAL);
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_CUSTOM_BLOCK:
+    BLANKLINE();
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_THEMATIC_BREAK:
+    BLANKLINE();
+    LIT("-----");
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_PARAGRAPH:
+    if (!entering) {
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_TEXT:
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
+    break;
+
+  case CMARK_NODE_LINEBREAK:
+    if (!(CMARK_OPT_HARDBREAKS & options)) {
+      LIT("  ");
+    }
+    CR();
+    break;
+
+  case CMARK_NODE_SOFTBREAK:
+    if (CMARK_OPT_HARDBREAKS & options) {
+      LIT("  ");
+      CR();
+    } else if (!renderer->no_linebreaks && renderer->width == 0 &&
+               !(CMARK_OPT_HARDBREAKS & options) &&
+               !(CMARK_OPT_NOBREAKS & options)) {
+      CR();
+    } else {
+      OUT(" ", allow_wrap, LITERAL);
+    }
+    break;
+
+  case CMARK_NODE_CODE:
+    code = cmark_node_get_literal(node);
+    code_len = strlen(code);
+    numticks = shortest_unused_backtick_sequence(code);
+    has_nonspace = false;
+    for (i=0; i < code_len; i++) {
+      if (code[i] != ' ') {
+        has_nonspace = true;
+        break;
+      }
+    }
+    extra_spaces = code_len == 0 ||
+            code[0] == '`' || code[code_len - 1] == '`' ||
+            (has_nonspace && code[0] == ' ' && code[code_len - 1] == ' ');
+    for (i = 0; i < numticks; i++) {
+      LIT("`");
+    }
+    if (extra_spaces) {
+      LIT(" ");
+    }
+    OUT(cmark_node_get_literal(node), allow_wrap, LITERAL);
+    if (extra_spaces) {
+      LIT(" ");
+    }
+    for (i = 0; i < numticks; i++) {
+      LIT("`");
+    }
+    break;
+
+  case CMARK_NODE_HTML_INLINE:
+    OUT(cmark_node_get_literal(node), false, LITERAL);
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE:
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    break;
+
+  case CMARK_NODE_STRONG:
+    if (entering) {
+      LIT("**");
+    } else {
+      LIT("**");
+    }
+    break;
+
+  case CMARK_NODE_EMPH:
+    // If we have EMPH(EMPH(x)), we need to use *_x_*
+    // because **x** is STRONG(x):
+    if (node->parent && node->parent->type == CMARK_NODE_EMPH &&
+        node->next == NULL && node->prev == NULL) {
+      emph_delim = "_";
+    } else {
+      emph_delim = "*";
+    }
+    if (entering) {
+      LIT(emph_delim);
+    } else {
+      LIT(emph_delim);
+    }
+    break;
+
+  case CMARK_NODE_LINK:
+    if (is_autolink(node)) {
+      if (entering) {
+        LIT("<");
+        if (strncmp(cmark_node_get_url(node), "mailto:", 7) == 0) {
+          LIT((const char *)cmark_node_get_url(node) + 7);
+        } else {
+          LIT((const char *)cmark_node_get_url(node));
+        }
+        LIT(">");
+        // return signal to skip contents of node...
+        return 0;
+      }
+    } else {
+      if (entering) {
+        LIT("[");
+      } else {
+        LIT("](");
+        OUT(cmark_node_get_url(node), false, URL);
+        title = cmark_node_get_title(node);
+        if (strlen(title) > 0) {
+          LIT(" \"");
+          OUT(title, false, TITLE);
+          LIT("\"");
+        }
+        LIT(")");
+      }
+    }
+    break;
+
+  case CMARK_NODE_IMAGE:
+    if (entering) {
+      LIT("![");
+    } else {
+      LIT("](");
+      OUT(cmark_node_get_url(node), false, URL);
+      title = cmark_node_get_title(node);
+      if (strlen(title) > 0) {
+        OUT(" \"", allow_wrap, LITERAL);
+        OUT(title, false, TITLE);
+        LIT("\"");
+      }
+      LIT(")");
+    }
+    break;
+
+  default:
+    assert(false);
+    break;
+  }
+
+  return 1;
+}
+
+char *cmark_render_commonmark(cmark_node *root, int options, int width) {
+  if (options & CMARK_OPT_HARDBREAKS) {
+    // disable breaking on width, since it has
+    // a different meaning with OPT_HARDBREAKS
+    width = 0;
+  }
+  return cmark_render(root, options, width, outc, S_render_node);
+}
diff --git a/cmark/src/entities.inc b/cmark/src/entities.inc
new file mode 100644
index 0000000000..e80d9aa9a4
--- /dev/null
+++ b/cmark/src/entities.inc
@@ -0,0 +1,2054 @@
+/* Autogenerated by tools/make_headers_inc.py */
+
+#define ENT_MIN_LENGTH      2
+#define ENT_MAX_LENGTH      32
+#define ENT_TABLE_SIZE      2125
+#define ENT_TEXT_IDX(x)     ((x) & 0x7FFF)
+#define ENT_NAME_SIZE(x)    (((x) >> 15) & 0x1F)
+#define ENT_REPL_SIZE(x)    ((x) >> 20)
+
+static const uint32_t cmark_entities[2125] = {
+  0x228000, 0x118007, 0x23000B, 0x230013, 0x22801B, 0x218022,
+  0x418027, 0x23002E, 0x228036, 0x22803D, 0x318044, 0x22804A,
+  0x420051, 0x368059, 0x228069, 0x420070, 0x330078, 0x230081,
+  0x220089, 0x34808F, 0x32009B, 0x3300A2, 0x2180AB, 0x3380B0,
+  0x3500BA, 0x2200C7, 0x4180CD, 0x4200D4, 0x2280DC, 0x3200E3,
+  0x3300EA, 0x2200F3, 0x2200F9, 0x2300FF, 0x318107, 0x3A010D,
+  0x338124, 0x23012E, 0x230136, 0x22813E, 0x338145, 0x22014F,
+  0x238155, 0x24815E, 0x318169, 0x21816F, 0x348174, 0x358180,
+  0x35018E, 0x35819B, 0x3C01A9, 0x3A81C4, 0x3781DC, 0x3281EE,
+  0x3301F6, 0x3481FF, 0x33020B, 0x378214, 0x320226, 0x34822D,
+  0x3F8239, 0x32825B, 0x420263, 0x31826B, 0x330271, 0x31027A,
+  0x34027F, 0x22028A, 0x220290, 0x220296, 0x33029C, 0x3202A5,
+  0x3282AC, 0x2302B4, 0x2182BC, 0x3182C1, 0x2282C7, 0x4182CE,
+  0x2802D5, 0x2702E7, 0x2B02F7, 0x18030F, 0x280320, 0x338332,
+  0x36833C, 0x42034C, 0x218354, 0x330359, 0x340362, 0x3A836D,
+  0x248385, 0x378390, 0x3783A2, 0x3A03B4, 0x3683CB, 0x3983DB,
+  0x3C03F1, 0x3A040C, 0x380423, 0x370436, 0x368447, 0x388457,
+  0x38846B, 0x34847F, 0x36048B, 0x38049A, 0x2484AD, 0x3984B8,
+  0x3884CE, 0x3704E2, 0x3884F3, 0x390507, 0x37851C, 0x39052E,
+  0x338543, 0x36054D, 0x34855C, 0x420568, 0x230570, 0x218578,
+  0x21857D, 0x230582, 0x23058A, 0x228592, 0x218599, 0x22059E,
+  0x4185A4, 0x2305AB, 0x3385B3, 0x2285BD, 0x3805C4, 0x3A05D7,
+  0x2285EE, 0x4205F5, 0x2385FD, 0x328606, 0x35060E, 0x35861B,
+  0x320629, 0x320630, 0x218637, 0x22063C, 0x330642, 0x36064B,
+  0x21865A, 0x41865F, 0x388666, 0x3A867A, 0x420692, 0x33069A,
+  0x3506A3, 0x3206B0, 0x2206B7, 0x1106BD, 0x2286C0, 0x2306C7,
+  0x2306CF, 0x2306D7, 0x2286DF, 0x2186E6, 0x2206EB, 0x4186F1,
+  0x3106F8, 0x4206FD, 0x360705, 0x380714, 0x380727, 0x37073A,
+  0x35874B, 0x388759, 0x36076D, 0x42077C, 0x310784, 0x230789,
+  0x228791, 0x118798, 0x22879C, 0x3187A3, 0x3607A9, 0x3207B8,
+  0x3707BF, 0x3207D0, 0x2307D7, 0x3607DF, 0x3487EE, 0x2207FA,
+  0x228800, 0x220807, 0x23080D, 0x228815, 0x21881C, 0x220821,
+  0x318827, 0x23082D, 0x310835, 0x22883A, 0x350841, 0x33884E,
+  0x318858, 0x34085E, 0x360869, 0x370878, 0x370889, 0x22889A,
+  0x4208A1, 0x2208A9, 0x3208AF, 0x2308B6, 0x2288BE, 0x2208C5,
+  0x2288CB, 0x2188D2, 0x4188D7, 0x4208DE, 0x4208E6, 0x2308EE,
+  0x2288F6, 0x2208FD, 0x220903, 0x228909, 0x230910, 0x218918,
+  0x41891D, 0x420924, 0x42092C, 0x220934, 0x11093A, 0x23093D,
+  0x230945, 0x32094D, 0x350954, 0x320961, 0x230968, 0x230970,
+  0x218978, 0x38097D, 0x348990, 0x36099C, 0x3989AB, 0x3589C1,
+  0x3889CF, 0x3889E3, 0x3709F7, 0x388A08, 0x348A1C, 0x370A28,
+  0x378A39, 0x338A4B, 0x360A55, 0x368A64, 0x360A74, 0x378A83,
+  0x388A95, 0x380AA9, 0x378ABC, 0x360ACE, 0x378ADD, 0x350AEF,
+  0x368AFC, 0x348B0C, 0x370B18, 0x380B29, 0x368B3C, 0x358B4C,
+  0x340B5A, 0x370B65, 0x348B76, 0x418B82, 0x310B89, 0x350B8E,
+  0x230B9B, 0x368BA3, 0x390BB3, 0x370BC8, 0x368BD9, 0x390BE9,
+  0x370BFE, 0x420C0F, 0x370C17, 0x378C28, 0x320C3A, 0x318C41,
+  0x230C47, 0x310C4F, 0x318C54, 0x218C5A, 0x358C5F, 0x348C6D,
+  0x418C79, 0x348C80, 0x420C8C, 0x320C94, 0x210C9B, 0x220C9F,
+  0x230CA5, 0x230CAD, 0x230CB5, 0x218CBD, 0x398CC2, 0x390CD8,
+  0x388CED, 0x3A8D01, 0x3A0D19, 0x370D30, 0x138D41, 0x418D49,
+  0x338D50, 0x280D5A, 0x320D6C, 0x318D73, 0x360D79, 0x348D88,
+  0x3A0D94, 0x350DAB, 0x340DB8, 0x568DC3, 0x348DD5, 0x350DE1,
+  0x378DEE, 0x598E00, 0x588E18, 0x370E2E, 0x5A0E3F, 0x378E58,
+  0x578E6A, 0x560E7E, 0x378E8F, 0x590EA1, 0x3A0EB8, 0x338ECF,
+  0x360ED9, 0x370EE8, 0x558EF9, 0x588F09, 0x360F1F, 0x5B8F2E,
+  0x588F4A, 0x358F60, 0x580F6E, 0x3A8F83, 0x388F9B, 0x380FAF,
+  0x598FC2, 0x3A8FDA, 0x578FF2, 0x3A1006, 0x58901D, 0x3B1033,
+  0x64904C, 0x37105B, 0x35906C, 0x58107A, 0x3A908F, 0x5810A7,
+  0x6590BC, 0x3810CD, 0x3410E0, 0x3690EB, 0x3890FB, 0x36910F,
+  0x37111F, 0x421130, 0x231138, 0x211140, 0x229144, 0x23114B,
+  0x229153, 0x21915A, 0x23115F, 0x419167, 0x23116E, 0x229176,
+  0x22917D, 0x239184, 0x42118D, 0x3A1195, 0x3711AC, 0x3111BD,
+  0x4211C2, 0x2311CA, 0x2311D2, 0x3311DA, 0x2211E3, 0x3391E9,
+  0x3491F3, 0x3591FF, 0x37920D, 0x34121F, 0x21922A, 0x41922F,
+  0x219236, 0x21123B, 0x24923F, 0x36924A, 0x32125A, 0x311261,
+  0x341266, 0x369271, 0x391281, 0x369296, 0x3292A6, 0x3392AE,
+  0x3512B8, 0x3612C5, 0x4212D4, 0x2192DC, 0x1212E1, 0x4192E6,
+  0x3212ED, 0x4212F4, 0x3292FC, 0x219304, 0x231309, 0x321311,
+  0x321318, 0x33131F, 0x231328, 0x231330, 0x219338, 0x31133D,
+  0x371342, 0x391353, 0x3A1368, 0x31937F, 0x219385, 0x38938A,
+  0x35139E, 0x3693AB, 0x3993BB, 0x3613D1, 0x3913E0, 0x3913F5,
+  0x37940A, 0x39141C, 0x351431, 0x34143E, 0x369449, 0x371459,
+  0x36946A, 0x38147A, 0x39148D, 0x3894A2, 0x3814B6, 0x3694C9,
+  0x3814D9, 0x3594EC, 0x3714FA, 0x35150B, 0x321518, 0x36151F,
+  0x35952E, 0x32153C, 0x319543, 0x359549, 0x231557, 0x22155F,
+  0x231565, 0x23156D, 0x311575, 0x23157A, 0x231582, 0x22958A,
+  0x219591, 0x419596, 0x37159D, 0x3715AE, 0x3795BF, 0x3615D1,
+  0x2295E0, 0x3595E7, 0x4215F5, 0x3215FD, 0x331604, 0x39160D,
+  0x361622, 0x389631, 0x371645, 0x399656, 0x35966C, 0x42167A,
+  0x321682, 0x319689, 0x33168F, 0x359698, 0x3416A6, 0x3696B1,
+  0x3916C1, 0x3696D6, 0x3416E6, 0x3196F1, 0x3196F7, 0x3416FD,
+  0x369708, 0x331718, 0x229721, 0x329728, 0x229730, 0x221737,
+  0x11973D, 0x219741, 0x231746, 0x23174E, 0x219756, 0x41975B,
+  0x349762, 0x22976E, 0x651775, 0x349785, 0x329791, 0x351799,
+  0x3717A6, 0x3517B7, 0x4217C4, 0x3497CC, 0x4217D8, 0x2317E0,
+  0x2317E8, 0x3217F0, 0x3417F7, 0x229802, 0x231809, 0x229811,
+  0x219818, 0x23181D, 0x419825, 0x23182C, 0x229834, 0x14183B,
+  0x351844, 0x361851, 0x381860, 0x329873, 0x34987B, 0x229887,
+  0x42188E, 0x339896, 0x3518A0, 0x3818AD, 0x3598C0, 0x3698CE,
+  0x3298DE, 0x3518E6, 0x3398F3, 0x3598FD, 0x37190B, 0x37991C,
+  0x22192E, 0x239934, 0x22993D, 0x421944, 0x23194C, 0x221954,
+  0x32995A, 0x321962, 0x219969, 0x32996E, 0x331976, 0x31997F,
+  0x331985, 0x32198E, 0x359995, 0x1619A3, 0x3899B0, 0x3699C4,
+  0x3699D4, 0x4199E4, 0x4219EB, 0x4219F3, 0x3319FB, 0x229A04,
+  0x329A0B, 0x419A13, 0x421A1A, 0x421A22, 0x419A2A, 0x211A31,
+  0x421A35, 0x421A3D, 0x221A45, 0x221A4B, 0x221A51, 0x231A57,
+  0x229A5F, 0x219A66, 0x419A6B, 0x421A72, 0x421A7A, 0x221A82,
+  0x221A88, 0x231A8E, 0x231A96, 0x219A9E, 0x221AA3, 0x371AA9,
+  0x221ABA, 0x319AC0, 0x321AC6, 0x421ACD, 0x231AD5, 0x231ADD,
+  0x311AE5, 0x519AEA, 0x319AF2, 0x229AF8, 0x229AFF, 0x219B06,
+  0x229B0B, 0x311B12, 0x419B17, 0x231B1E, 0x339B26, 0x329B30,
+  0x229B38, 0x229B3F, 0x329B46, 0x119B4E, 0x319B52, 0x331B58,
+  0x321B61, 0x341B68, 0x321B73, 0x319B7A, 0x321B80, 0x329B87,
+  0x331B8F, 0x341B98, 0x341BA3, 0x341BAE, 0x341BB9, 0x341BC4,
+  0x341BCF, 0x341BDA, 0x341BE5, 0x329BF0, 0x339BF8, 0x341C02,
+  0x331C0D, 0x229C16, 0x339C1D, 0x229C27, 0x421C2E, 0x311C36,
+  0x319C3B, 0x331C41, 0x319C4A, 0x321C50, 0x121C57, 0x331C5C,
+  0x341C65, 0x229C70, 0x421C77, 0x119C7F, 0x329C83, 0x339C8B,
+  0x231C95, 0x221C9D, 0x341CA3, 0x329CAE, 0x321CB6, 0x341CBD,
+  0x259CC8, 0x349CD5, 0x339CE1, 0x349CEB, 0x331CF7, 0x331D00,
+  0x341D09, 0x321D14, 0x341D1B, 0x329D26, 0x219D2E, 0x329D33,
+  0x331D3B, 0x339D44, 0x339D4E, 0x229D58, 0x331D5F, 0x221D68,
+  0x321D6E, 0x339D75, 0x419D7F, 0x331D86, 0x339D8F, 0x331D99,
+  0x339DA2, 0x341DAC, 0x349DB7, 0x341DC3, 0x339DCE, 0x379DD8,
+  0x369DEA, 0x341DFA, 0x331E05, 0x341E0E, 0x331E19, 0x361E22,
+  0x359E31, 0x369E3F, 0x389E4F, 0x389E63, 0x391E77, 0x329E8C,
+  0x329E94, 0x329E9C, 0x329EA4, 0x329EAC, 0x419EB4, 0x639EBB,
+  0x321EC8, 0x421ECF, 0x319ED7, 0x331EDD, 0x331EE6, 0x329EEF,
+  0x329EF7, 0x329EFF, 0x329F07, 0x321F0F, 0x329F16, 0x329F1E,
+  0x329F26, 0x329F2E, 0x329F36, 0x329F3E, 0x329F46, 0x329F4E,
+  0x321F56, 0x329F5D, 0x329F65, 0x329F6D, 0x329F75, 0x329F7D,
+  0x329F85, 0x331F8D, 0x329F96, 0x329F9E, 0x329FA6, 0x329FAE,
+  0x321FB6, 0x329FBD, 0x329FC5, 0x329FCD, 0x329FD5, 0x341FDD,
+  0x339FE8, 0x341FF2, 0x329FFD, 0x32A005, 0x32A00D, 0x32A015,
+  0x32201D, 0x32A024, 0x32A02C, 0x32A034, 0x32A03C, 0x32A044,
+  0x32A04C, 0x332054, 0x22A05D, 0x232064, 0x42206C, 0x32A074,
+  0x32207C, 0x32A083, 0x12208B, 0x32A090, 0x342098, 0x3220A3,
+  0x3320AA, 0x3220B3, 0x32A0BA, 0x32A0C2, 0x3320CA, 0x2320D3,
+  0x31A0DB, 0x3320E1, 0x3420EA, 0x3320F5, 0x3320FE, 0x332107,
+  0x622110, 0x32A11A, 0x22A122, 0x32A129, 0x232131, 0x232139,
+  0x22A141, 0x32A148, 0x33A150, 0x22215A, 0x22A160, 0x33A167,
+  0x222171, 0x24A177, 0x41A182, 0x222189, 0x32A18F, 0x34A197,
+  0x21A1A3, 0x31A1A8, 0x3221AE, 0x2221B5, 0x3321BB, 0x37A1C4,
+  0x3821D6, 0x2421E9, 0x3421F3, 0x3521FE, 0x35A20B, 0x35A219,
+  0x322227, 0x34222E, 0x332239, 0x33A242, 0x32A24C, 0x342254,
+  0x12A25F, 0x332265, 0x33A26E, 0x12A278, 0x13227E, 0x322285,
+  0x33228C, 0x352295, 0x34A2A2, 0x3222AE, 0x33A2B5, 0x3322BF,
+  0x4222C8, 0x3322D0, 0x2222D9, 0x3322DF, 0x32A2E8, 0x32A2F0,
+  0x4222F8, 0x322300, 0x32A307, 0x32230F, 0x32A316, 0x32A31E,
+  0x33A326, 0x33A330, 0x32A33A, 0x32A342, 0x33234A, 0x33A353,
+  0x31A35D, 0x342363, 0x33236E, 0x332377, 0x332380, 0x32A389,
+  0x622391, 0x33239B, 0x33A3A4, 0x35A3AE, 0x35A3BC, 0x3423CA,
+  0x3523D5, 0x2323E2, 0x3723EA, 0x37A3FB, 0x32A40D, 0x32A415,
+  0x34241D, 0x32A428, 0x332430, 0x322439, 0x322440, 0x332447,
+  0x332450, 0x322459, 0x322460, 0x32A467, 0x33A46F, 0x22A479,
+  0x232480, 0x21A488, 0x31248D, 0x33A492, 0x32A49C, 0x33A4A4,
+  0x21A4AE, 0x22A4B3, 0x33A4BA, 0x3324C4, 0x41A4CD, 0x32A4D4,
+  0x32A4DC, 0x3224E4, 0x33A4EB, 0x35A4F5, 0x32A503, 0x21A50B,
+  0x23A510, 0x32A519, 0x21A521, 0x232526, 0x36A52E, 0x33253E,
+  0x222547, 0x33254D, 0x332556, 0x13255F, 0x422566, 0x21A56E,
+  0x32A573, 0x34257B, 0x342586, 0x33A591, 0x34A59B, 0x3725A7,
+  0x34A5B8, 0x3725C4, 0x37A5D5, 0x3825E7, 0x3425FA, 0x332605,
+  0x33260E, 0x422617, 0x22261F, 0x322625, 0x23262C, 0x32A634,
+  0x32263C, 0x32A643, 0x32A64B, 0x32A653, 0x33A65B, 0x222665,
+  0x34266B, 0x32A676, 0x32267E, 0x232685, 0x33268D, 0x232696,
+  0x32269E, 0x22A6A5, 0x3326AC, 0x21A6B5, 0x2226BA, 0x3126C0,
+  0x32A6C5, 0x41A6CD, 0x3126D4, 0x2326D9, 0x31A6E1, 0x3326E7,
+  0x3126F0, 0x3426F5, 0x31A700, 0x31A706, 0x33270C, 0x22A715,
+  0x32A71C, 0x342724, 0x33272F, 0x322738, 0x33273F, 0x332748,
+  0x21A751, 0x322756, 0x22A75D, 0x422764, 0x32276C, 0x332773,
+  0x32A77C, 0x222784, 0x23A78A, 0x22A793, 0x33279A, 0x33A7A3,
+  0x32A7AD, 0x3527B5, 0x35A7C2, 0x1327D0, 0x3327D7, 0x32A7E0,
+  0x33A7E8, 0x3427F2, 0x32A7FD, 0x32A805, 0x32280D, 0x32A814,
+  0x32281C, 0x21A823, 0x21A828, 0x22282D, 0x322833, 0x12283A,
+  0x32A83F, 0x35A847, 0x362855, 0x36A864, 0x21A874, 0x332879,
+  0x332882, 0x32A88B, 0x332893, 0x41A89C, 0x32A8A3, 0x22A8AB,
+  0x3228B2, 0x32A8B9, 0x32A8C1, 0x2228C9, 0x4228CF, 0x3328D7,
+  0x3228E0, 0x32A8E7, 0x3428EF, 0x2328FA, 0x332902, 0x23290B,
+  0x332913, 0x33291C, 0x332925, 0x33292E, 0x332937, 0x232940,
+  0x332948, 0x332951, 0x33295A, 0x332963, 0x33296C, 0x332975,
+  0x32A97E, 0x32A986, 0x42298E, 0x312996, 0x31A99B, 0x2329A1,
+  0x22A9A9, 0x2329B0, 0x31A9B8, 0x2329BE, 0x22A9C6, 0x21A9CD,
+  0x2229D2, 0x3129D8, 0x31A9DD, 0x31A9E3, 0x3229E9, 0x3429F0,
+  0x31A9FB, 0x32AA01, 0x332A09, 0x33AA12, 0x342A1C, 0x622A27,
+  0x332A31, 0x41AA3A, 0x312A41, 0x31AA46, 0x32AA4C, 0x222A54,
+  0x312A5A, 0x31AA5F, 0x31AA65, 0x31AA6B, 0x31AA71, 0x322A77,
+  0x342A7E, 0x31AA89, 0x322A8F, 0x32AA96, 0x32AA9E, 0x422AA6,
+  0x12AAAE, 0x322AB4, 0x322ABB, 0x32AAC2, 0x32AACA, 0x112AD2,
+  0x322AD5, 0x32AADC, 0x32AAE4, 0x332AEC, 0x33AAF5, 0x34AAFF,
+  0x332B0B, 0x332B14, 0x34AB1D, 0x352B29, 0x33AB36, 0x332B40,
+  0x64AB49, 0x622B58, 0x322B62, 0x332B69, 0x222B72, 0x332B78,
+  0x232B81, 0x322B89, 0x33AB90, 0x32AB9A, 0x322BA2, 0x22ABA9,
+  0x332BB0, 0x34ABB9, 0x332BC5, 0x332BCE, 0x41ABD7, 0x342BDE,
+  0x342BE9, 0x32ABF4, 0x332BFC, 0x36AC05, 0x372C15, 0x422C26,
+  0x332C2E, 0x422C37, 0x332C3F, 0x232C48, 0x332C50, 0x332C59,
+  0x232C62, 0x312C6A, 0x22AC6F, 0x21AC76, 0x222C7B, 0x22AC81,
+  0x31AC88, 0x41AC8E, 0x232C95, 0x312C9D, 0x332CA2, 0x32ACAB,
+  0x332CB3, 0x32ACBC, 0x22ACC4, 0x22ACCB, 0x32ACD2, 0x342CDA,
+  0x342CE5, 0x22ACF0, 0x322CF7, 0x22ACFE, 0x312D05, 0x332D0A,
+  0x32AD13, 0x342D1B, 0x232D26, 0x31AD2E, 0x332D34, 0x342D3D,
+  0x342D48, 0x342D53, 0x33AD5E, 0x222D68, 0x22AD6E, 0x422D75,
+  0x222D7D, 0x32AD83, 0x232D8B, 0x422D93, 0x322D9B, 0x32ADA2,
+  0x33ADAA, 0x32ADB4, 0x332DBC, 0x32ADC5, 0x312DCD, 0x232DD2,
+  0x22ADDA, 0x222DE1, 0x22ADE7, 0x21ADEE, 0x41ADF3, 0x22ADFA,
+  0x422E01, 0x422E09, 0x232E11, 0x22AE19, 0x22AE20, 0x232E27,
+  0x232E2F, 0x21AE37, 0x41AE3C, 0x232E43, 0x222E4B, 0x222E51,
+  0x422E57, 0x422E5F, 0x32AE67, 0x322E6F, 0x332E76, 0x32AE7F,
+  0x312E87, 0x31AE8C, 0x322E92, 0x232E99, 0x342EA1, 0x332EAC,
+  0x232EB5, 0x322EBD, 0x32AEC4, 0x332ECC, 0x31AED5, 0x22AEDB,
+  0x322EE2, 0x32AEE9, 0x33AEF1, 0x332EFB, 0x332F04, 0x332F0D,
+  0x332F16, 0x33AF1F, 0x332F29, 0x31AF32, 0x332F38, 0x322F41,
+  0x62AF48, 0x32AF53, 0x32AF5B, 0x132F63, 0x132F6A, 0x32AF71,
+  0x33AF79, 0x33AF83, 0x232F8D, 0x232F95, 0x32AF9D, 0x122FA5,
+  0x21AFAA, 0x322FAF, 0x32AFB6, 0x332FBE, 0x33AFC7, 0x342FD1,
+  0x322FDC, 0x312FE3, 0x34AFE8, 0x36AFF4, 0x37B004, 0x36B016,
+  0x373026, 0x373037, 0x37B048, 0x38B05A, 0x39B06E, 0x373084,
+  0x31B095, 0x31B09B, 0x3230A1, 0x3430A8, 0x31B0B3, 0x32B0B9,
+  0x3330C1, 0x33B0CA, 0x3430D4, 0x6230DF, 0x3330E9, 0x3530F2,
+  0x33B0FF, 0x34B109, 0x353115, 0x33B122, 0x33B12C, 0x333136,
+  0x33313F, 0x41B148, 0x31314F, 0x31B154, 0x32B15A, 0x32B162,
+  0x33316A, 0x32B173, 0x22317B, 0x313181, 0x32B186, 0x34318E,
+  0x333199, 0x32B1A2, 0x2331AA, 0x3331B2, 0x3531BB, 0x31B1C8,
+  0x3231CE, 0x3431D5, 0x31B1E0, 0x3231E6, 0x32B1ED, 0x32B1F5,
+  0x32B1FD, 0x32B205, 0x32B20D, 0x36B215, 0x393225, 0x35323A,
+  0x373247, 0x36B258, 0x373268, 0x32B279, 0x423281, 0x333289,
+  0x33B292, 0x33329C, 0x1332A5, 0x31B2AC, 0x33B2B2, 0x3232BC,
+  0x1232C3, 0x3332C8, 0x32B2D1, 0x3432D9, 0x32B2E4, 0x3332EC,
+  0x31B2F5, 0x32B2FB, 0x333303, 0x42330C, 0x31B314, 0x32331A,
+  0x32B321, 0x32B329, 0x123331, 0x32B336, 0x33333E, 0x233347,
+  0x11334F, 0x323352, 0x32B359, 0x32B361, 0x333369, 0x333372,
+  0x33337B, 0x33B384, 0x33338E, 0x323397, 0x32B39E, 0x32B3A6,
+  0x3433AE, 0x33B3B9, 0x64B3C3, 0x6233D2, 0x32B3DC, 0x2233E4,
+  0x3233EA, 0x3233F1, 0x33B3F8, 0x31B402, 0x333408, 0x353411,
+  0x35341E, 0x34342B, 0x333436, 0x33343F, 0x21B448, 0x32B44D,
+  0x36B455, 0x41B465, 0x31B46C, 0x22B472, 0x31B479, 0x13347F,
+  0x333486, 0x23348F, 0x32B497, 0x33349F, 0x3334A8, 0x33B4B1,
+  0x3234BB, 0x3234C2, 0x3334C9, 0x3334D2, 0x4234DB, 0x3134E3,
+  0x4234E8, 0x3334F0, 0x2134F9, 0x3434FD, 0x32B508, 0x51B510,
+  0x61B518, 0x523521, 0x35352A, 0x37B537, 0x51B549, 0x61B551,
+  0x52355A, 0x35B563, 0x333571, 0x33357A, 0x32B583, 0x23358B,
+  0x623593, 0x31B59D, 0x5235A3, 0x52B5AC, 0x22B5B6, 0x33B5BD,
+  0x32B5C7, 0x33B5CF, 0x3435D9, 0x2235E4, 0x52B5EA, 0x5335F4,
+  0x3235FF, 0x233606, 0x23360E, 0x32B616, 0x54361E, 0x32362B,
+  0x21B632, 0x32B637, 0x31363F, 0x32B644, 0x33364C, 0x32B655,
+  0x33B65D, 0x52B667, 0x333671, 0x33367A, 0x52B683, 0x33368D,
+  0x33B696, 0x41B6A0, 0x51B6A7, 0x31B6AF, 0x3236B5, 0x52B6BC,
+  0x54B6C6, 0x5236D4, 0x32B6DD, 0x31B6E5, 0x3236EB, 0x32B6F2,
+  0x32B6FA, 0x32B702, 0x31370A, 0x31B70F, 0x323715, 0x31B71C,
+  0x223722, 0x32B728, 0x51B730, 0x32B738, 0x323740, 0x31B747,
+  0x35374D, 0x37B75A, 0x32376C, 0x52B773, 0x54B77D, 0x52378B,
+  0x32B794, 0x32B79C, 0x31B7A4, 0x32B7AA, 0x3337B2, 0x3237BB,
+  0x4237C2, 0x21B7CA, 0x32B7CF, 0x5337D7, 0x5437E2, 0x33B7EF,
+  0x33B7F9, 0x33B803, 0x32B80D, 0x33B815, 0x33B81F, 0x33B829,
+  0x323833, 0x34B83A, 0x633846, 0x52B852, 0x33B85C, 0x31B866,
+  0x33386C, 0x523875, 0x32B87E, 0x53B886, 0x32B892, 0x32B89A,
+  0x5338A2, 0x5338AD, 0x35B8B8, 0x32B8C6, 0x3338CE, 0x31B8D7,
+  0x3338DD, 0x5238E6, 0x4238EF, 0x34B8F7, 0x373903, 0x323914,
+  0x32B91B, 0x333923, 0x32B92C, 0x32B934, 0x33B93C, 0x33B946,
+  0x323950, 0x52B957, 0x32B961, 0x63B969, 0x34B976, 0x553982,
+  0x32B991, 0x53B999, 0x3239A5, 0x52B9AC, 0x32B9B6, 0x63B9BE,
+  0x34B9CB, 0x5539D7, 0x3239E6, 0x2339ED, 0x3239F5, 0x36B9FC,
+  0x37BA0C, 0x373A1E, 0x383A2F, 0x213A42, 0x11BA46, 0x333A4A,
+  0x32BA53, 0x333A5B, 0x333A64, 0x623A6D, 0x333A77, 0x623A80,
+  0x423A8A, 0x33BA92, 0x333A9C, 0x623AA5, 0x423AAF, 0x63BAB7,
+  0x333AC4, 0x63BACD, 0x62BADA, 0x32BAE5, 0x333AED, 0x32BAF6,
+  0x33BAFE, 0x333B08, 0x313B11, 0x233B16, 0x323B1E, 0x323B25,
+  0x22BB2C, 0x21BB33, 0x32BB38, 0x233B40, 0x323B48, 0x323B4F,
+  0x333B56, 0x22BB5F, 0x32BB66, 0x41BB6E, 0x223B75, 0x233B7B,
+  0x31BB83, 0x32BB89, 0x21BB91, 0x323B96, 0x32BB9D, 0x32BBA5,
+  0x33BBAD, 0x32BBB7, 0x31BBBF, 0x22BBC5, 0x22BBCC, 0x23BBD3,
+  0x323BDC, 0x333BE3, 0x423BEC, 0x323BF4, 0x32BBFB, 0x32BC03,
+  0x313C0B, 0x32BC10, 0x31BC18, 0x32BC1E, 0x33BC26, 0x223C30,
+  0x223C36, 0x333C3C, 0x323C45, 0x33BC4C, 0x31BC56, 0x323C5C,
+  0x233C63, 0x323C6B, 0x233C72, 0x333C7A, 0x343C83, 0x223C8E,
+  0x32BC94, 0x31BC9C, 0x223CA2, 0x343CA8, 0x333CB3, 0x32BCBC,
+  0x323CC4, 0x21BCCB, 0x133CD0, 0x133CD7, 0x333CDE, 0x323CE7,
+  0x33BCEE, 0x41BCF8, 0x21BCFF, 0x223D04, 0x333D0A, 0x32BD13,
+  0x213D1B, 0x34BD1F, 0x21BD2B, 0x333D30, 0x33BD39, 0x333D43,
+  0x123D4C, 0x343D51, 0x32BD5C, 0x33BD64, 0x333D6E, 0x333D77,
+  0x32BD80, 0x233D88, 0x33BD90, 0x33BD9A, 0x213DA4, 0x343DA8,
+  0x423DB3, 0x22BDBB, 0x313DC2, 0x31BDC7, 0x323DCD, 0x32BDD4,
+  0x31BDDC, 0x323DE2, 0x353DE9, 0x35BDF6, 0x333E04, 0x35BE0D,
+  0x343E1B, 0x343E26, 0x33BE31, 0x32BE3B, 0x333E43, 0x323E4C,
+  0x32BE53, 0x333E5B, 0x323E64, 0x343E6B, 0x343E76, 0x343E81,
+  0x323E8C, 0x333E93, 0x32BE9C, 0x333EA4, 0x423EAD, 0x21BEB5,
+  0x333EBA, 0x41BEC3, 0x323ECA, 0x423ED1, 0x333ED9, 0x423EE2,
+  0x35BEEA, 0x33BEF8, 0x12BF02, 0x33BF08, 0x123F12, 0x32BF17,
+  0x323F1F, 0x333F26, 0x32BF2F, 0x323F37, 0x523F3E, 0x233F47,
+  0x32BF4F, 0x343F57, 0x323F62, 0x32BF69, 0x32BF71, 0x333F79,
+  0x22BF82, 0x323F89, 0x333F90, 0x32BF99, 0x33BFA1, 0x32BFAB,
+  0x333FB3, 0x333FBC, 0x333FC5, 0x333FCE, 0x33BFD7, 0x333FE1,
+  0x32BFEA, 0x333FF2, 0x32BFFB, 0x34C003, 0x32C00F, 0x32C017,
+  0x13401F, 0x134026, 0x32C02D, 0x33C035, 0x33C03F, 0x234049,
+  0x234051, 0x32C059, 0x124061, 0x21C066, 0x32406B, 0x33C072,
+  0x32C07C, 0x334084, 0x32408D, 0x324094, 0x33C09B, 0x3440A5,
+  0x32C0B0, 0x3240B8, 0x21C0BF, 0x3340C4, 0x3340CD, 0x41C0D6,
+  0x32C0DD, 0x32C0E5, 0x3340ED, 0x21C0F6, 0x2240FB, 0x354101,
+  0x37410E, 0x38411F, 0x374132, 0x37C143, 0x38C155, 0x384169,
+  0x37C17C, 0x37C18E, 0x2241A0, 0x3641A6, 0x32C1B5, 0x32C1BD,
+  0x31C1C5, 0x3341CB, 0x3541D4, 0x32C1E1, 0x32C1E9, 0x32C1F1,
+  0x32C1F9, 0x32C201, 0x424209, 0x334211, 0x33C21A, 0x124224,
+  0x334229, 0x344232, 0x32C23D, 0x334245, 0x42424E, 0x31C256,
+  0x12425C, 0x32C261, 0x334269, 0x334272, 0x33427B, 0x324284,
+  0x32C28B, 0x32C293, 0x34429B, 0x33C2A6, 0x3142B0, 0x2342B5,
+  0x32C2BD, 0x3142C5, 0x31C2CA, 0x3242D0, 0x2342D7, 0x32C2DF,
+  0x31C2E7, 0x2342ED, 0x22C2F5, 0x3242FC, 0x32C303, 0x33430B,
+  0x344314, 0x32C31F, 0x21C327, 0x32432C, 0x32C333, 0x32C33B,
+  0x32C343, 0x33434B, 0x32C354, 0x33C35C, 0x224366, 0x12436C,
+  0x334371, 0x34437A, 0x32C385, 0x32438D, 0x41C394, 0x33439B,
+  0x32C3A4, 0x2343AC, 0x2243B4, 0x3443BA, 0x36C3C5, 0x21C3D5,
+  0x22C3DA, 0x2343E1, 0x2343E9, 0x31C3F1, 0x3343F7, 0x324400,
+  0x32C407, 0x32440F, 0x32C416, 0x32441E, 0x32C425, 0x32C42D,
+  0x33C435, 0x33C43F, 0x32C449, 0x36C451, 0x334461, 0x34446A,
+  0x324475, 0x32C47C, 0x31C484, 0x32448A, 0x62C491, 0x23449C,
+  0x11C4A4, 0x3244A8, 0x3344AF, 0x4244B8, 0x3344C0, 0x34C4C9,
+  0x3244D5, 0x32C4DC, 0x6344E4, 0x32C4F0, 0x6344F8, 0x32C504,
+  0x33450C, 0x344515, 0x354520, 0x32C52D, 0x334535, 0x34453E,
+  0x354549, 0x31C556, 0x33455C, 0x334565, 0x32456E, 0x32C575,
+  0x42457D, 0x334585, 0x33458E, 0x334597, 0x3245A0, 0x32C5A7,
+  0x27C5AF, 0x25C5C0, 0x22C5CD, 0x31C5D4, 0x3245DA, 0x3345E1,
+  0x3245EA, 0x33C5F1, 0x33C5FB, 0x32C605, 0x32C60D, 0x33C615,
+  0x33C61F, 0x334629, 0x344632, 0x34C63D, 0x34C649, 0x354655,
+  0x334662, 0x33466B, 0x334674, 0x32467D, 0x354684, 0x35C691,
+  0x33469F, 0x35C6A8, 0x3446B6, 0x3446C1, 0x33C6CC, 0x31C6D6,
+  0x3246DC, 0x31C6E3, 0x2246E9, 0x2246EF, 0x2246F5, 0x3246FB,
+  0x334702, 0x33C70B, 0x324715, 0x33C71C, 0x33C726, 0x33C730,
+  0x33C73A, 0x33C744, 0x32C74E, 0x32C756, 0x33C75E, 0x334768,
+  0x344771, 0x34C77C, 0x34C788, 0x354794, 0x3347A1, 0x3347AA,
+  0x3347B3, 0x32C7BC, 0x3347C4, 0x32C7CD, 0x33C7D5, 0x3347DF,
+  0x22C7E8, 0x3347EF, 0x21C7F8, 0x3247FD, 0x234804, 0x23480C,
+  0x21C814, 0x324819, 0x334820, 0x41C829, 0x334830, 0x34C839,
+  0x22C845, 0x24484C, 0x234856, 0x35C85E, 0x34486C, 0x334877,
+  0x32C880, 0x334888, 0x22C891, 0x22C898, 0x22C89F, 0x3348A6,
+  0x3448AF, 0x3348BA, 0x3248C3, 0x3248CA, 0x31C8D1, 0x3348D7,
+  0x3348E0, 0x4248E9, 0x33C8F1, 0x3248FB, 0x334902, 0x32C90B,
+  0x344913, 0x36491E, 0x36492D, 0x37493C, 0x34C94D, 0x36C959,
+  0x37C969, 0x33497B, 0x324984, 0x34498B, 0x33C996, 0x32C9A0,
+  0x33C9A8, 0x3449B2, 0x4249BD, 0x2249C5, 0x22C9CB, 0x2349D2,
+  0x32C9DA, 0x3849E2, 0x38C9F5, 0x324A09, 0x324A10, 0x234A17,
+  0x324A1F, 0x22CA26, 0x234A2D, 0x22CA35, 0x21CA3C, 0x32CA41,
+  0x234A49, 0x32CA51, 0x334A59, 0x41CA62, 0x234A69, 0x32CA71,
+  0x32CA79, 0x32CA81, 0x334A89, 0x344A92, 0x334A9D, 0x32CAA6,
+  0x22CAAE, 0x21CAB5, 0x22CABA, 0x424AC1, 0x33CAC9, 0x35CAD3,
+  0x36CAE1, 0x374AF1, 0x32CB02, 0x224B0A, 0x22CB10, 0x23CB17,
+  0x354B20, 0x334B2D, 0x344B36, 0x334B41, 0x22CB4A, 0x32CB51,
+  0x424B59, 0x32CB61, 0x234B69, 0x324B71, 0x32CB78, 0x32CB80,
+  0x224B88, 0x33CB8E, 0x324B98, 0x324B9F, 0x32CBA6, 0x32CBAE,
+  0x334BB6, 0x254BBF, 0x244BCB, 0x354BD5, 0x234BE2, 0x22CBEA,
+  0x34CBF1, 0x324BFD, 0x234C04, 0x244C0C, 0x664C16, 0x66CC28,
+  0x664C3B, 0x66CC4D, 0x244C60, 0x37CC6A, 0x384C7C, 0x21CC8F,
+  0x32CC94, 0x31CC9C, 0x334CA2, 0x32CCAB, 0x334CB3, 0x134CBC,
+  0x124CC3, 0x41CCC8, 0x32CCCF, 0x62CCD7, 0x62CCE2, 0x424CED,
+  0x32CCF5, 0x32CCFD, 0x424D05, 0x634D0D, 0x634D19, 0x634D25,
+  0x634D31, 0x33CD3D, 0x22CD47, 0x334D4E, 0x32CD57, 0x334D5F,
+  0x334D68, 0x41CD71, 0x424D78, 0x314D80, 0x314D85, 0x334D8A,
+  0x424D93, 0x324D9B, 0x32CDA2, 0x324DAA, 0x32CDB1, 0x41CDB9,
+  0x32CDC0, 0x32CDC8, 0x214DD0, 0x32CDD4, 0x32CDDC, 0x324DE4,
+  0x324DEB, 0x32CDF2, 0x424DFA, 0x334E02, 0x334E0B, 0x32CE14,
+  0x32CE1C, 0x424E24, 0x334E2C, 0x334E35, 0x32CE3E, 0x324E46,
+  0x334E4D, 0x234E56, 0x224E5E, 0x22CE64, 0x21CE6B, 0x21CE70,
+  0x41CE75, 0x224E7C, 0x424E82, 0x424E8A, 0x224E92, 0x224E98,
+  0x234E9E, 0x234EA6, 0x21CEAE, 0x224EB3, 0x334EB9, 0x224EC2,
+  0x41CEC8, 0x224ECF, 0x33CED5, 0x424EDF, 0x424EE7, 0x31CEEF,
+  0x324EF5
+};
+
+static const unsigned char cmark_entity_text[20220] = {
+  0x41, 0x45, 0x6C, 0x69, 0x67, 0xC3, 0x86, 0x41, 0x4D, 0x50, 0x26, 0x41,
+  0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, 0x81, 0x41, 0x62, 0x72, 0x65, 0x76,
+  0x65, 0xC4, 0x82, 0x41, 0x63, 0x69, 0x72, 0x63, 0xC3, 0x82, 0x41, 0x63,
+  0x79, 0xD0, 0x90, 0x41, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x84, 0x41, 0x67,
+  0x72, 0x61, 0x76, 0x65, 0xC3, 0x80, 0x41, 0x6C, 0x70, 0x68, 0x61, 0xCE,
+  0x91, 0x41, 0x6D, 0x61, 0x63, 0x72, 0xC4, 0x80, 0x41, 0x6E, 0x64, 0xE2,
+  0xA9, 0x93, 0x41, 0x6F, 0x67, 0x6F, 0x6E, 0xC4, 0x84, 0x41, 0x6F, 0x70,
+  0x66, 0xF0, 0x9D, 0x94, 0xB8, 0x41, 0x70, 0x70, 0x6C, 0x79, 0x46, 0x75,
+  0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xE2, 0x81, 0xA1, 0x41, 0x72, 0x69,
+  0x6E, 0x67, 0xC3, 0x85, 0x41, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0x9C,
+  0x41, 0x73, 0x73, 0x69, 0x67, 0x6E, 0xE2, 0x89, 0x94, 0x41, 0x74, 0x69,
+  0x6C, 0x64, 0x65, 0xC3, 0x83, 0x41, 0x75, 0x6D, 0x6C, 0xC3, 0x84, 0x42,
+  0x61, 0x63, 0x6B, 0x73, 0x6C, 0x61, 0x73, 0x68, 0xE2, 0x88, 0x96, 0x42,
+  0x61, 0x72, 0x76, 0xE2, 0xAB, 0xA7, 0x42, 0x61, 0x72, 0x77, 0x65, 0x64,
+  0xE2, 0x8C, 0x86, 0x42, 0x63, 0x79, 0xD0, 0x91, 0x42, 0x65, 0x63, 0x61,
+  0x75, 0x73, 0x65, 0xE2, 0x88, 0xB5, 0x42, 0x65, 0x72, 0x6E, 0x6F, 0x75,
+  0x6C, 0x6C, 0x69, 0x73, 0xE2, 0x84, 0xAC, 0x42, 0x65, 0x74, 0x61, 0xCE,
+  0x92, 0x42, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x85, 0x42, 0x6F, 0x70, 0x66,
+  0xF0, 0x9D, 0x94, 0xB9, 0x42, 0x72, 0x65, 0x76, 0x65, 0xCB, 0x98, 0x42,
+  0x73, 0x63, 0x72, 0xE2, 0x84, 0xAC, 0x42, 0x75, 0x6D, 0x70, 0x65, 0x71,
+  0xE2, 0x89, 0x8E, 0x43, 0x48, 0x63, 0x79, 0xD0, 0xA7, 0x43, 0x4F, 0x50,
+  0x59, 0xC2, 0xA9, 0x43, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC4, 0x86, 0x43,
+  0x61, 0x70, 0xE2, 0x8B, 0x92, 0x43, 0x61, 0x70, 0x69, 0x74, 0x61, 0x6C,
+  0x44, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x69, 0x61, 0x6C,
+  0x44, 0xE2, 0x85, 0x85, 0x43, 0x61, 0x79, 0x6C, 0x65, 0x79, 0x73, 0xE2,
+  0x84, 0xAD, 0x43, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC4, 0x8C, 0x43, 0x63,
+  0x65, 0x64, 0x69, 0x6C, 0xC3, 0x87, 0x43, 0x63, 0x69, 0x72, 0x63, 0xC4,
+  0x88, 0x43, 0x63, 0x6F, 0x6E, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xB0, 0x43,
+  0x64, 0x6F, 0x74, 0xC4, 0x8A, 0x43, 0x65, 0x64, 0x69, 0x6C, 0x6C, 0x61,
+  0xC2, 0xB8, 0x43, 0x65, 0x6E, 0x74, 0x65, 0x72, 0x44, 0x6F, 0x74, 0xC2,
+  0xB7, 0x43, 0x66, 0x72, 0xE2, 0x84, 0xAD, 0x43, 0x68, 0x69, 0xCE, 0xA7,
+  0x43, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x44, 0x6F, 0x74, 0xE2, 0x8A, 0x99,
+  0x43, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x4D, 0x69, 0x6E, 0x75, 0x73, 0xE2,
+  0x8A, 0x96, 0x43, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x50, 0x6C, 0x75, 0x73,
+  0xE2, 0x8A, 0x95, 0x43, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x54, 0x69, 0x6D,
+  0x65, 0x73, 0xE2, 0x8A, 0x97, 0x43, 0x6C, 0x6F, 0x63, 0x6B, 0x77, 0x69,
+  0x73, 0x65, 0x43, 0x6F, 0x6E, 0x74, 0x6F, 0x75, 0x72, 0x49, 0x6E, 0x74,
+  0x65, 0x67, 0x72, 0x61, 0x6C, 0xE2, 0x88, 0xB2, 0x43, 0x6C, 0x6F, 0x73,
+  0x65, 0x43, 0x75, 0x72, 0x6C, 0x79, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65,
+  0x51, 0x75, 0x6F, 0x74, 0x65, 0xE2, 0x80, 0x9D, 0x43, 0x6C, 0x6F, 0x73,
+  0x65, 0x43, 0x75, 0x72, 0x6C, 0x79, 0x51, 0x75, 0x6F, 0x74, 0x65, 0xE2,
+  0x80, 0x99, 0x43, 0x6F, 0x6C, 0x6F, 0x6E, 0xE2, 0x88, 0xB7, 0x43, 0x6F,
+  0x6C, 0x6F, 0x6E, 0x65, 0xE2, 0xA9, 0xB4, 0x43, 0x6F, 0x6E, 0x67, 0x72,
+  0x75, 0x65, 0x6E, 0x74, 0xE2, 0x89, 0xA1, 0x43, 0x6F, 0x6E, 0x69, 0x6E,
+  0x74, 0xE2, 0x88, 0xAF, 0x43, 0x6F, 0x6E, 0x74, 0x6F, 0x75, 0x72, 0x49,
+  0x6E, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6C, 0xE2, 0x88, 0xAE, 0x43, 0x6F,
+  0x70, 0x66, 0xE2, 0x84, 0x82, 0x43, 0x6F, 0x70, 0x72, 0x6F, 0x64, 0x75,
+  0x63, 0x74, 0xE2, 0x88, 0x90, 0x43, 0x6F, 0x75, 0x6E, 0x74, 0x65, 0x72,
+  0x43, 0x6C, 0x6F, 0x63, 0x6B, 0x77, 0x69, 0x73, 0x65, 0x43, 0x6F, 0x6E,
+  0x74, 0x6F, 0x75, 0x72, 0x49, 0x6E, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6C,
+  0xE2, 0x88, 0xB3, 0x43, 0x72, 0x6F, 0x73, 0x73, 0xE2, 0xA8, 0xAF, 0x43,
+  0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0x9E, 0x43, 0x75, 0x70, 0xE2, 0x8B,
+  0x93, 0x43, 0x75, 0x70, 0x43, 0x61, 0x70, 0xE2, 0x89, 0x8D, 0x44, 0x44,
+  0xE2, 0x85, 0x85, 0x44, 0x44, 0x6F, 0x74, 0x72, 0x61, 0x68, 0x64, 0xE2,
+  0xA4, 0x91, 0x44, 0x4A, 0x63, 0x79, 0xD0, 0x82, 0x44, 0x53, 0x63, 0x79,
+  0xD0, 0x85, 0x44, 0x5A, 0x63, 0x79, 0xD0, 0x8F, 0x44, 0x61, 0x67, 0x67,
+  0x65, 0x72, 0xE2, 0x80, 0xA1, 0x44, 0x61, 0x72, 0x72, 0xE2, 0x86, 0xA1,
+  0x44, 0x61, 0x73, 0x68, 0x76, 0xE2, 0xAB, 0xA4, 0x44, 0x63, 0x61, 0x72,
+  0x6F, 0x6E, 0xC4, 0x8E, 0x44, 0x63, 0x79, 0xD0, 0x94, 0x44, 0x65, 0x6C,
+  0xE2, 0x88, 0x87, 0x44, 0x65, 0x6C, 0x74, 0x61, 0xCE, 0x94, 0x44, 0x66,
+  0x72, 0xF0, 0x9D, 0x94, 0x87, 0x44, 0x69, 0x61, 0x63, 0x72, 0x69, 0x74,
+  0x69, 0x63, 0x61, 0x6C, 0x41, 0x63, 0x75, 0x74, 0x65, 0xC2, 0xB4, 0x44,
+  0x69, 0x61, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x44, 0x6F,
+  0x74, 0xCB, 0x99, 0x44, 0x69, 0x61, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63,
+  0x61, 0x6C, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x41, 0x63, 0x75, 0x74,
+  0x65, 0xCB, 0x9D, 0x44, 0x69, 0x61, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63,
+  0x61, 0x6C, 0x47, 0x72, 0x61, 0x76, 0x65, 0x60, 0x44, 0x69, 0x61, 0x63,
+  0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x54, 0x69, 0x6C, 0x64, 0x65,
+  0xCB, 0x9C, 0x44, 0x69, 0x61, 0x6D, 0x6F, 0x6E, 0x64, 0xE2, 0x8B, 0x84,
+  0x44, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x74, 0x69, 0x61, 0x6C,
+  0x44, 0xE2, 0x85, 0x86, 0x44, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x94, 0xBB,
+  0x44, 0x6F, 0x74, 0xC2, 0xA8, 0x44, 0x6F, 0x74, 0x44, 0x6F, 0x74, 0xE2,
+  0x83, 0x9C, 0x44, 0x6F, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89,
+  0x90, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x43, 0x6F, 0x6E, 0x74, 0x6F,
+  0x75, 0x72, 0x49, 0x6E, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6C, 0xE2, 0x88,
+  0xAF, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x44, 0x6F, 0x74, 0xC2, 0xA8,
+  0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72,
+  0x72, 0x6F, 0x77, 0xE2, 0x87, 0x93, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65,
+  0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x90,
+  0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x4C, 0x65, 0x66, 0x74, 0x52, 0x69,
+  0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x94, 0x44,
+  0x6F, 0x75, 0x62, 0x6C, 0x65, 0x4C, 0x65, 0x66, 0x74, 0x54, 0x65, 0x65,
+  0xE2, 0xAB, 0xA4, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x4C, 0x6F, 0x6E,
+  0x67, 0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F,
+  0xB8, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x4C, 0x6F, 0x6E, 0x67, 0x4C,
+  0x65, 0x66, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F,
+  0x77, 0xE2, 0x9F, 0xBA, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x4C, 0x6F,
+  0x6E, 0x67, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77,
+  0xE2, 0x9F, 0xB9, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x52, 0x69, 0x67,
+  0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x92, 0x44, 0x6F,
+  0x75, 0x62, 0x6C, 0x65, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, 0x65, 0x65,
+  0xE2, 0x8A, 0xA8, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x55, 0x70, 0x41,
+  0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x91, 0x44, 0x6F, 0x75, 0x62, 0x6C,
+  0x65, 0x55, 0x70, 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77,
+  0xE2, 0x87, 0x95, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x56, 0x65, 0x72,
+  0x74, 0x69, 0x63, 0x61, 0x6C, 0x42, 0x61, 0x72, 0xE2, 0x88, 0xA5, 0x44,
+  0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x93, 0x44,
+  0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, 0x42, 0x61, 0x72, 0xE2,
+  0xA4, 0x93, 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, 0x55,
+  0x70, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0xB5, 0x44, 0x6F, 0x77,
+  0x6E, 0x42, 0x72, 0x65, 0x76, 0x65, 0xCC, 0x91, 0x44, 0x6F, 0x77, 0x6E,
+  0x4C, 0x65, 0x66, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x56, 0x65, 0x63,
+  0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x90, 0x44, 0x6F, 0x77, 0x6E, 0x4C, 0x65,
+  0x66, 0x74, 0x54, 0x65, 0x65, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2,
+  0xA5, 0x9E, 0x44, 0x6F, 0x77, 0x6E, 0x4C, 0x65, 0x66, 0x74, 0x56, 0x65,
+  0x63, 0x74, 0x6F, 0x72, 0xE2, 0x86, 0xBD, 0x44, 0x6F, 0x77, 0x6E, 0x4C,
+  0x65, 0x66, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x42, 0x61, 0x72,
+  0xE2, 0xA5, 0x96, 0x44, 0x6F, 0x77, 0x6E, 0x52, 0x69, 0x67, 0x68, 0x74,
+  0x54, 0x65, 0x65, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x9F,
+  0x44, 0x6F, 0x77, 0x6E, 0x52, 0x69, 0x67, 0x68, 0x74, 0x56, 0x65, 0x63,
+  0x74, 0x6F, 0x72, 0xE2, 0x87, 0x81, 0x44, 0x6F, 0x77, 0x6E, 0x52, 0x69,
+  0x67, 0x68, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x42, 0x61, 0x72,
+  0xE2, 0xA5, 0x97, 0x44, 0x6F, 0x77, 0x6E, 0x54, 0x65, 0x65, 0xE2, 0x8A,
+  0xA4, 0x44, 0x6F, 0x77, 0x6E, 0x54, 0x65, 0x65, 0x41, 0x72, 0x72, 0x6F,
+  0x77, 0xE2, 0x86, 0xA7, 0x44, 0x6F, 0x77, 0x6E, 0x61, 0x72, 0x72, 0x6F,
+  0x77, 0xE2, 0x87, 0x93, 0x44, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0x9F,
+  0x44, 0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC4, 0x90, 0x45, 0x4E, 0x47, 0xC5,
+  0x8A, 0x45, 0x54, 0x48, 0xC3, 0x90, 0x45, 0x61, 0x63, 0x75, 0x74, 0x65,
+  0xC3, 0x89, 0x45, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC4, 0x9A, 0x45, 0x63,
+  0x69, 0x72, 0x63, 0xC3, 0x8A, 0x45, 0x63, 0x79, 0xD0, 0xAD, 0x45, 0x64,
+  0x6F, 0x74, 0xC4, 0x96, 0x45, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x88, 0x45,
+  0x67, 0x72, 0x61, 0x76, 0x65, 0xC3, 0x88, 0x45, 0x6C, 0x65, 0x6D, 0x65,
+  0x6E, 0x74, 0xE2, 0x88, 0x88, 0x45, 0x6D, 0x61, 0x63, 0x72, 0xC4, 0x92,
+  0x45, 0x6D, 0x70, 0x74, 0x79, 0x53, 0x6D, 0x61, 0x6C, 0x6C, 0x53, 0x71,
+  0x75, 0x61, 0x72, 0x65, 0xE2, 0x97, 0xBB, 0x45, 0x6D, 0x70, 0x74, 0x79,
+  0x56, 0x65, 0x72, 0x79, 0x53, 0x6D, 0x61, 0x6C, 0x6C, 0x53, 0x71, 0x75,
+  0x61, 0x72, 0x65, 0xE2, 0x96, 0xAB, 0x45, 0x6F, 0x67, 0x6F, 0x6E, 0xC4,
+  0x98, 0x45, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x94, 0xBC, 0x45, 0x70, 0x73,
+  0x69, 0x6C, 0x6F, 0x6E, 0xCE, 0x95, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2,
+  0xA9, 0xB5, 0x45, 0x71, 0x75, 0x61, 0x6C, 0x54, 0x69, 0x6C, 0x64, 0x65,
+  0xE2, 0x89, 0x82, 0x45, 0x71, 0x75, 0x69, 0x6C, 0x69, 0x62, 0x72, 0x69,
+  0x75, 0x6D, 0xE2, 0x87, 0x8C, 0x45, 0x73, 0x63, 0x72, 0xE2, 0x84, 0xB0,
+  0x45, 0x73, 0x69, 0x6D, 0xE2, 0xA9, 0xB3, 0x45, 0x74, 0x61, 0xCE, 0x97,
+  0x45, 0x75, 0x6D, 0x6C, 0xC3, 0x8B, 0x45, 0x78, 0x69, 0x73, 0x74, 0x73,
+  0xE2, 0x88, 0x83, 0x45, 0x78, 0x70, 0x6F, 0x6E, 0x65, 0x6E, 0x74, 0x69,
+  0x61, 0x6C, 0x45, 0xE2, 0x85, 0x87, 0x46, 0x63, 0x79, 0xD0, 0xA4, 0x46,
+  0x66, 0x72, 0xF0, 0x9D, 0x94, 0x89, 0x46, 0x69, 0x6C, 0x6C, 0x65, 0x64,
+  0x53, 0x6D, 0x61, 0x6C, 0x6C, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0xE2,
+  0x97, 0xBC, 0x46, 0x69, 0x6C, 0x6C, 0x65, 0x64, 0x56, 0x65, 0x72, 0x79,
+  0x53, 0x6D, 0x61, 0x6C, 0x6C, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0xE2,
+  0x96, 0xAA, 0x46, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x94, 0xBD, 0x46, 0x6F,
+  0x72, 0x41, 0x6C, 0x6C, 0xE2, 0x88, 0x80, 0x46, 0x6F, 0x75, 0x72, 0x69,
+  0x65, 0x72, 0x74, 0x72, 0x66, 0xE2, 0x84, 0xB1, 0x46, 0x73, 0x63, 0x72,
+  0xE2, 0x84, 0xB1, 0x47, 0x4A, 0x63, 0x79, 0xD0, 0x83, 0x47, 0x54, 0x3E,
+  0x47, 0x61, 0x6D, 0x6D, 0x61, 0xCE, 0x93, 0x47, 0x61, 0x6D, 0x6D, 0x61,
+  0x64, 0xCF, 0x9C, 0x47, 0x62, 0x72, 0x65, 0x76, 0x65, 0xC4, 0x9E, 0x47,
+  0x63, 0x65, 0x64, 0x69, 0x6C, 0xC4, 0xA2, 0x47, 0x63, 0x69, 0x72, 0x63,
+  0xC4, 0x9C, 0x47, 0x63, 0x79, 0xD0, 0x93, 0x47, 0x64, 0x6F, 0x74, 0xC4,
+  0xA0, 0x47, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x8A, 0x47, 0x67, 0xE2, 0x8B,
+  0x99, 0x47, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x94, 0xBE, 0x47, 0x72, 0x65,
+  0x61, 0x74, 0x65, 0x72, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xA5,
+  0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x45, 0x71, 0x75, 0x61, 0x6C,
+  0x4C, 0x65, 0x73, 0x73, 0xE2, 0x8B, 0x9B, 0x47, 0x72, 0x65, 0x61, 0x74,
+  0x65, 0x72, 0x46, 0x75, 0x6C, 0x6C, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2,
+  0x89, 0xA7, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x47, 0x72, 0x65,
+  0x61, 0x74, 0x65, 0x72, 0xE2, 0xAA, 0xA2, 0x47, 0x72, 0x65, 0x61, 0x74,
+  0x65, 0x72, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xB7, 0x47, 0x72, 0x65,
+  0x61, 0x74, 0x65, 0x72, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71, 0x75,
+  0x61, 0x6C, 0xE2, 0xA9, 0xBE, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72,
+  0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xB3, 0x47, 0x73, 0x63, 0x72,
+  0xF0, 0x9D, 0x92, 0xA2, 0x47, 0x74, 0xE2, 0x89, 0xAB, 0x48, 0x41, 0x52,
+  0x44, 0x63, 0x79, 0xD0, 0xAA, 0x48, 0x61, 0x63, 0x65, 0x6B, 0xCB, 0x87,
+  0x48, 0x61, 0x74, 0x5E, 0x48, 0x63, 0x69, 0x72, 0x63, 0xC4, 0xA4, 0x48,
+  0x66, 0x72, 0xE2, 0x84, 0x8C, 0x48, 0x69, 0x6C, 0x62, 0x65, 0x72, 0x74,
+  0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, 0x84, 0x8B, 0x48, 0x6F, 0x70, 0x66,
+  0xE2, 0x84, 0x8D, 0x48, 0x6F, 0x72, 0x69, 0x7A, 0x6F, 0x6E, 0x74, 0x61,
+  0x6C, 0x4C, 0x69, 0x6E, 0x65, 0xE2, 0x94, 0x80, 0x48, 0x73, 0x63, 0x72,
+  0xE2, 0x84, 0x8B, 0x48, 0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC4, 0xA6, 0x48,
+  0x75, 0x6D, 0x70, 0x44, 0x6F, 0x77, 0x6E, 0x48, 0x75, 0x6D, 0x70, 0xE2,
+  0x89, 0x8E, 0x48, 0x75, 0x6D, 0x70, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2,
+  0x89, 0x8F, 0x49, 0x45, 0x63, 0x79, 0xD0, 0x95, 0x49, 0x4A, 0x6C, 0x69,
+  0x67, 0xC4, 0xB2, 0x49, 0x4F, 0x63, 0x79, 0xD0, 0x81, 0x49, 0x61, 0x63,
+  0x75, 0x74, 0x65, 0xC3, 0x8D, 0x49, 0x63, 0x69, 0x72, 0x63, 0xC3, 0x8E,
+  0x49, 0x63, 0x79, 0xD0, 0x98, 0x49, 0x64, 0x6F, 0x74, 0xC4, 0xB0, 0x49,
+  0x66, 0x72, 0xE2, 0x84, 0x91, 0x49, 0x67, 0x72, 0x61, 0x76, 0x65, 0xC3,
+  0x8C, 0x49, 0x6D, 0xE2, 0x84, 0x91, 0x49, 0x6D, 0x61, 0x63, 0x72, 0xC4,
+  0xAA, 0x49, 0x6D, 0x61, 0x67, 0x69, 0x6E, 0x61, 0x72, 0x79, 0x49, 0xE2,
+  0x85, 0x88, 0x49, 0x6D, 0x70, 0x6C, 0x69, 0x65, 0x73, 0xE2, 0x87, 0x92,
+  0x49, 0x6E, 0x74, 0xE2, 0x88, 0xAC, 0x49, 0x6E, 0x74, 0x65, 0x67, 0x72,
+  0x61, 0x6C, 0xE2, 0x88, 0xAB, 0x49, 0x6E, 0x74, 0x65, 0x72, 0x73, 0x65,
+  0x63, 0x74, 0x69, 0x6F, 0x6E, 0xE2, 0x8B, 0x82, 0x49, 0x6E, 0x76, 0x69,
+  0x73, 0x69, 0x62, 0x6C, 0x65, 0x43, 0x6F, 0x6D, 0x6D, 0x61, 0xE2, 0x81,
+  0xA3, 0x49, 0x6E, 0x76, 0x69, 0x73, 0x69, 0x62, 0x6C, 0x65, 0x54, 0x69,
+  0x6D, 0x65, 0x73, 0xE2, 0x81, 0xA2, 0x49, 0x6F, 0x67, 0x6F, 0x6E, 0xC4,
+  0xAE, 0x49, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x80, 0x49, 0x6F, 0x74,
+  0x61, 0xCE, 0x99, 0x49, 0x73, 0x63, 0x72, 0xE2, 0x84, 0x90, 0x49, 0x74,
+  0x69, 0x6C, 0x64, 0x65, 0xC4, 0xA8, 0x49, 0x75, 0x6B, 0x63, 0x79, 0xD0,
+  0x86, 0x49, 0x75, 0x6D, 0x6C, 0xC3, 0x8F, 0x4A, 0x63, 0x69, 0x72, 0x63,
+  0xC4, 0xB4, 0x4A, 0x63, 0x79, 0xD0, 0x99, 0x4A, 0x66, 0x72, 0xF0, 0x9D,
+  0x94, 0x8D, 0x4A, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x81, 0x4A, 0x73,
+  0x63, 0x72, 0xF0, 0x9D, 0x92, 0xA5, 0x4A, 0x73, 0x65, 0x72, 0x63, 0x79,
+  0xD0, 0x88, 0x4A, 0x75, 0x6B, 0x63, 0x79, 0xD0, 0x84, 0x4B, 0x48, 0x63,
+  0x79, 0xD0, 0xA5, 0x4B, 0x4A, 0x63, 0x79, 0xD0, 0x8C, 0x4B, 0x61, 0x70,
+  0x70, 0x61, 0xCE, 0x9A, 0x4B, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC4, 0xB6,
+  0x4B, 0x63, 0x79, 0xD0, 0x9A, 0x4B, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x8E,
+  0x4B, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x82, 0x4B, 0x73, 0x63, 0x72,
+  0xF0, 0x9D, 0x92, 0xA6, 0x4C, 0x4A, 0x63, 0x79, 0xD0, 0x89, 0x4C, 0x54,
+  0x3C, 0x4C, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC4, 0xB9, 0x4C, 0x61, 0x6D,
+  0x62, 0x64, 0x61, 0xCE, 0x9B, 0x4C, 0x61, 0x6E, 0x67, 0xE2, 0x9F, 0xAA,
+  0x4C, 0x61, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x74, 0x72, 0x66, 0xE2, 0x84,
+  0x92, 0x4C, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x9E, 0x4C, 0x63, 0x61, 0x72,
+  0x6F, 0x6E, 0xC4, 0xBD, 0x4C, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC4, 0xBB,
+  0x4C, 0x63, 0x79, 0xD0, 0x9B, 0x4C, 0x65, 0x66, 0x74, 0x41, 0x6E, 0x67,
+  0x6C, 0x65, 0x42, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0xE2, 0x9F, 0xA8,
+  0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x90,
+  0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0x42, 0x61, 0x72,
+  0xE2, 0x87, 0xA4, 0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77,
+  0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87,
+  0x86, 0x4C, 0x65, 0x66, 0x74, 0x43, 0x65, 0x69, 0x6C, 0x69, 0x6E, 0x67,
+  0xE2, 0x8C, 0x88, 0x4C, 0x65, 0x66, 0x74, 0x44, 0x6F, 0x75, 0x62, 0x6C,
+  0x65, 0x42, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0xE2, 0x9F, 0xA6, 0x4C,
+  0x65, 0x66, 0x74, 0x44, 0x6F, 0x77, 0x6E, 0x54, 0x65, 0x65, 0x56, 0x65,
+  0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0xA1, 0x4C, 0x65, 0x66, 0x74, 0x44,
+  0x6F, 0x77, 0x6E, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0x87, 0x83,
+  0x4C, 0x65, 0x66, 0x74, 0x44, 0x6F, 0x77, 0x6E, 0x56, 0x65, 0x63, 0x74,
+  0x6F, 0x72, 0x42, 0x61, 0x72, 0xE2, 0xA5, 0x99, 0x4C, 0x65, 0x66, 0x74,
+  0x46, 0x6C, 0x6F, 0x6F, 0x72, 0xE2, 0x8C, 0x8A, 0x4C, 0x65, 0x66, 0x74,
+  0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86,
+  0x94, 0x4C, 0x65, 0x66, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x56, 0x65,
+  0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x8E, 0x4C, 0x65, 0x66, 0x74, 0x54,
+  0x65, 0x65, 0xE2, 0x8A, 0xA3, 0x4C, 0x65, 0x66, 0x74, 0x54, 0x65, 0x65,
+  0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0xA4, 0x4C, 0x65, 0x66, 0x74,
+  0x54, 0x65, 0x65, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x9A,
+  0x4C, 0x65, 0x66, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65,
+  0xE2, 0x8A, 0xB2, 0x4C, 0x65, 0x66, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E,
+  0x67, 0x6C, 0x65, 0x42, 0x61, 0x72, 0xE2, 0xA7, 0x8F, 0x4C, 0x65, 0x66,
+  0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x45, 0x71, 0x75,
+  0x61, 0x6C, 0xE2, 0x8A, 0xB4, 0x4C, 0x65, 0x66, 0x74, 0x55, 0x70, 0x44,
+  0x6F, 0x77, 0x6E, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x91,
+  0x4C, 0x65, 0x66, 0x74, 0x55, 0x70, 0x54, 0x65, 0x65, 0x56, 0x65, 0x63,
+  0x74, 0x6F, 0x72, 0xE2, 0xA5, 0xA0, 0x4C, 0x65, 0x66, 0x74, 0x55, 0x70,
+  0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0x86, 0xBF, 0x4C, 0x65, 0x66,
+  0x74, 0x55, 0x70, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x42, 0x61, 0x72,
+  0xE2, 0xA5, 0x98, 0x4C, 0x65, 0x66, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6F,
+  0x72, 0xE2, 0x86, 0xBC, 0x4C, 0x65, 0x66, 0x74, 0x56, 0x65, 0x63, 0x74,
+  0x6F, 0x72, 0x42, 0x61, 0x72, 0xE2, 0xA5, 0x92, 0x4C, 0x65, 0x66, 0x74,
+  0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x90, 0x4C, 0x65, 0x66, 0x74,
+  0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87,
+  0x94, 0x4C, 0x65, 0x73, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6C, 0x47, 0x72,
+  0x65, 0x61, 0x74, 0x65, 0x72, 0xE2, 0x8B, 0x9A, 0x4C, 0x65, 0x73, 0x73,
+  0x46, 0x75, 0x6C, 0x6C, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xA6,
+  0x4C, 0x65, 0x73, 0x73, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0xE2,
+  0x89, 0xB6, 0x4C, 0x65, 0x73, 0x73, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0xAA,
+  0xA1, 0x4C, 0x65, 0x73, 0x73, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71,
+  0x75, 0x61, 0x6C, 0xE2, 0xA9, 0xBD, 0x4C, 0x65, 0x73, 0x73, 0x54, 0x69,
+  0x6C, 0x64, 0x65, 0xE2, 0x89, 0xB2, 0x4C, 0x66, 0x72, 0xF0, 0x9D, 0x94,
+  0x8F, 0x4C, 0x6C, 0xE2, 0x8B, 0x98, 0x4C, 0x6C, 0x65, 0x66, 0x74, 0x61,
+  0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x9A, 0x4C, 0x6D, 0x69, 0x64, 0x6F,
+  0x74, 0xC4, 0xBF, 0x4C, 0x6F, 0x6E, 0x67, 0x4C, 0x65, 0x66, 0x74, 0x41,
+  0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xB5, 0x4C, 0x6F, 0x6E, 0x67, 0x4C,
+  0x65, 0x66, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F,
+  0x77, 0xE2, 0x9F, 0xB7, 0x4C, 0x6F, 0x6E, 0x67, 0x52, 0x69, 0x67, 0x68,
+  0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xB6, 0x4C, 0x6F, 0x6E,
+  0x67, 0x6C, 0x65, 0x66, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F,
+  0xB8, 0x4C, 0x6F, 0x6E, 0x67, 0x6C, 0x65, 0x66, 0x74, 0x72, 0x69, 0x67,
+  0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xBA, 0x4C, 0x6F,
+  0x6E, 0x67, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77,
+  0xE2, 0x9F, 0xB9, 0x4C, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x83, 0x4C,
+  0x6F, 0x77, 0x65, 0x72, 0x4C, 0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F,
+  0x77, 0xE2, 0x86, 0x99, 0x4C, 0x6F, 0x77, 0x65, 0x72, 0x52, 0x69, 0x67,
+  0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x98, 0x4C, 0x73,
+  0x63, 0x72, 0xE2, 0x84, 0x92, 0x4C, 0x73, 0x68, 0xE2, 0x86, 0xB0, 0x4C,
+  0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC5, 0x81, 0x4C, 0x74, 0xE2, 0x89, 0xAA,
+  0x4D, 0x61, 0x70, 0xE2, 0xA4, 0x85, 0x4D, 0x63, 0x79, 0xD0, 0x9C, 0x4D,
+  0x65, 0x64, 0x69, 0x75, 0x6D, 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, 0x81,
+  0x9F, 0x4D, 0x65, 0x6C, 0x6C, 0x69, 0x6E, 0x74, 0x72, 0x66, 0xE2, 0x84,
+  0xB3, 0x4D, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x90, 0x4D, 0x69, 0x6E, 0x75,
+  0x73, 0x50, 0x6C, 0x75, 0x73, 0xE2, 0x88, 0x93, 0x4D, 0x6F, 0x70, 0x66,
+  0xF0, 0x9D, 0x95, 0x84, 0x4D, 0x73, 0x63, 0x72, 0xE2, 0x84, 0xB3, 0x4D,
+  0x75, 0xCE, 0x9C, 0x4E, 0x4A, 0x63, 0x79, 0xD0, 0x8A, 0x4E, 0x61, 0x63,
+  0x75, 0x74, 0x65, 0xC5, 0x83, 0x4E, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5,
+  0x87, 0x4E, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0x85, 0x4E, 0x63, 0x79,
+  0xD0, 0x9D, 0x4E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4D, 0x65,
+  0x64, 0x69, 0x75, 0x6D, 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, 0x80, 0x8B,
+  0x4E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x54, 0x68, 0x69, 0x63,
+  0x6B, 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, 0x80, 0x8B, 0x4E, 0x65, 0x67,
+  0x61, 0x74, 0x69, 0x76, 0x65, 0x54, 0x68, 0x69, 0x6E, 0x53, 0x70, 0x61,
+  0x63, 0x65, 0xE2, 0x80, 0x8B, 0x4E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76,
+  0x65, 0x56, 0x65, 0x72, 0x79, 0x54, 0x68, 0x69, 0x6E, 0x53, 0x70, 0x61,
+  0x63, 0x65, 0xE2, 0x80, 0x8B, 0x4E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x47,
+  0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65,
+  0x72, 0xE2, 0x89, 0xAB, 0x4E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4C, 0x65,
+  0x73, 0x73, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xAA, 0x4E, 0x65, 0x77,
+  0x4C, 0x69, 0x6E, 0x65, 0x0A, 0x4E, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x91,
+  0x4E, 0x6F, 0x42, 0x72, 0x65, 0x61, 0x6B, 0xE2, 0x81, 0xA0, 0x4E, 0x6F,
+  0x6E, 0x42, 0x72, 0x65, 0x61, 0x6B, 0x69, 0x6E, 0x67, 0x53, 0x70, 0x61,
+  0x63, 0x65, 0xC2, 0xA0, 0x4E, 0x6F, 0x70, 0x66, 0xE2, 0x84, 0x95, 0x4E,
+  0x6F, 0x74, 0xE2, 0xAB, 0xAC, 0x4E, 0x6F, 0x74, 0x43, 0x6F, 0x6E, 0x67,
+  0x72, 0x75, 0x65, 0x6E, 0x74, 0xE2, 0x89, 0xA2, 0x4E, 0x6F, 0x74, 0x43,
+  0x75, 0x70, 0x43, 0x61, 0x70, 0xE2, 0x89, 0xAD, 0x4E, 0x6F, 0x74, 0x44,
+  0x6F, 0x75, 0x62, 0x6C, 0x65, 0x56, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61,
+  0x6C, 0x42, 0x61, 0x72, 0xE2, 0x88, 0xA6, 0x4E, 0x6F, 0x74, 0x45, 0x6C,
+  0x65, 0x6D, 0x65, 0x6E, 0x74, 0xE2, 0x88, 0x89, 0x4E, 0x6F, 0x74, 0x45,
+  0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xA0, 0x4E, 0x6F, 0x74, 0x45, 0x71,
+  0x75, 0x61, 0x6C, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0x82, 0xCC,
+  0xB8, 0x4E, 0x6F, 0x74, 0x45, 0x78, 0x69, 0x73, 0x74, 0x73, 0xE2, 0x88,
+  0x84, 0x4E, 0x6F, 0x74, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0xE2,
+  0x89, 0xAF, 0x4E, 0x6F, 0x74, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72,
+  0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xB1, 0x4E, 0x6F, 0x74, 0x47,
+  0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x46, 0x75, 0x6C, 0x6C, 0x45, 0x71,
+  0x75, 0x61, 0x6C, 0xE2, 0x89, 0xA7, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x47,
+  0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65,
+  0x72, 0xE2, 0x89, 0xAB, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x47, 0x72, 0x65,
+  0x61, 0x74, 0x65, 0x72, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xB9, 0x4E,
+  0x6F, 0x74, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x53, 0x6C, 0x61,
+  0x6E, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0xA9, 0xBE, 0xCC, 0xB8,
+  0x4E, 0x6F, 0x74, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x54, 0x69,
+  0x6C, 0x64, 0x65, 0xE2, 0x89, 0xB5, 0x4E, 0x6F, 0x74, 0x48, 0x75, 0x6D,
+  0x70, 0x44, 0x6F, 0x77, 0x6E, 0x48, 0x75, 0x6D, 0x70, 0xE2, 0x89, 0x8E,
+  0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x48, 0x75, 0x6D, 0x70, 0x45, 0x71, 0x75,
+  0x61, 0x6C, 0xE2, 0x89, 0x8F, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x4C, 0x65,
+  0x66, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x8B,
+  0xAA, 0x4E, 0x6F, 0x74, 0x4C, 0x65, 0x66, 0x74, 0x54, 0x72, 0x69, 0x61,
+  0x6E, 0x67, 0x6C, 0x65, 0x42, 0x61, 0x72, 0xE2, 0xA7, 0x8F, 0xCC, 0xB8,
+  0x4E, 0x6F, 0x74, 0x4C, 0x65, 0x66, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E,
+  0x67, 0x6C, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8B, 0xAC, 0x4E,
+  0x6F, 0x74, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xAE, 0x4E, 0x6F, 0x74,
+  0x4C, 0x65, 0x73, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0xB0,
+  0x4E, 0x6F, 0x74, 0x4C, 0x65, 0x73, 0x73, 0x47, 0x72, 0x65, 0x61, 0x74,
+  0x65, 0x72, 0xE2, 0x89, 0xB8, 0x4E, 0x6F, 0x74, 0x4C, 0x65, 0x73, 0x73,
+  0x4C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xAA, 0xCC, 0xB8, 0x4E, 0x6F, 0x74,
+  0x4C, 0x65, 0x73, 0x73, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71, 0x75,
+  0x61, 0x6C, 0xE2, 0xA9, 0xBD, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x4C, 0x65,
+  0x73, 0x73, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xB4, 0x4E, 0x6F,
+  0x74, 0x4E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x47, 0x72, 0x65, 0x61, 0x74,
+  0x65, 0x72, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0xE2, 0xAA, 0xA2,
+  0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x4E, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4C,
+  0x65, 0x73, 0x73, 0x4C, 0x65, 0x73, 0x73, 0xE2, 0xAA, 0xA1, 0xCC, 0xB8,
+  0x4E, 0x6F, 0x74, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65, 0x73, 0xE2,
+  0x8A, 0x80, 0x4E, 0x6F, 0x74, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65,
+  0x73, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0xAA, 0xAF, 0xCC, 0xB8, 0x4E,
+  0x6F, 0x74, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65, 0x73, 0x53, 0x6C,
+  0x61, 0x6E, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8B, 0xA0, 0x4E,
+  0x6F, 0x74, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x45, 0x6C, 0x65,
+  0x6D, 0x65, 0x6E, 0x74, 0xE2, 0x88, 0x8C, 0x4E, 0x6F, 0x74, 0x52, 0x69,
+  0x67, 0x68, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2,
+  0x8B, 0xAB, 0x4E, 0x6F, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, 0x72,
+  0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x42, 0x61, 0x72, 0xE2, 0xA7, 0x90,
+  0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, 0x72,
+  0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2,
+  0x8B, 0xAD, 0x4E, 0x6F, 0x74, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53,
+  0x75, 0x62, 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x8F, 0xCC, 0xB8, 0x4E, 0x6F,
+  0x74, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53, 0x75, 0x62, 0x73, 0x65,
+  0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8B, 0xA2, 0x4E, 0x6F, 0x74,
+  0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x73,
+  0x65, 0x74, 0xE2, 0x8A, 0x90, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x53, 0x71,
+  0x75, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x73, 0x65, 0x74,
+  0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8B, 0xA3, 0x4E, 0x6F, 0x74, 0x53,
+  0x75, 0x62, 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x82, 0xE2, 0x83, 0x92, 0x4E,
+  0x6F, 0x74, 0x53, 0x75, 0x62, 0x73, 0x65, 0x74, 0x45, 0x71, 0x75, 0x61,
+  0x6C, 0xE2, 0x8A, 0x88, 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x63, 0x63, 0x65,
+  0x65, 0x64, 0x73, 0xE2, 0x8A, 0x81, 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x63,
+  0x63, 0x65, 0x65, 0x64, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0xAA,
+  0xB0, 0xCC, 0xB8, 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65,
+  0x64, 0x73, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C,
+  0xE2, 0x8B, 0xA1, 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65,
+  0x64, 0x73, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xBF, 0xCC, 0xB8,
+  0x4E, 0x6F, 0x74, 0x53, 0x75, 0x70, 0x65, 0x72, 0x73, 0x65, 0x74, 0xE2,
+  0x8A, 0x83, 0xE2, 0x83, 0x92, 0x4E, 0x6F, 0x74, 0x53, 0x75, 0x70, 0x65,
+  0x72, 0x73, 0x65, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8A, 0x89,
+  0x4E, 0x6F, 0x74, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0x81, 0x4E,
+  0x6F, 0x74, 0x54, 0x69, 0x6C, 0x64, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6C,
+  0xE2, 0x89, 0x84, 0x4E, 0x6F, 0x74, 0x54, 0x69, 0x6C, 0x64, 0x65, 0x46,
+  0x75, 0x6C, 0x6C, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0x87, 0x4E,
+  0x6F, 0x74, 0x54, 0x69, 0x6C, 0x64, 0x65, 0x54, 0x69, 0x6C, 0x64, 0x65,
+  0xE2, 0x89, 0x89, 0x4E, 0x6F, 0x74, 0x56, 0x65, 0x72, 0x74, 0x69, 0x63,
+  0x61, 0x6C, 0x42, 0x61, 0x72, 0xE2, 0x88, 0xA4, 0x4E, 0x73, 0x63, 0x72,
+  0xF0, 0x9D, 0x92, 0xA9, 0x4E, 0x74, 0x69, 0x6C, 0x64, 0x65, 0xC3, 0x91,
+  0x4E, 0x75, 0xCE, 0x9D, 0x4F, 0x45, 0x6C, 0x69, 0x67, 0xC5, 0x92, 0x4F,
+  0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, 0x93, 0x4F, 0x63, 0x69, 0x72, 0x63,
+  0xC3, 0x94, 0x4F, 0x63, 0x79, 0xD0, 0x9E, 0x4F, 0x64, 0x62, 0x6C, 0x61,
+  0x63, 0xC5, 0x90, 0x4F, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x92, 0x4F, 0x67,
+  0x72, 0x61, 0x76, 0x65, 0xC3, 0x92, 0x4F, 0x6D, 0x61, 0x63, 0x72, 0xC5,
+  0x8C, 0x4F, 0x6D, 0x65, 0x67, 0x61, 0xCE, 0xA9, 0x4F, 0x6D, 0x69, 0x63,
+  0x72, 0x6F, 0x6E, 0xCE, 0x9F, 0x4F, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95,
+  0x86, 0x4F, 0x70, 0x65, 0x6E, 0x43, 0x75, 0x72, 0x6C, 0x79, 0x44, 0x6F,
+  0x75, 0x62, 0x6C, 0x65, 0x51, 0x75, 0x6F, 0x74, 0x65, 0xE2, 0x80, 0x9C,
+  0x4F, 0x70, 0x65, 0x6E, 0x43, 0x75, 0x72, 0x6C, 0x79, 0x51, 0x75, 0x6F,
+  0x74, 0x65, 0xE2, 0x80, 0x98, 0x4F, 0x72, 0xE2, 0xA9, 0x94, 0x4F, 0x73,
+  0x63, 0x72, 0xF0, 0x9D, 0x92, 0xAA, 0x4F, 0x73, 0x6C, 0x61, 0x73, 0x68,
+  0xC3, 0x98, 0x4F, 0x74, 0x69, 0x6C, 0x64, 0x65, 0xC3, 0x95, 0x4F, 0x74,
+  0x69, 0x6D, 0x65, 0x73, 0xE2, 0xA8, 0xB7, 0x4F, 0x75, 0x6D, 0x6C, 0xC3,
+  0x96, 0x4F, 0x76, 0x65, 0x72, 0x42, 0x61, 0x72, 0xE2, 0x80, 0xBE, 0x4F,
+  0x76, 0x65, 0x72, 0x42, 0x72, 0x61, 0x63, 0x65, 0xE2, 0x8F, 0x9E, 0x4F,
+  0x76, 0x65, 0x72, 0x42, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0xE2, 0x8E,
+  0xB4, 0x4F, 0x76, 0x65, 0x72, 0x50, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x68,
+  0x65, 0x73, 0x69, 0x73, 0xE2, 0x8F, 0x9C, 0x50, 0x61, 0x72, 0x74, 0x69,
+  0x61, 0x6C, 0x44, 0xE2, 0x88, 0x82, 0x50, 0x63, 0x79, 0xD0, 0x9F, 0x50,
+  0x66, 0x72, 0xF0, 0x9D, 0x94, 0x93, 0x50, 0x68, 0x69, 0xCE, 0xA6, 0x50,
+  0x69, 0xCE, 0xA0, 0x50, 0x6C, 0x75, 0x73, 0x4D, 0x69, 0x6E, 0x75, 0x73,
+  0xC2, 0xB1, 0x50, 0x6F, 0x69, 0x6E, 0x63, 0x61, 0x72, 0x65, 0x70, 0x6C,
+  0x61, 0x6E, 0x65, 0xE2, 0x84, 0x8C, 0x50, 0x6F, 0x70, 0x66, 0xE2, 0x84,
+  0x99, 0x50, 0x72, 0xE2, 0xAA, 0xBB, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64,
+  0x65, 0x73, 0xE2, 0x89, 0xBA, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65,
+  0x73, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0xAA, 0xAF, 0x50, 0x72, 0x65,
+  0x63, 0x65, 0x64, 0x65, 0x73, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71,
+  0x75, 0x61, 0x6C, 0xE2, 0x89, 0xBC, 0x50, 0x72, 0x65, 0x63, 0x65, 0x64,
+  0x65, 0x73, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0xBE, 0x50, 0x72,
+  0x69, 0x6D, 0x65, 0xE2, 0x80, 0xB3, 0x50, 0x72, 0x6F, 0x64, 0x75, 0x63,
+  0x74, 0xE2, 0x88, 0x8F, 0x50, 0x72, 0x6F, 0x70, 0x6F, 0x72, 0x74, 0x69,
+  0x6F, 0x6E, 0xE2, 0x88, 0xB7, 0x50, 0x72, 0x6F, 0x70, 0x6F, 0x72, 0x74,
+  0x69, 0x6F, 0x6E, 0x61, 0x6C, 0xE2, 0x88, 0x9D, 0x50, 0x73, 0x63, 0x72,
+  0xF0, 0x9D, 0x92, 0xAB, 0x50, 0x73, 0x69, 0xCE, 0xA8, 0x51, 0x55, 0x4F,
+  0x54, 0x22, 0x51, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x94, 0x51, 0x6F, 0x70,
+  0x66, 0xE2, 0x84, 0x9A, 0x51, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xAC,
+  0x52, 0x42, 0x61, 0x72, 0x72, 0xE2, 0xA4, 0x90, 0x52, 0x45, 0x47, 0xC2,
+  0xAE, 0x52, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0x94, 0x52, 0x61, 0x6E,
+  0x67, 0xE2, 0x9F, 0xAB, 0x52, 0x61, 0x72, 0x72, 0xE2, 0x86, 0xA0, 0x52,
+  0x61, 0x72, 0x72, 0x74, 0x6C, 0xE2, 0xA4, 0x96, 0x52, 0x63, 0x61, 0x72,
+  0x6F, 0x6E, 0xC5, 0x98, 0x52, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0x96,
+  0x52, 0x63, 0x79, 0xD0, 0xA0, 0x52, 0x65, 0xE2, 0x84, 0x9C, 0x52, 0x65,
+  0x76, 0x65, 0x72, 0x73, 0x65, 0x45, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74,
+  0xE2, 0x88, 0x8B, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x45, 0x71,
+  0x75, 0x69, 0x6C, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6D, 0xE2, 0x87, 0x8B,
+  0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x55, 0x70, 0x45, 0x71, 0x75,
+  0x69, 0x6C, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6D, 0xE2, 0xA5, 0xAF, 0x52,
+  0x66, 0x72, 0xE2, 0x84, 0x9C, 0x52, 0x68, 0x6F, 0xCE, 0xA1, 0x52, 0x69,
+  0x67, 0x68, 0x74, 0x41, 0x6E, 0x67, 0x6C, 0x65, 0x42, 0x72, 0x61, 0x63,
+  0x6B, 0x65, 0x74, 0xE2, 0x9F, 0xA9, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41,
+  0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x92, 0x52, 0x69, 0x67, 0x68, 0x74,
+  0x41, 0x72, 0x72, 0x6F, 0x77, 0x42, 0x61, 0x72, 0xE2, 0x87, 0xA5, 0x52,
+  0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0x4C, 0x65, 0x66,
+  0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x84, 0x52, 0x69, 0x67,
+  0x68, 0x74, 0x43, 0x65, 0x69, 0x6C, 0x69, 0x6E, 0x67, 0xE2, 0x8C, 0x89,
+  0x52, 0x69, 0x67, 0x68, 0x74, 0x44, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x42,
+  0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0xE2, 0x9F, 0xA7, 0x52, 0x69, 0x67,
+  0x68, 0x74, 0x44, 0x6F, 0x77, 0x6E, 0x54, 0x65, 0x65, 0x56, 0x65, 0x63,
+  0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x9D, 0x52, 0x69, 0x67, 0x68, 0x74, 0x44,
+  0x6F, 0x77, 0x6E, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0x87, 0x82,
+  0x52, 0x69, 0x67, 0x68, 0x74, 0x44, 0x6F, 0x77, 0x6E, 0x56, 0x65, 0x63,
+  0x74, 0x6F, 0x72, 0x42, 0x61, 0x72, 0xE2, 0xA5, 0x95, 0x52, 0x69, 0x67,
+  0x68, 0x74, 0x46, 0x6C, 0x6F, 0x6F, 0x72, 0xE2, 0x8C, 0x8B, 0x52, 0x69,
+  0x67, 0x68, 0x74, 0x54, 0x65, 0x65, 0xE2, 0x8A, 0xA2, 0x52, 0x69, 0x67,
+  0x68, 0x74, 0x54, 0x65, 0x65, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86,
+  0xA6, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, 0x65, 0x65, 0x56, 0x65, 0x63,
+  0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x9B, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54,
+  0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x8A, 0xB3, 0x52, 0x69,
+  0x67, 0x68, 0x74, 0x54, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x42,
+  0x61, 0x72, 0xE2, 0xA7, 0x90, 0x52, 0x69, 0x67, 0x68, 0x74, 0x54, 0x72,
+  0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2,
+  0x8A, 0xB5, 0x52, 0x69, 0x67, 0x68, 0x74, 0x55, 0x70, 0x44, 0x6F, 0x77,
+  0x6E, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0xA5, 0x8F, 0x52, 0x69,
+  0x67, 0x68, 0x74, 0x55, 0x70, 0x54, 0x65, 0x65, 0x56, 0x65, 0x63, 0x74,
+  0x6F, 0x72, 0xE2, 0xA5, 0x9C, 0x52, 0x69, 0x67, 0x68, 0x74, 0x55, 0x70,
+  0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0xE2, 0x86, 0xBE, 0x52, 0x69, 0x67,
+  0x68, 0x74, 0x55, 0x70, 0x56, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x42, 0x61,
+  0x72, 0xE2, 0xA5, 0x94, 0x52, 0x69, 0x67, 0x68, 0x74, 0x56, 0x65, 0x63,
+  0x74, 0x6F, 0x72, 0xE2, 0x87, 0x80, 0x52, 0x69, 0x67, 0x68, 0x74, 0x56,
+  0x65, 0x63, 0x74, 0x6F, 0x72, 0x42, 0x61, 0x72, 0xE2, 0xA5, 0x93, 0x52,
+  0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x92,
+  0x52, 0x6F, 0x70, 0x66, 0xE2, 0x84, 0x9D, 0x52, 0x6F, 0x75, 0x6E, 0x64,
+  0x49, 0x6D, 0x70, 0x6C, 0x69, 0x65, 0x73, 0xE2, 0xA5, 0xB0, 0x52, 0x72,
+  0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x9B,
+  0x52, 0x73, 0x63, 0x72, 0xE2, 0x84, 0x9B, 0x52, 0x73, 0x68, 0xE2, 0x86,
+  0xB1, 0x52, 0x75, 0x6C, 0x65, 0x44, 0x65, 0x6C, 0x61, 0x79, 0x65, 0x64,
+  0xE2, 0xA7, 0xB4, 0x53, 0x48, 0x43, 0x48, 0x63, 0x79, 0xD0, 0xA9, 0x53,
+  0x48, 0x63, 0x79, 0xD0, 0xA8, 0x53, 0x4F, 0x46, 0x54, 0x63, 0x79, 0xD0,
+  0xAC, 0x53, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0x9A, 0x53, 0x63, 0xE2,
+  0xAA, 0xBC, 0x53, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5, 0xA0, 0x53, 0x63,
+  0x65, 0x64, 0x69, 0x6C, 0xC5, 0x9E, 0x53, 0x63, 0x69, 0x72, 0x63, 0xC5,
+  0x9C, 0x53, 0x63, 0x79, 0xD0, 0xA1, 0x53, 0x66, 0x72, 0xF0, 0x9D, 0x94,
+  0x96, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72,
+  0x72, 0x6F, 0x77, 0xE2, 0x86, 0x93, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x4C,
+  0x65, 0x66, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x90, 0x53,
+  0x68, 0x6F, 0x72, 0x74, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72,
+  0x6F, 0x77, 0xE2, 0x86, 0x92, 0x53, 0x68, 0x6F, 0x72, 0x74, 0x55, 0x70,
+  0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x91, 0x53, 0x69, 0x67, 0x6D,
+  0x61, 0xCE, 0xA3, 0x53, 0x6D, 0x61, 0x6C, 0x6C, 0x43, 0x69, 0x72, 0x63,
+  0x6C, 0x65, 0xE2, 0x88, 0x98, 0x53, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95,
+  0x8A, 0x53, 0x71, 0x72, 0x74, 0xE2, 0x88, 0x9A, 0x53, 0x71, 0x75, 0x61,
+  0x72, 0x65, 0xE2, 0x96, 0xA1, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x49,
+  0x6E, 0x74, 0x65, 0x72, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0xE2,
+  0x8A, 0x93, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53, 0x75, 0x62, 0x73,
+  0x65, 0x74, 0xE2, 0x8A, 0x8F, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53,
+  0x75, 0x62, 0x73, 0x65, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8A,
+  0x91, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72,
+  0x73, 0x65, 0x74, 0xE2, 0x8A, 0x90, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65,
+  0x53, 0x75, 0x70, 0x65, 0x72, 0x73, 0x65, 0x74, 0x45, 0x71, 0x75, 0x61,
+  0x6C, 0xE2, 0x8A, 0x92, 0x53, 0x71, 0x75, 0x61, 0x72, 0x65, 0x55, 0x6E,
+  0x69, 0x6F, 0x6E, 0xE2, 0x8A, 0x94, 0x53, 0x73, 0x63, 0x72, 0xF0, 0x9D,
+  0x92, 0xAE, 0x53, 0x74, 0x61, 0x72, 0xE2, 0x8B, 0x86, 0x53, 0x75, 0x62,
+  0xE2, 0x8B, 0x90, 0x53, 0x75, 0x62, 0x73, 0x65, 0x74, 0xE2, 0x8B, 0x90,
+  0x53, 0x75, 0x62, 0x73, 0x65, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2,
+  0x8A, 0x86, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x73, 0xE2, 0x89,
+  0xBB, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x73, 0x45, 0x71, 0x75,
+  0x61, 0x6C, 0xE2, 0xAA, 0xB0, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64,
+  0x73, 0x53, 0x6C, 0x61, 0x6E, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2,
+  0x89, 0xBD, 0x53, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x73, 0x54, 0x69,
+  0x6C, 0x64, 0x65, 0xE2, 0x89, 0xBF, 0x53, 0x75, 0x63, 0x68, 0x54, 0x68,
+  0x61, 0x74, 0xE2, 0x88, 0x8B, 0x53, 0x75, 0x6D, 0xE2, 0x88, 0x91, 0x53,
+  0x75, 0x70, 0xE2, 0x8B, 0x91, 0x53, 0x75, 0x70, 0x65, 0x72, 0x73, 0x65,
+  0x74, 0xE2, 0x8A, 0x83, 0x53, 0x75, 0x70, 0x65, 0x72, 0x73, 0x65, 0x74,
+  0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x8A, 0x87, 0x53, 0x75, 0x70, 0x73,
+  0x65, 0x74, 0xE2, 0x8B, 0x91, 0x54, 0x48, 0x4F, 0x52, 0x4E, 0xC3, 0x9E,
+  0x54, 0x52, 0x41, 0x44, 0x45, 0xE2, 0x84, 0xA2, 0x54, 0x53, 0x48, 0x63,
+  0x79, 0xD0, 0x8B, 0x54, 0x53, 0x63, 0x79, 0xD0, 0xA6, 0x54, 0x61, 0x62,
+  0x09, 0x54, 0x61, 0x75, 0xCE, 0xA4, 0x54, 0x63, 0x61, 0x72, 0x6F, 0x6E,
+  0xC5, 0xA4, 0x54, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0xA2, 0x54, 0x63,
+  0x79, 0xD0, 0xA2, 0x54, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x97, 0x54, 0x68,
+  0x65, 0x72, 0x65, 0x66, 0x6F, 0x72, 0x65, 0xE2, 0x88, 0xB4, 0x54, 0x68,
+  0x65, 0x74, 0x61, 0xCE, 0x98, 0x54, 0x68, 0x69, 0x63, 0x6B, 0x53, 0x70,
+  0x61, 0x63, 0x65, 0xE2, 0x81, 0x9F, 0xE2, 0x80, 0x8A, 0x54, 0x68, 0x69,
+  0x6E, 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2, 0x80, 0x89, 0x54, 0x69, 0x6C,
+  0x64, 0x65, 0xE2, 0x88, 0xBC, 0x54, 0x69, 0x6C, 0x64, 0x65, 0x45, 0x71,
+  0x75, 0x61, 0x6C, 0xE2, 0x89, 0x83, 0x54, 0x69, 0x6C, 0x64, 0x65, 0x46,
+  0x75, 0x6C, 0x6C, 0x45, 0x71, 0x75, 0x61, 0x6C, 0xE2, 0x89, 0x85, 0x54,
+  0x69, 0x6C, 0x64, 0x65, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0x88,
+  0x54, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x8B, 0x54, 0x72, 0x69, 0x70,
+  0x6C, 0x65, 0x44, 0x6F, 0x74, 0xE2, 0x83, 0x9B, 0x54, 0x73, 0x63, 0x72,
+  0xF0, 0x9D, 0x92, 0xAF, 0x54, 0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC5, 0xA6,
+  0x55, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, 0x9A, 0x55, 0x61, 0x72, 0x72,
+  0xE2, 0x86, 0x9F, 0x55, 0x61, 0x72, 0x72, 0x6F, 0x63, 0x69, 0x72, 0xE2,
+  0xA5, 0x89, 0x55, 0x62, 0x72, 0x63, 0x79, 0xD0, 0x8E, 0x55, 0x62, 0x72,
+  0x65, 0x76, 0x65, 0xC5, 0xAC, 0x55, 0x63, 0x69, 0x72, 0x63, 0xC3, 0x9B,
+  0x55, 0x63, 0x79, 0xD0, 0xA3, 0x55, 0x64, 0x62, 0x6C, 0x61, 0x63, 0xC5,
+  0xB0, 0x55, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x98, 0x55, 0x67, 0x72, 0x61,
+  0x76, 0x65, 0xC3, 0x99, 0x55, 0x6D, 0x61, 0x63, 0x72, 0xC5, 0xAA, 0x55,
+  0x6E, 0x64, 0x65, 0x72, 0x42, 0x61, 0x72, 0x5F, 0x55, 0x6E, 0x64, 0x65,
+  0x72, 0x42, 0x72, 0x61, 0x63, 0x65, 0xE2, 0x8F, 0x9F, 0x55, 0x6E, 0x64,
+  0x65, 0x72, 0x42, 0x72, 0x61, 0x63, 0x6B, 0x65, 0x74, 0xE2, 0x8E, 0xB5,
+  0x55, 0x6E, 0x64, 0x65, 0x72, 0x50, 0x61, 0x72, 0x65, 0x6E, 0x74, 0x68,
+  0x65, 0x73, 0x69, 0x73, 0xE2, 0x8F, 0x9D, 0x55, 0x6E, 0x69, 0x6F, 0x6E,
+  0xE2, 0x8B, 0x83, 0x55, 0x6E, 0x69, 0x6F, 0x6E, 0x50, 0x6C, 0x75, 0x73,
+  0xE2, 0x8A, 0x8E, 0x55, 0x6F, 0x67, 0x6F, 0x6E, 0xC5, 0xB2, 0x55, 0x6F,
+  0x70, 0x66, 0xF0, 0x9D, 0x95, 0x8C, 0x55, 0x70, 0x41, 0x72, 0x72, 0x6F,
+  0x77, 0xE2, 0x86, 0x91, 0x55, 0x70, 0x41, 0x72, 0x72, 0x6F, 0x77, 0x42,
+  0x61, 0x72, 0xE2, 0xA4, 0x92, 0x55, 0x70, 0x41, 0x72, 0x72, 0x6F, 0x77,
+  0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x85,
+  0x55, 0x70, 0x44, 0x6F, 0x77, 0x6E, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2,
+  0x86, 0x95, 0x55, 0x70, 0x45, 0x71, 0x75, 0x69, 0x6C, 0x69, 0x62, 0x72,
+  0x69, 0x75, 0x6D, 0xE2, 0xA5, 0xAE, 0x55, 0x70, 0x54, 0x65, 0x65, 0xE2,
+  0x8A, 0xA5, 0x55, 0x70, 0x54, 0x65, 0x65, 0x41, 0x72, 0x72, 0x6F, 0x77,
+  0xE2, 0x86, 0xA5, 0x55, 0x70, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87,
+  0x91, 0x55, 0x70, 0x64, 0x6F, 0x77, 0x6E, 0x61, 0x72, 0x72, 0x6F, 0x77,
+  0xE2, 0x87, 0x95, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4C, 0x65, 0x66, 0x74,
+  0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x96, 0x55, 0x70, 0x70, 0x65,
+  0x72, 0x52, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, 0x6F, 0x77, 0xE2,
+  0x86, 0x97, 0x55, 0x70, 0x73, 0x69, 0xCF, 0x92, 0x55, 0x70, 0x73, 0x69,
+  0x6C, 0x6F, 0x6E, 0xCE, 0xA5, 0x55, 0x72, 0x69, 0x6E, 0x67, 0xC5, 0xAE,
+  0x55, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xB0, 0x55, 0x74, 0x69, 0x6C,
+  0x64, 0x65, 0xC5, 0xA8, 0x55, 0x75, 0x6D, 0x6C, 0xC3, 0x9C, 0x56, 0x44,
+  0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAB, 0x56, 0x62, 0x61, 0x72, 0xE2, 0xAB,
+  0xAB, 0x56, 0x63, 0x79, 0xD0, 0x92, 0x56, 0x64, 0x61, 0x73, 0x68, 0xE2,
+  0x8A, 0xA9, 0x56, 0x64, 0x61, 0x73, 0x68, 0x6C, 0xE2, 0xAB, 0xA6, 0x56,
+  0x65, 0x65, 0xE2, 0x8B, 0x81, 0x56, 0x65, 0x72, 0x62, 0x61, 0x72, 0xE2,
+  0x80, 0x96, 0x56, 0x65, 0x72, 0x74, 0xE2, 0x80, 0x96, 0x56, 0x65, 0x72,
+  0x74, 0x69, 0x63, 0x61, 0x6C, 0x42, 0x61, 0x72, 0xE2, 0x88, 0xA3, 0x56,
+  0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x4C, 0x69, 0x6E, 0x65, 0x7C,
+  0x56, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6C, 0x53, 0x65, 0x70, 0x61,
+  0x72, 0x61, 0x74, 0x6F, 0x72, 0xE2, 0x9D, 0x98, 0x56, 0x65, 0x72, 0x74,
+  0x69, 0x63, 0x61, 0x6C, 0x54, 0x69, 0x6C, 0x64, 0x65, 0xE2, 0x89, 0x80,
+  0x56, 0x65, 0x72, 0x79, 0x54, 0x68, 0x69, 0x6E, 0x53, 0x70, 0x61, 0x63,
+  0x65, 0xE2, 0x80, 0x8A, 0x56, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x99, 0x56,
+  0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x8D, 0x56, 0x73, 0x63, 0x72, 0xF0,
+  0x9D, 0x92, 0xB1, 0x56, 0x76, 0x64, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAA,
+  0x57, 0x63, 0x69, 0x72, 0x63, 0xC5, 0xB4, 0x57, 0x65, 0x64, 0x67, 0x65,
+  0xE2, 0x8B, 0x80, 0x57, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x9A, 0x57, 0x6F,
+  0x70, 0x66, 0xF0, 0x9D, 0x95, 0x8E, 0x57, 0x73, 0x63, 0x72, 0xF0, 0x9D,
+  0x92, 0xB2, 0x58, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x9B, 0x58, 0x69, 0xCE,
+  0x9E, 0x58, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x8F, 0x58, 0x73, 0x63,
+  0x72, 0xF0, 0x9D, 0x92, 0xB3, 0x59, 0x41, 0x63, 0x79, 0xD0, 0xAF, 0x59,
+  0x49, 0x63, 0x79, 0xD0, 0x87, 0x59, 0x55, 0x63, 0x79, 0xD0, 0xAE, 0x59,
+  0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, 0x9D, 0x59, 0x63, 0x69, 0x72, 0x63,
+  0xC5, 0xB6, 0x59, 0x63, 0x79, 0xD0, 0xAB, 0x59, 0x66, 0x72, 0xF0, 0x9D,
+  0x94, 0x9C, 0x59, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x90, 0x59, 0x73,
+  0x63, 0x72, 0xF0, 0x9D, 0x92, 0xB4, 0x59, 0x75, 0x6D, 0x6C, 0xC5, 0xB8,
+  0x5A, 0x48, 0x63, 0x79, 0xD0, 0x96, 0x5A, 0x61, 0x63, 0x75, 0x74, 0x65,
+  0xC5, 0xB9, 0x5A, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5, 0xBD, 0x5A, 0x63,
+  0x79, 0xD0, 0x97, 0x5A, 0x64, 0x6F, 0x74, 0xC5, 0xBB, 0x5A, 0x65, 0x72,
+  0x6F, 0x57, 0x69, 0x64, 0x74, 0x68, 0x53, 0x70, 0x61, 0x63, 0x65, 0xE2,
+  0x80, 0x8B, 0x5A, 0x65, 0x74, 0x61, 0xCE, 0x96, 0x5A, 0x66, 0x72, 0xE2,
+  0x84, 0xA8, 0x5A, 0x6F, 0x70, 0x66, 0xE2, 0x84, 0xA4, 0x5A, 0x73, 0x63,
+  0x72, 0xF0, 0x9D, 0x92, 0xB5, 0x61, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC3,
+  0xA1, 0x61, 0x62, 0x72, 0x65, 0x76, 0x65, 0xC4, 0x83, 0x61, 0x63, 0xE2,
+  0x88, 0xBE, 0x61, 0x63, 0x45, 0xE2, 0x88, 0xBE, 0xCC, 0xB3, 0x61, 0x63,
+  0x64, 0xE2, 0x88, 0xBF, 0x61, 0x63, 0x69, 0x72, 0x63, 0xC3, 0xA2, 0x61,
+  0x63, 0x75, 0x74, 0x65, 0xC2, 0xB4, 0x61, 0x63, 0x79, 0xD0, 0xB0, 0x61,
+  0x65, 0x6C, 0x69, 0x67, 0xC3, 0xA6, 0x61, 0x66, 0xE2, 0x81, 0xA1, 0x61,
+  0x66, 0x72, 0xF0, 0x9D, 0x94, 0x9E, 0x61, 0x67, 0x72, 0x61, 0x76, 0x65,
+  0xC3, 0xA0, 0x61, 0x6C, 0x65, 0x66, 0x73, 0x79, 0x6D, 0xE2, 0x84, 0xB5,
+  0x61, 0x6C, 0x65, 0x70, 0x68, 0xE2, 0x84, 0xB5, 0x61, 0x6C, 0x70, 0x68,
+  0x61, 0xCE, 0xB1, 0x61, 0x6D, 0x61, 0x63, 0x72, 0xC4, 0x81, 0x61, 0x6D,
+  0x61, 0x6C, 0x67, 0xE2, 0xA8, 0xBF, 0x61, 0x6D, 0x70, 0x26, 0x61, 0x6E,
+  0x64, 0xE2, 0x88, 0xA7, 0x61, 0x6E, 0x64, 0x61, 0x6E, 0x64, 0xE2, 0xA9,
+  0x95, 0x61, 0x6E, 0x64, 0x64, 0xE2, 0xA9, 0x9C, 0x61, 0x6E, 0x64, 0x73,
+  0x6C, 0x6F, 0x70, 0x65, 0xE2, 0xA9, 0x98, 0x61, 0x6E, 0x64, 0x76, 0xE2,
+  0xA9, 0x9A, 0x61, 0x6E, 0x67, 0xE2, 0x88, 0xA0, 0x61, 0x6E, 0x67, 0x65,
+  0xE2, 0xA6, 0xA4, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x88, 0xA0, 0x61,
+  0x6E, 0x67, 0x6D, 0x73, 0x64, 0xE2, 0x88, 0xA1, 0x61, 0x6E, 0x67, 0x6D,
+  0x73, 0x64, 0x61, 0x61, 0xE2, 0xA6, 0xA8, 0x61, 0x6E, 0x67, 0x6D, 0x73,
+  0x64, 0x61, 0x62, 0xE2, 0xA6, 0xA9, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64,
+  0x61, 0x63, 0xE2, 0xA6, 0xAA, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, 0x61,
+  0x64, 0xE2, 0xA6, 0xAB, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, 0x61, 0x65,
+  0xE2, 0xA6, 0xAC, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, 0x61, 0x66, 0xE2,
+  0xA6, 0xAD, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, 0x61, 0x67, 0xE2, 0xA6,
+  0xAE, 0x61, 0x6E, 0x67, 0x6D, 0x73, 0x64, 0x61, 0x68, 0xE2, 0xA6, 0xAF,
+  0x61, 0x6E, 0x67, 0x72, 0x74, 0xE2, 0x88, 0x9F, 0x61, 0x6E, 0x67, 0x72,
+  0x74, 0x76, 0x62, 0xE2, 0x8A, 0xBE, 0x61, 0x6E, 0x67, 0x72, 0x74, 0x76,
+  0x62, 0x64, 0xE2, 0xA6, 0x9D, 0x61, 0x6E, 0x67, 0x73, 0x70, 0x68, 0xE2,
+  0x88, 0xA2, 0x61, 0x6E, 0x67, 0x73, 0x74, 0xC3, 0x85, 0x61, 0x6E, 0x67,
+  0x7A, 0x61, 0x72, 0x72, 0xE2, 0x8D, 0xBC, 0x61, 0x6F, 0x67, 0x6F, 0x6E,
+  0xC4, 0x85, 0x61, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x92, 0x61, 0x70,
+  0xE2, 0x89, 0x88, 0x61, 0x70, 0x45, 0xE2, 0xA9, 0xB0, 0x61, 0x70, 0x61,
+  0x63, 0x69, 0x72, 0xE2, 0xA9, 0xAF, 0x61, 0x70, 0x65, 0xE2, 0x89, 0x8A,
+  0x61, 0x70, 0x69, 0x64, 0xE2, 0x89, 0x8B, 0x61, 0x70, 0x6F, 0x73, 0x27,
+  0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0xE2, 0x89, 0x88, 0x61, 0x70, 0x70,
+  0x72, 0x6F, 0x78, 0x65, 0x71, 0xE2, 0x89, 0x8A, 0x61, 0x72, 0x69, 0x6E,
+  0x67, 0xC3, 0xA5, 0x61, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xB6, 0x61,
+  0x73, 0x74, 0x2A, 0x61, 0x73, 0x79, 0x6D, 0x70, 0xE2, 0x89, 0x88, 0x61,
+  0x73, 0x79, 0x6D, 0x70, 0x65, 0x71, 0xE2, 0x89, 0x8D, 0x61, 0x74, 0x69,
+  0x6C, 0x64, 0x65, 0xC3, 0xA3, 0x61, 0x75, 0x6D, 0x6C, 0xC3, 0xA4, 0x61,
+  0x77, 0x63, 0x6F, 0x6E, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xB3, 0x61, 0x77,
+  0x69, 0x6E, 0x74, 0xE2, 0xA8, 0x91, 0x62, 0x4E, 0x6F, 0x74, 0xE2, 0xAB,
+  0xAD, 0x62, 0x61, 0x63, 0x6B, 0x63, 0x6F, 0x6E, 0x67, 0xE2, 0x89, 0x8C,
+  0x62, 0x61, 0x63, 0x6B, 0x65, 0x70, 0x73, 0x69, 0x6C, 0x6F, 0x6E, 0xCF,
+  0xB6, 0x62, 0x61, 0x63, 0x6B, 0x70, 0x72, 0x69, 0x6D, 0x65, 0xE2, 0x80,
+  0xB5, 0x62, 0x61, 0x63, 0x6B, 0x73, 0x69, 0x6D, 0xE2, 0x88, 0xBD, 0x62,
+  0x61, 0x63, 0x6B, 0x73, 0x69, 0x6D, 0x65, 0x71, 0xE2, 0x8B, 0x8D, 0x62,
+  0x61, 0x72, 0x76, 0x65, 0x65, 0xE2, 0x8A, 0xBD, 0x62, 0x61, 0x72, 0x77,
+  0x65, 0x64, 0xE2, 0x8C, 0x85, 0x62, 0x61, 0x72, 0x77, 0x65, 0x64, 0x67,
+  0x65, 0xE2, 0x8C, 0x85, 0x62, 0x62, 0x72, 0x6B, 0xE2, 0x8E, 0xB5, 0x62,
+  0x62, 0x72, 0x6B, 0x74, 0x62, 0x72, 0x6B, 0xE2, 0x8E, 0xB6, 0x62, 0x63,
+  0x6F, 0x6E, 0x67, 0xE2, 0x89, 0x8C, 0x62, 0x63, 0x79, 0xD0, 0xB1, 0x62,
+  0x64, 0x71, 0x75, 0x6F, 0xE2, 0x80, 0x9E, 0x62, 0x65, 0x63, 0x61, 0x75,
+  0x73, 0xE2, 0x88, 0xB5, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0xE2,
+  0x88, 0xB5, 0x62, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x76, 0xE2, 0xA6, 0xB0,
+  0x62, 0x65, 0x70, 0x73, 0x69, 0xCF, 0xB6, 0x62, 0x65, 0x72, 0x6E, 0x6F,
+  0x75, 0xE2, 0x84, 0xAC, 0x62, 0x65, 0x74, 0x61, 0xCE, 0xB2, 0x62, 0x65,
+  0x74, 0x68, 0xE2, 0x84, 0xB6, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6E,
+  0xE2, 0x89, 0xAC, 0x62, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0x9F, 0x62, 0x69,
+  0x67, 0x63, 0x61, 0x70, 0xE2, 0x8B, 0x82, 0x62, 0x69, 0x67, 0x63, 0x69,
+  0x72, 0x63, 0xE2, 0x97, 0xAF, 0x62, 0x69, 0x67, 0x63, 0x75, 0x70, 0xE2,
+  0x8B, 0x83, 0x62, 0x69, 0x67, 0x6F, 0x64, 0x6F, 0x74, 0xE2, 0xA8, 0x80,
+  0x62, 0x69, 0x67, 0x6F, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA8, 0x81, 0x62,
+  0x69, 0x67, 0x6F, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0xA8, 0x82, 0x62,
+  0x69, 0x67, 0x73, 0x71, 0x63, 0x75, 0x70, 0xE2, 0xA8, 0x86, 0x62, 0x69,
+  0x67, 0x73, 0x74, 0x61, 0x72, 0xE2, 0x98, 0x85, 0x62, 0x69, 0x67, 0x74,
+  0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x64, 0x6F, 0x77, 0x6E, 0xE2,
+  0x96, 0xBD, 0x62, 0x69, 0x67, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C,
+  0x65, 0x75, 0x70, 0xE2, 0x96, 0xB3, 0x62, 0x69, 0x67, 0x75, 0x70, 0x6C,
+  0x75, 0x73, 0xE2, 0xA8, 0x84, 0x62, 0x69, 0x67, 0x76, 0x65, 0x65, 0xE2,
+  0x8B, 0x81, 0x62, 0x69, 0x67, 0x77, 0x65, 0x64, 0x67, 0x65, 0xE2, 0x8B,
+  0x80, 0x62, 0x6B, 0x61, 0x72, 0x6F, 0x77, 0xE2, 0xA4, 0x8D, 0x62, 0x6C,
+  0x61, 0x63, 0x6B, 0x6C, 0x6F, 0x7A, 0x65, 0x6E, 0x67, 0x65, 0xE2, 0xA7,
+  0xAB, 0x62, 0x6C, 0x61, 0x63, 0x6B, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65,
+  0xE2, 0x96, 0xAA, 0x62, 0x6C, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x69, 0x61,
+  0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x96, 0xB4, 0x62, 0x6C, 0x61, 0x63, 0x6B,
+  0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x64, 0x6F, 0x77, 0x6E,
+  0xE2, 0x96, 0xBE, 0x62, 0x6C, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x69, 0x61,
+  0x6E, 0x67, 0x6C, 0x65, 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x97, 0x82, 0x62,
+  0x6C, 0x61, 0x63, 0x6B, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65,
+  0x72, 0x69, 0x67, 0x68, 0x74, 0xE2, 0x96, 0xB8, 0x62, 0x6C, 0x61, 0x6E,
+  0x6B, 0xE2, 0x90, 0xA3, 0x62, 0x6C, 0x6B, 0x31, 0x32, 0xE2, 0x96, 0x92,
+  0x62, 0x6C, 0x6B, 0x31, 0x34, 0xE2, 0x96, 0x91, 0x62, 0x6C, 0x6B, 0x33,
+  0x34, 0xE2, 0x96, 0x93, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0xE2, 0x96, 0x88,
+  0x62, 0x6E, 0x65, 0x3D, 0xE2, 0x83, 0xA5, 0x62, 0x6E, 0x65, 0x71, 0x75,
+  0x69, 0x76, 0xE2, 0x89, 0xA1, 0xE2, 0x83, 0xA5, 0x62, 0x6E, 0x6F, 0x74,
+  0xE2, 0x8C, 0x90, 0x62, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x93, 0x62,
+  0x6F, 0x74, 0xE2, 0x8A, 0xA5, 0x62, 0x6F, 0x74, 0x74, 0x6F, 0x6D, 0xE2,
+  0x8A, 0xA5, 0x62, 0x6F, 0x77, 0x74, 0x69, 0x65, 0xE2, 0x8B, 0x88, 0x62,
+  0x6F, 0x78, 0x44, 0x4C, 0xE2, 0x95, 0x97, 0x62, 0x6F, 0x78, 0x44, 0x52,
+  0xE2, 0x95, 0x94, 0x62, 0x6F, 0x78, 0x44, 0x6C, 0xE2, 0x95, 0x96, 0x62,
+  0x6F, 0x78, 0x44, 0x72, 0xE2, 0x95, 0x93, 0x62, 0x6F, 0x78, 0x48, 0xE2,
+  0x95, 0x90, 0x62, 0x6F, 0x78, 0x48, 0x44, 0xE2, 0x95, 0xA6, 0x62, 0x6F,
+  0x78, 0x48, 0x55, 0xE2, 0x95, 0xA9, 0x62, 0x6F, 0x78, 0x48, 0x64, 0xE2,
+  0x95, 0xA4, 0x62, 0x6F, 0x78, 0x48, 0x75, 0xE2, 0x95, 0xA7, 0x62, 0x6F,
+  0x78, 0x55, 0x4C, 0xE2, 0x95, 0x9D, 0x62, 0x6F, 0x78, 0x55, 0x52, 0xE2,
+  0x95, 0x9A, 0x62, 0x6F, 0x78, 0x55, 0x6C, 0xE2, 0x95, 0x9C, 0x62, 0x6F,
+  0x78, 0x55, 0x72, 0xE2, 0x95, 0x99, 0x62, 0x6F, 0x78, 0x56, 0xE2, 0x95,
+  0x91, 0x62, 0x6F, 0x78, 0x56, 0x48, 0xE2, 0x95, 0xAC, 0x62, 0x6F, 0x78,
+  0x56, 0x4C, 0xE2, 0x95, 0xA3, 0x62, 0x6F, 0x78, 0x56, 0x52, 0xE2, 0x95,
+  0xA0, 0x62, 0x6F, 0x78, 0x56, 0x68, 0xE2, 0x95, 0xAB, 0x62, 0x6F, 0x78,
+  0x56, 0x6C, 0xE2, 0x95, 0xA2, 0x62, 0x6F, 0x78, 0x56, 0x72, 0xE2, 0x95,
+  0x9F, 0x62, 0x6F, 0x78, 0x62, 0x6F, 0x78, 0xE2, 0xA7, 0x89, 0x62, 0x6F,
+  0x78, 0x64, 0x4C, 0xE2, 0x95, 0x95, 0x62, 0x6F, 0x78, 0x64, 0x52, 0xE2,
+  0x95, 0x92, 0x62, 0x6F, 0x78, 0x64, 0x6C, 0xE2, 0x94, 0x90, 0x62, 0x6F,
+  0x78, 0x64, 0x72, 0xE2, 0x94, 0x8C, 0x62, 0x6F, 0x78, 0x68, 0xE2, 0x94,
+  0x80, 0x62, 0x6F, 0x78, 0x68, 0x44, 0xE2, 0x95, 0xA5, 0x62, 0x6F, 0x78,
+  0x68, 0x55, 0xE2, 0x95, 0xA8, 0x62, 0x6F, 0x78, 0x68, 0x64, 0xE2, 0x94,
+  0xAC, 0x62, 0x6F, 0x78, 0x68, 0x75, 0xE2, 0x94, 0xB4, 0x62, 0x6F, 0x78,
+  0x6D, 0x69, 0x6E, 0x75, 0x73, 0xE2, 0x8A, 0x9F, 0x62, 0x6F, 0x78, 0x70,
+  0x6C, 0x75, 0x73, 0xE2, 0x8A, 0x9E, 0x62, 0x6F, 0x78, 0x74, 0x69, 0x6D,
+  0x65, 0x73, 0xE2, 0x8A, 0xA0, 0x62, 0x6F, 0x78, 0x75, 0x4C, 0xE2, 0x95,
+  0x9B, 0x62, 0x6F, 0x78, 0x75, 0x52, 0xE2, 0x95, 0x98, 0x62, 0x6F, 0x78,
+  0x75, 0x6C, 0xE2, 0x94, 0x98, 0x62, 0x6F, 0x78, 0x75, 0x72, 0xE2, 0x94,
+  0x94, 0x62, 0x6F, 0x78, 0x76, 0xE2, 0x94, 0x82, 0x62, 0x6F, 0x78, 0x76,
+  0x48, 0xE2, 0x95, 0xAA, 0x62, 0x6F, 0x78, 0x76, 0x4C, 0xE2, 0x95, 0xA1,
+  0x62, 0x6F, 0x78, 0x76, 0x52, 0xE2, 0x95, 0x9E, 0x62, 0x6F, 0x78, 0x76,
+  0x68, 0xE2, 0x94, 0xBC, 0x62, 0x6F, 0x78, 0x76, 0x6C, 0xE2, 0x94, 0xA4,
+  0x62, 0x6F, 0x78, 0x76, 0x72, 0xE2, 0x94, 0x9C, 0x62, 0x70, 0x72, 0x69,
+  0x6D, 0x65, 0xE2, 0x80, 0xB5, 0x62, 0x72, 0x65, 0x76, 0x65, 0xCB, 0x98,
+  0x62, 0x72, 0x76, 0x62, 0x61, 0x72, 0xC2, 0xA6, 0x62, 0x73, 0x63, 0x72,
+  0xF0, 0x9D, 0x92, 0xB7, 0x62, 0x73, 0x65, 0x6D, 0x69, 0xE2, 0x81, 0x8F,
+  0x62, 0x73, 0x69, 0x6D, 0xE2, 0x88, 0xBD, 0x62, 0x73, 0x69, 0x6D, 0x65,
+  0xE2, 0x8B, 0x8D, 0x62, 0x73, 0x6F, 0x6C, 0x5C, 0x62, 0x73, 0x6F, 0x6C,
+  0x62, 0xE2, 0xA7, 0x85, 0x62, 0x73, 0x6F, 0x6C, 0x68, 0x73, 0x75, 0x62,
+  0xE2, 0x9F, 0x88, 0x62, 0x75, 0x6C, 0x6C, 0xE2, 0x80, 0xA2, 0x62, 0x75,
+  0x6C, 0x6C, 0x65, 0x74, 0xE2, 0x80, 0xA2, 0x62, 0x75, 0x6D, 0x70, 0xE2,
+  0x89, 0x8E, 0x62, 0x75, 0x6D, 0x70, 0x45, 0xE2, 0xAA, 0xAE, 0x62, 0x75,
+  0x6D, 0x70, 0x65, 0xE2, 0x89, 0x8F, 0x62, 0x75, 0x6D, 0x70, 0x65, 0x71,
+  0xE2, 0x89, 0x8F, 0x63, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC4, 0x87, 0x63,
+  0x61, 0x70, 0xE2, 0x88, 0xA9, 0x63, 0x61, 0x70, 0x61, 0x6E, 0x64, 0xE2,
+  0xA9, 0x84, 0x63, 0x61, 0x70, 0x62, 0x72, 0x63, 0x75, 0x70, 0xE2, 0xA9,
+  0x89, 0x63, 0x61, 0x70, 0x63, 0x61, 0x70, 0xE2, 0xA9, 0x8B, 0x63, 0x61,
+  0x70, 0x63, 0x75, 0x70, 0xE2, 0xA9, 0x87, 0x63, 0x61, 0x70, 0x64, 0x6F,
+  0x74, 0xE2, 0xA9, 0x80, 0x63, 0x61, 0x70, 0x73, 0xE2, 0x88, 0xA9, 0xEF,
+  0xB8, 0x80, 0x63, 0x61, 0x72, 0x65, 0x74, 0xE2, 0x81, 0x81, 0x63, 0x61,
+  0x72, 0x6F, 0x6E, 0xCB, 0x87, 0x63, 0x63, 0x61, 0x70, 0x73, 0xE2, 0xA9,
+  0x8D, 0x63, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC4, 0x8D, 0x63, 0x63, 0x65,
+  0x64, 0x69, 0x6C, 0xC3, 0xA7, 0x63, 0x63, 0x69, 0x72, 0x63, 0xC4, 0x89,
+  0x63, 0x63, 0x75, 0x70, 0x73, 0xE2, 0xA9, 0x8C, 0x63, 0x63, 0x75, 0x70,
+  0x73, 0x73, 0x6D, 0xE2, 0xA9, 0x90, 0x63, 0x64, 0x6F, 0x74, 0xC4, 0x8B,
+  0x63, 0x65, 0x64, 0x69, 0x6C, 0xC2, 0xB8, 0x63, 0x65, 0x6D, 0x70, 0x74,
+  0x79, 0x76, 0xE2, 0xA6, 0xB2, 0x63, 0x65, 0x6E, 0x74, 0xC2, 0xA2, 0x63,
+  0x65, 0x6E, 0x74, 0x65, 0x72, 0x64, 0x6F, 0x74, 0xC2, 0xB7, 0x63, 0x66,
+  0x72, 0xF0, 0x9D, 0x94, 0xA0, 0x63, 0x68, 0x63, 0x79, 0xD1, 0x87, 0x63,
+  0x68, 0x65, 0x63, 0x6B, 0xE2, 0x9C, 0x93, 0x63, 0x68, 0x65, 0x63, 0x6B,
+  0x6D, 0x61, 0x72, 0x6B, 0xE2, 0x9C, 0x93, 0x63, 0x68, 0x69, 0xCF, 0x87,
+  0x63, 0x69, 0x72, 0xE2, 0x97, 0x8B, 0x63, 0x69, 0x72, 0x45, 0xE2, 0xA7,
+  0x83, 0x63, 0x69, 0x72, 0x63, 0xCB, 0x86, 0x63, 0x69, 0x72, 0x63, 0x65,
+  0x71, 0xE2, 0x89, 0x97, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x61, 0x72,
+  0x72, 0x6F, 0x77, 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x86, 0xBA, 0x63, 0x69,
+  0x72, 0x63, 0x6C, 0x65, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x72, 0x69, 0x67,
+  0x68, 0x74, 0xE2, 0x86, 0xBB, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x64,
+  0x52, 0xC2, 0xAE, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x64, 0x53, 0xE2,
+  0x93, 0x88, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x64, 0x61, 0x73, 0x74,
+  0xE2, 0x8A, 0x9B, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x64, 0x63, 0x69,
+  0x72, 0x63, 0xE2, 0x8A, 0x9A, 0x63, 0x69, 0x72, 0x63, 0x6C, 0x65, 0x64,
+  0x64, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0x9D, 0x63, 0x69, 0x72, 0x65, 0xE2,
+  0x89, 0x97, 0x63, 0x69, 0x72, 0x66, 0x6E, 0x69, 0x6E, 0x74, 0xE2, 0xA8,
+  0x90, 0x63, 0x69, 0x72, 0x6D, 0x69, 0x64, 0xE2, 0xAB, 0xAF, 0x63, 0x69,
+  0x72, 0x73, 0x63, 0x69, 0x72, 0xE2, 0xA7, 0x82, 0x63, 0x6C, 0x75, 0x62,
+  0x73, 0xE2, 0x99, 0xA3, 0x63, 0x6C, 0x75, 0x62, 0x73, 0x75, 0x69, 0x74,
+  0xE2, 0x99, 0xA3, 0x63, 0x6F, 0x6C, 0x6F, 0x6E, 0x3A, 0x63, 0x6F, 0x6C,
+  0x6F, 0x6E, 0x65, 0xE2, 0x89, 0x94, 0x63, 0x6F, 0x6C, 0x6F, 0x6E, 0x65,
+  0x71, 0xE2, 0x89, 0x94, 0x63, 0x6F, 0x6D, 0x6D, 0x61, 0x2C, 0x63, 0x6F,
+  0x6D, 0x6D, 0x61, 0x74, 0x40, 0x63, 0x6F, 0x6D, 0x70, 0xE2, 0x88, 0x81,
+  0x63, 0x6F, 0x6D, 0x70, 0x66, 0x6E, 0xE2, 0x88, 0x98, 0x63, 0x6F, 0x6D,
+  0x70, 0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0xE2, 0x88, 0x81, 0x63, 0x6F,
+  0x6D, 0x70, 0x6C, 0x65, 0x78, 0x65, 0x73, 0xE2, 0x84, 0x82, 0x63, 0x6F,
+  0x6E, 0x67, 0xE2, 0x89, 0x85, 0x63, 0x6F, 0x6E, 0x67, 0x64, 0x6F, 0x74,
+  0xE2, 0xA9, 0xAD, 0x63, 0x6F, 0x6E, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xAE,
+  0x63, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x94, 0x63, 0x6F, 0x70, 0x72,
+  0x6F, 0x64, 0xE2, 0x88, 0x90, 0x63, 0x6F, 0x70, 0x79, 0xC2, 0xA9, 0x63,
+  0x6F, 0x70, 0x79, 0x73, 0x72, 0xE2, 0x84, 0x97, 0x63, 0x72, 0x61, 0x72,
+  0x72, 0xE2, 0x86, 0xB5, 0x63, 0x72, 0x6F, 0x73, 0x73, 0xE2, 0x9C, 0x97,
+  0x63, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xB8, 0x63, 0x73, 0x75, 0x62,
+  0xE2, 0xAB, 0x8F, 0x63, 0x73, 0x75, 0x62, 0x65, 0xE2, 0xAB, 0x91, 0x63,
+  0x73, 0x75, 0x70, 0xE2, 0xAB, 0x90, 0x63, 0x73, 0x75, 0x70, 0x65, 0xE2,
+  0xAB, 0x92, 0x63, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0xAF, 0x63, 0x75,
+  0x64, 0x61, 0x72, 0x72, 0x6C, 0xE2, 0xA4, 0xB8, 0x63, 0x75, 0x64, 0x61,
+  0x72, 0x72, 0x72, 0xE2, 0xA4, 0xB5, 0x63, 0x75, 0x65, 0x70, 0x72, 0xE2,
+  0x8B, 0x9E, 0x63, 0x75, 0x65, 0x73, 0x63, 0xE2, 0x8B, 0x9F, 0x63, 0x75,
+  0x6C, 0x61, 0x72, 0x72, 0xE2, 0x86, 0xB6, 0x63, 0x75, 0x6C, 0x61, 0x72,
+  0x72, 0x70, 0xE2, 0xA4, 0xBD, 0x63, 0x75, 0x70, 0xE2, 0x88, 0xAA, 0x63,
+  0x75, 0x70, 0x62, 0x72, 0x63, 0x61, 0x70, 0xE2, 0xA9, 0x88, 0x63, 0x75,
+  0x70, 0x63, 0x61, 0x70, 0xE2, 0xA9, 0x86, 0x63, 0x75, 0x70, 0x63, 0x75,
+  0x70, 0xE2, 0xA9, 0x8A, 0x63, 0x75, 0x70, 0x64, 0x6F, 0x74, 0xE2, 0x8A,
+  0x8D, 0x63, 0x75, 0x70, 0x6F, 0x72, 0xE2, 0xA9, 0x85, 0x63, 0x75, 0x70,
+  0x73, 0xE2, 0x88, 0xAA, 0xEF, 0xB8, 0x80, 0x63, 0x75, 0x72, 0x61, 0x72,
+  0x72, 0xE2, 0x86, 0xB7, 0x63, 0x75, 0x72, 0x61, 0x72, 0x72, 0x6D, 0xE2,
+  0xA4, 0xBC, 0x63, 0x75, 0x72, 0x6C, 0x79, 0x65, 0x71, 0x70, 0x72, 0x65,
+  0x63, 0xE2, 0x8B, 0x9E, 0x63, 0x75, 0x72, 0x6C, 0x79, 0x65, 0x71, 0x73,
+  0x75, 0x63, 0x63, 0xE2, 0x8B, 0x9F, 0x63, 0x75, 0x72, 0x6C, 0x79, 0x76,
+  0x65, 0x65, 0xE2, 0x8B, 0x8E, 0x63, 0x75, 0x72, 0x6C, 0x79, 0x77, 0x65,
+  0x64, 0x67, 0x65, 0xE2, 0x8B, 0x8F, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E,
+  0xC2, 0xA4, 0x63, 0x75, 0x72, 0x76, 0x65, 0x61, 0x72, 0x72, 0x6F, 0x77,
+  0x6C, 0x65, 0x66, 0x74, 0xE2, 0x86, 0xB6, 0x63, 0x75, 0x72, 0x76, 0x65,
+  0x61, 0x72, 0x72, 0x6F, 0x77, 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2, 0x86,
+  0xB7, 0x63, 0x75, 0x76, 0x65, 0x65, 0xE2, 0x8B, 0x8E, 0x63, 0x75, 0x77,
+  0x65, 0x64, 0xE2, 0x8B, 0x8F, 0x63, 0x77, 0x63, 0x6F, 0x6E, 0x69, 0x6E,
+  0x74, 0xE2, 0x88, 0xB2, 0x63, 0x77, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xB1,
+  0x63, 0x79, 0x6C, 0x63, 0x74, 0x79, 0xE2, 0x8C, 0xAD, 0x64, 0x41, 0x72,
+  0x72, 0xE2, 0x87, 0x93, 0x64, 0x48, 0x61, 0x72, 0xE2, 0xA5, 0xA5, 0x64,
+  0x61, 0x67, 0x67, 0x65, 0x72, 0xE2, 0x80, 0xA0, 0x64, 0x61, 0x6C, 0x65,
+  0x74, 0x68, 0xE2, 0x84, 0xB8, 0x64, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x93,
+  0x64, 0x61, 0x73, 0x68, 0xE2, 0x80, 0x90, 0x64, 0x61, 0x73, 0x68, 0x76,
+  0xE2, 0x8A, 0xA3, 0x64, 0x62, 0x6B, 0x61, 0x72, 0x6F, 0x77, 0xE2, 0xA4,
+  0x8F, 0x64, 0x62, 0x6C, 0x61, 0x63, 0xCB, 0x9D, 0x64, 0x63, 0x61, 0x72,
+  0x6F, 0x6E, 0xC4, 0x8F, 0x64, 0x63, 0x79, 0xD0, 0xB4, 0x64, 0x64, 0xE2,
+  0x85, 0x86, 0x64, 0x64, 0x61, 0x67, 0x67, 0x65, 0x72, 0xE2, 0x80, 0xA1,
+  0x64, 0x64, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x8A, 0x64, 0x64, 0x6F, 0x74,
+  0x73, 0x65, 0x71, 0xE2, 0xA9, 0xB7, 0x64, 0x65, 0x67, 0xC2, 0xB0, 0x64,
+  0x65, 0x6C, 0x74, 0x61, 0xCE, 0xB4, 0x64, 0x65, 0x6D, 0x70, 0x74, 0x79,
+  0x76, 0xE2, 0xA6, 0xB1, 0x64, 0x66, 0x69, 0x73, 0x68, 0x74, 0xE2, 0xA5,
+  0xBF, 0x64, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA1, 0x64, 0x68, 0x61, 0x72,
+  0x6C, 0xE2, 0x87, 0x83, 0x64, 0x68, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x82,
+  0x64, 0x69, 0x61, 0x6D, 0xE2, 0x8B, 0x84, 0x64, 0x69, 0x61, 0x6D, 0x6F,
+  0x6E, 0x64, 0xE2, 0x8B, 0x84, 0x64, 0x69, 0x61, 0x6D, 0x6F, 0x6E, 0x64,
+  0x73, 0x75, 0x69, 0x74, 0xE2, 0x99, 0xA6, 0x64, 0x69, 0x61, 0x6D, 0x73,
+  0xE2, 0x99, 0xA6, 0x64, 0x69, 0x65, 0xC2, 0xA8, 0x64, 0x69, 0x67, 0x61,
+  0x6D, 0x6D, 0x61, 0xCF, 0x9D, 0x64, 0x69, 0x73, 0x69, 0x6E, 0xE2, 0x8B,
+  0xB2, 0x64, 0x69, 0x76, 0xC3, 0xB7, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65,
+  0xC3, 0xB7, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, 0x6F, 0x6E, 0x74, 0x69,
+  0x6D, 0x65, 0x73, 0xE2, 0x8B, 0x87, 0x64, 0x69, 0x76, 0x6F, 0x6E, 0x78,
+  0xE2, 0x8B, 0x87, 0x64, 0x6A, 0x63, 0x79, 0xD1, 0x92, 0x64, 0x6C, 0x63,
+  0x6F, 0x72, 0x6E, 0xE2, 0x8C, 0x9E, 0x64, 0x6C, 0x63, 0x72, 0x6F, 0x70,
+  0xE2, 0x8C, 0x8D, 0x64, 0x6F, 0x6C, 0x6C, 0x61, 0x72, 0x24, 0x64, 0x6F,
+  0x70, 0x66, 0xF0, 0x9D, 0x95, 0x95, 0x64, 0x6F, 0x74, 0xCB, 0x99, 0x64,
+  0x6F, 0x74, 0x65, 0x71, 0xE2, 0x89, 0x90, 0x64, 0x6F, 0x74, 0x65, 0x71,
+  0x64, 0x6F, 0x74, 0xE2, 0x89, 0x91, 0x64, 0x6F, 0x74, 0x6D, 0x69, 0x6E,
+  0x75, 0x73, 0xE2, 0x88, 0xB8, 0x64, 0x6F, 0x74, 0x70, 0x6C, 0x75, 0x73,
+  0xE2, 0x88, 0x94, 0x64, 0x6F, 0x74, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65,
+  0xE2, 0x8A, 0xA1, 0x64, 0x6F, 0x75, 0x62, 0x6C, 0x65, 0x62, 0x61, 0x72,
+  0x77, 0x65, 0x64, 0x67, 0x65, 0xE2, 0x8C, 0x86, 0x64, 0x6F, 0x77, 0x6E,
+  0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x93, 0x64, 0x6F, 0x77, 0x6E,
+  0x64, 0x6F, 0x77, 0x6E, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x73, 0xE2, 0x87,
+  0x8A, 0x64, 0x6F, 0x77, 0x6E, 0x68, 0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E,
+  0x6C, 0x65, 0x66, 0x74, 0xE2, 0x87, 0x83, 0x64, 0x6F, 0x77, 0x6E, 0x68,
+  0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2,
+  0x87, 0x82, 0x64, 0x72, 0x62, 0x6B, 0x61, 0x72, 0x6F, 0x77, 0xE2, 0xA4,
+  0x90, 0x64, 0x72, 0x63, 0x6F, 0x72, 0x6E, 0xE2, 0x8C, 0x9F, 0x64, 0x72,
+  0x63, 0x72, 0x6F, 0x70, 0xE2, 0x8C, 0x8C, 0x64, 0x73, 0x63, 0x72, 0xF0,
+  0x9D, 0x92, 0xB9, 0x64, 0x73, 0x63, 0x79, 0xD1, 0x95, 0x64, 0x73, 0x6F,
+  0x6C, 0xE2, 0xA7, 0xB6, 0x64, 0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC4, 0x91,
+  0x64, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0xB1, 0x64, 0x74, 0x72, 0x69,
+  0xE2, 0x96, 0xBF, 0x64, 0x74, 0x72, 0x69, 0x66, 0xE2, 0x96, 0xBE, 0x64,
+  0x75, 0x61, 0x72, 0x72, 0xE2, 0x87, 0xB5, 0x64, 0x75, 0x68, 0x61, 0x72,
+  0xE2, 0xA5, 0xAF, 0x64, 0x77, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0xA6,
+  0xA6, 0x64, 0x7A, 0x63, 0x79, 0xD1, 0x9F, 0x64, 0x7A, 0x69, 0x67, 0x72,
+  0x61, 0x72, 0x72, 0xE2, 0x9F, 0xBF, 0x65, 0x44, 0x44, 0x6F, 0x74, 0xE2,
+  0xA9, 0xB7, 0x65, 0x44, 0x6F, 0x74, 0xE2, 0x89, 0x91, 0x65, 0x61, 0x63,
+  0x75, 0x74, 0x65, 0xC3, 0xA9, 0x65, 0x61, 0x73, 0x74, 0x65, 0x72, 0xE2,
+  0xA9, 0xAE, 0x65, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC4, 0x9B, 0x65, 0x63,
+  0x69, 0x72, 0xE2, 0x89, 0x96, 0x65, 0x63, 0x69, 0x72, 0x63, 0xC3, 0xAA,
+  0x65, 0x63, 0x6F, 0x6C, 0x6F, 0x6E, 0xE2, 0x89, 0x95, 0x65, 0x63, 0x79,
+  0xD1, 0x8D, 0x65, 0x64, 0x6F, 0x74, 0xC4, 0x97, 0x65, 0x65, 0xE2, 0x85,
+  0x87, 0x65, 0x66, 0x44, 0x6F, 0x74, 0xE2, 0x89, 0x92, 0x65, 0x66, 0x72,
+  0xF0, 0x9D, 0x94, 0xA2, 0x65, 0x67, 0xE2, 0xAA, 0x9A, 0x65, 0x67, 0x72,
+  0x61, 0x76, 0x65, 0xC3, 0xA8, 0x65, 0x67, 0x73, 0xE2, 0xAA, 0x96, 0x65,
+  0x67, 0x73, 0x64, 0x6F, 0x74, 0xE2, 0xAA, 0x98, 0x65, 0x6C, 0xE2, 0xAA,
+  0x99, 0x65, 0x6C, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x73, 0xE2, 0x8F, 0xA7,
+  0x65, 0x6C, 0x6C, 0xE2, 0x84, 0x93, 0x65, 0x6C, 0x73, 0xE2, 0xAA, 0x95,
+  0x65, 0x6C, 0x73, 0x64, 0x6F, 0x74, 0xE2, 0xAA, 0x97, 0x65, 0x6D, 0x61,
+  0x63, 0x72, 0xC4, 0x93, 0x65, 0x6D, 0x70, 0x74, 0x79, 0xE2, 0x88, 0x85,
+  0x65, 0x6D, 0x70, 0x74, 0x79, 0x73, 0x65, 0x74, 0xE2, 0x88, 0x85, 0x65,
+  0x6D, 0x70, 0x74, 0x79, 0x76, 0xE2, 0x88, 0x85, 0x65, 0x6D, 0x73, 0x70,
+  0xE2, 0x80, 0x83, 0x65, 0x6D, 0x73, 0x70, 0x31, 0x33, 0xE2, 0x80, 0x84,
+  0x65, 0x6D, 0x73, 0x70, 0x31, 0x34, 0xE2, 0x80, 0x85, 0x65, 0x6E, 0x67,
+  0xC5, 0x8B, 0x65, 0x6E, 0x73, 0x70, 0xE2, 0x80, 0x82, 0x65, 0x6F, 0x67,
+  0x6F, 0x6E, 0xC4, 0x99, 0x65, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0x96,
+  0x65, 0x70, 0x61, 0x72, 0xE2, 0x8B, 0x95, 0x65, 0x70, 0x61, 0x72, 0x73,
+  0x6C, 0xE2, 0xA7, 0xA3, 0x65, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA9, 0xB1,
+  0x65, 0x70, 0x73, 0x69, 0xCE, 0xB5, 0x65, 0x70, 0x73, 0x69, 0x6C, 0x6F,
+  0x6E, 0xCE, 0xB5, 0x65, 0x70, 0x73, 0x69, 0x76, 0xCF, 0xB5, 0x65, 0x71,
+  0x63, 0x69, 0x72, 0x63, 0xE2, 0x89, 0x96, 0x65, 0x71, 0x63, 0x6F, 0x6C,
+  0x6F, 0x6E, 0xE2, 0x89, 0x95, 0x65, 0x71, 0x73, 0x69, 0x6D, 0xE2, 0x89,
+  0x82, 0x65, 0x71, 0x73, 0x6C, 0x61, 0x6E, 0x74, 0x67, 0x74, 0x72, 0xE2,
+  0xAA, 0x96, 0x65, 0x71, 0x73, 0x6C, 0x61, 0x6E, 0x74, 0x6C, 0x65, 0x73,
+  0x73, 0xE2, 0xAA, 0x95, 0x65, 0x71, 0x75, 0x61, 0x6C, 0x73, 0x3D, 0x65,
+  0x71, 0x75, 0x65, 0x73, 0x74, 0xE2, 0x89, 0x9F, 0x65, 0x71, 0x75, 0x69,
+  0x76, 0xE2, 0x89, 0xA1, 0x65, 0x71, 0x75, 0x69, 0x76, 0x44, 0x44, 0xE2,
+  0xA9, 0xB8, 0x65, 0x71, 0x76, 0x70, 0x61, 0x72, 0x73, 0x6C, 0xE2, 0xA7,
+  0xA5, 0x65, 0x72, 0x44, 0x6F, 0x74, 0xE2, 0x89, 0x93, 0x65, 0x72, 0x61,
+  0x72, 0x72, 0xE2, 0xA5, 0xB1, 0x65, 0x73, 0x63, 0x72, 0xE2, 0x84, 0xAF,
+  0x65, 0x73, 0x64, 0x6F, 0x74, 0xE2, 0x89, 0x90, 0x65, 0x73, 0x69, 0x6D,
+  0xE2, 0x89, 0x82, 0x65, 0x74, 0x61, 0xCE, 0xB7, 0x65, 0x74, 0x68, 0xC3,
+  0xB0, 0x65, 0x75, 0x6D, 0x6C, 0xC3, 0xAB, 0x65, 0x75, 0x72, 0x6F, 0xE2,
+  0x82, 0xAC, 0x65, 0x78, 0x63, 0x6C, 0x21, 0x65, 0x78, 0x69, 0x73, 0x74,
+  0xE2, 0x88, 0x83, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x61, 0x74, 0x69,
+  0x6F, 0x6E, 0xE2, 0x84, 0xB0, 0x65, 0x78, 0x70, 0x6F, 0x6E, 0x65, 0x6E,
+  0x74, 0x69, 0x61, 0x6C, 0x65, 0xE2, 0x85, 0x87, 0x66, 0x61, 0x6C, 0x6C,
+  0x69, 0x6E, 0x67, 0x64, 0x6F, 0x74, 0x73, 0x65, 0x71, 0xE2, 0x89, 0x92,
+  0x66, 0x63, 0x79, 0xD1, 0x84, 0x66, 0x65, 0x6D, 0x61, 0x6C, 0x65, 0xE2,
+  0x99, 0x80, 0x66, 0x66, 0x69, 0x6C, 0x69, 0x67, 0xEF, 0xAC, 0x83, 0x66,
+  0x66, 0x6C, 0x69, 0x67, 0xEF, 0xAC, 0x80, 0x66, 0x66, 0x6C, 0x6C, 0x69,
+  0x67, 0xEF, 0xAC, 0x84, 0x66, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA3, 0x66,
+  0x69, 0x6C, 0x69, 0x67, 0xEF, 0xAC, 0x81, 0x66, 0x6A, 0x6C, 0x69, 0x67,
+  0x66, 0x6A, 0x66, 0x6C, 0x61, 0x74, 0xE2, 0x99, 0xAD, 0x66, 0x6C, 0x6C,
+  0x69, 0x67, 0xEF, 0xAC, 0x82, 0x66, 0x6C, 0x74, 0x6E, 0x73, 0xE2, 0x96,
+  0xB1, 0x66, 0x6E, 0x6F, 0x66, 0xC6, 0x92, 0x66, 0x6F, 0x70, 0x66, 0xF0,
+  0x9D, 0x95, 0x97, 0x66, 0x6F, 0x72, 0x61, 0x6C, 0x6C, 0xE2, 0x88, 0x80,
+  0x66, 0x6F, 0x72, 0x6B, 0xE2, 0x8B, 0x94, 0x66, 0x6F, 0x72, 0x6B, 0x76,
+  0xE2, 0xAB, 0x99, 0x66, 0x70, 0x61, 0x72, 0x74, 0x69, 0x6E, 0x74, 0xE2,
+  0xA8, 0x8D, 0x66, 0x72, 0x61, 0x63, 0x31, 0x32, 0xC2, 0xBD, 0x66, 0x72,
+  0x61, 0x63, 0x31, 0x33, 0xE2, 0x85, 0x93, 0x66, 0x72, 0x61, 0x63, 0x31,
+  0x34, 0xC2, 0xBC, 0x66, 0x72, 0x61, 0x63, 0x31, 0x35, 0xE2, 0x85, 0x95,
+  0x66, 0x72, 0x61, 0x63, 0x31, 0x36, 0xE2, 0x85, 0x99, 0x66, 0x72, 0x61,
+  0x63, 0x31, 0x38, 0xE2, 0x85, 0x9B, 0x66, 0x72, 0x61, 0x63, 0x32, 0x33,
+  0xE2, 0x85, 0x94, 0x66, 0x72, 0x61, 0x63, 0x32, 0x35, 0xE2, 0x85, 0x96,
+  0x66, 0x72, 0x61, 0x63, 0x33, 0x34, 0xC2, 0xBE, 0x66, 0x72, 0x61, 0x63,
+  0x33, 0x35, 0xE2, 0x85, 0x97, 0x66, 0x72, 0x61, 0x63, 0x33, 0x38, 0xE2,
+  0x85, 0x9C, 0x66, 0x72, 0x61, 0x63, 0x34, 0x35, 0xE2, 0x85, 0x98, 0x66,
+  0x72, 0x61, 0x63, 0x35, 0x36, 0xE2, 0x85, 0x9A, 0x66, 0x72, 0x61, 0x63,
+  0x35, 0x38, 0xE2, 0x85, 0x9D, 0x66, 0x72, 0x61, 0x63, 0x37, 0x38, 0xE2,
+  0x85, 0x9E, 0x66, 0x72, 0x61, 0x73, 0x6C, 0xE2, 0x81, 0x84, 0x66, 0x72,
+  0x6F, 0x77, 0x6E, 0xE2, 0x8C, 0xA2, 0x66, 0x73, 0x63, 0x72, 0xF0, 0x9D,
+  0x92, 0xBB, 0x67, 0x45, 0xE2, 0x89, 0xA7, 0x67, 0x45, 0x6C, 0xE2, 0xAA,
+  0x8C, 0x67, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC7, 0xB5, 0x67, 0x61, 0x6D,
+  0x6D, 0x61, 0xCE, 0xB3, 0x67, 0x61, 0x6D, 0x6D, 0x61, 0x64, 0xCF, 0x9D,
+  0x67, 0x61, 0x70, 0xE2, 0xAA, 0x86, 0x67, 0x62, 0x72, 0x65, 0x76, 0x65,
+  0xC4, 0x9F, 0x67, 0x63, 0x69, 0x72, 0x63, 0xC4, 0x9D, 0x67, 0x63, 0x79,
+  0xD0, 0xB3, 0x67, 0x64, 0x6F, 0x74, 0xC4, 0xA1, 0x67, 0x65, 0xE2, 0x89,
+  0xA5, 0x67, 0x65, 0x6C, 0xE2, 0x8B, 0x9B, 0x67, 0x65, 0x71, 0xE2, 0x89,
+  0xA5, 0x67, 0x65, 0x71, 0x71, 0xE2, 0x89, 0xA7, 0x67, 0x65, 0x71, 0x73,
+  0x6C, 0x61, 0x6E, 0x74, 0xE2, 0xA9, 0xBE, 0x67, 0x65, 0x73, 0xE2, 0xA9,
+  0xBE, 0x67, 0x65, 0x73, 0x63, 0x63, 0xE2, 0xAA, 0xA9, 0x67, 0x65, 0x73,
+  0x64, 0x6F, 0x74, 0xE2, 0xAA, 0x80, 0x67, 0x65, 0x73, 0x64, 0x6F, 0x74,
+  0x6F, 0xE2, 0xAA, 0x82, 0x67, 0x65, 0x73, 0x64, 0x6F, 0x74, 0x6F, 0x6C,
+  0xE2, 0xAA, 0x84, 0x67, 0x65, 0x73, 0x6C, 0xE2, 0x8B, 0x9B, 0xEF, 0xB8,
+  0x80, 0x67, 0x65, 0x73, 0x6C, 0x65, 0x73, 0xE2, 0xAA, 0x94, 0x67, 0x66,
+  0x72, 0xF0, 0x9D, 0x94, 0xA4, 0x67, 0x67, 0xE2, 0x89, 0xAB, 0x67, 0x67,
+  0x67, 0xE2, 0x8B, 0x99, 0x67, 0x69, 0x6D, 0x65, 0x6C, 0xE2, 0x84, 0xB7,
+  0x67, 0x6A, 0x63, 0x79, 0xD1, 0x93, 0x67, 0x6C, 0xE2, 0x89, 0xB7, 0x67,
+  0x6C, 0x45, 0xE2, 0xAA, 0x92, 0x67, 0x6C, 0x61, 0xE2, 0xAA, 0xA5, 0x67,
+  0x6C, 0x6A, 0xE2, 0xAA, 0xA4, 0x67, 0x6E, 0x45, 0xE2, 0x89, 0xA9, 0x67,
+  0x6E, 0x61, 0x70, 0xE2, 0xAA, 0x8A, 0x67, 0x6E, 0x61, 0x70, 0x70, 0x72,
+  0x6F, 0x78, 0xE2, 0xAA, 0x8A, 0x67, 0x6E, 0x65, 0xE2, 0xAA, 0x88, 0x67,
+  0x6E, 0x65, 0x71, 0xE2, 0xAA, 0x88, 0x67, 0x6E, 0x65, 0x71, 0x71, 0xE2,
+  0x89, 0xA9, 0x67, 0x6E, 0x73, 0x69, 0x6D, 0xE2, 0x8B, 0xA7, 0x67, 0x6F,
+  0x70, 0x66, 0xF0, 0x9D, 0x95, 0x98, 0x67, 0x72, 0x61, 0x76, 0x65, 0x60,
+  0x67, 0x73, 0x63, 0x72, 0xE2, 0x84, 0x8A, 0x67, 0x73, 0x69, 0x6D, 0xE2,
+  0x89, 0xB3, 0x67, 0x73, 0x69, 0x6D, 0x65, 0xE2, 0xAA, 0x8E, 0x67, 0x73,
+  0x69, 0x6D, 0x6C, 0xE2, 0xAA, 0x90, 0x67, 0x74, 0x3E, 0x67, 0x74, 0x63,
+  0x63, 0xE2, 0xAA, 0xA7, 0x67, 0x74, 0x63, 0x69, 0x72, 0xE2, 0xA9, 0xBA,
+  0x67, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0x97, 0x67, 0x74, 0x6C, 0x50,
+  0x61, 0x72, 0xE2, 0xA6, 0x95, 0x67, 0x74, 0x71, 0x75, 0x65, 0x73, 0x74,
+  0xE2, 0xA9, 0xBC, 0x67, 0x74, 0x72, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78,
+  0xE2, 0xAA, 0x86, 0x67, 0x74, 0x72, 0x61, 0x72, 0x72, 0xE2, 0xA5, 0xB8,
+  0x67, 0x74, 0x72, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0x97, 0x67, 0x74, 0x72,
+  0x65, 0x71, 0x6C, 0x65, 0x73, 0x73, 0xE2, 0x8B, 0x9B, 0x67, 0x74, 0x72,
+  0x65, 0x71, 0x71, 0x6C, 0x65, 0x73, 0x73, 0xE2, 0xAA, 0x8C, 0x67, 0x74,
+  0x72, 0x6C, 0x65, 0x73, 0x73, 0xE2, 0x89, 0xB7, 0x67, 0x74, 0x72, 0x73,
+  0x69, 0x6D, 0xE2, 0x89, 0xB3, 0x67, 0x76, 0x65, 0x72, 0x74, 0x6E, 0x65,
+  0x71, 0x71, 0xE2, 0x89, 0xA9, 0xEF, 0xB8, 0x80, 0x67, 0x76, 0x6E, 0x45,
+  0xE2, 0x89, 0xA9, 0xEF, 0xB8, 0x80, 0x68, 0x41, 0x72, 0x72, 0xE2, 0x87,
+  0x94, 0x68, 0x61, 0x69, 0x72, 0x73, 0x70, 0xE2, 0x80, 0x8A, 0x68, 0x61,
+  0x6C, 0x66, 0xC2, 0xBD, 0x68, 0x61, 0x6D, 0x69, 0x6C, 0x74, 0xE2, 0x84,
+  0x8B, 0x68, 0x61, 0x72, 0x64, 0x63, 0x79, 0xD1, 0x8A, 0x68, 0x61, 0x72,
+  0x72, 0xE2, 0x86, 0x94, 0x68, 0x61, 0x72, 0x72, 0x63, 0x69, 0x72, 0xE2,
+  0xA5, 0x88, 0x68, 0x61, 0x72, 0x72, 0x77, 0xE2, 0x86, 0xAD, 0x68, 0x62,
+  0x61, 0x72, 0xE2, 0x84, 0x8F, 0x68, 0x63, 0x69, 0x72, 0x63, 0xC4, 0xA5,
+  0x68, 0x65, 0x61, 0x72, 0x74, 0x73, 0xE2, 0x99, 0xA5, 0x68, 0x65, 0x61,
+  0x72, 0x74, 0x73, 0x75, 0x69, 0x74, 0xE2, 0x99, 0xA5, 0x68, 0x65, 0x6C,
+  0x6C, 0x69, 0x70, 0xE2, 0x80, 0xA6, 0x68, 0x65, 0x72, 0x63, 0x6F, 0x6E,
+  0xE2, 0x8A, 0xB9, 0x68, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA5, 0x68, 0x6B,
+  0x73, 0x65, 0x61, 0x72, 0x6F, 0x77, 0xE2, 0xA4, 0xA5, 0x68, 0x6B, 0x73,
+  0x77, 0x61, 0x72, 0x6F, 0x77, 0xE2, 0xA4, 0xA6, 0x68, 0x6F, 0x61, 0x72,
+  0x72, 0xE2, 0x87, 0xBF, 0x68, 0x6F, 0x6D, 0x74, 0x68, 0x74, 0xE2, 0x88,
+  0xBB, 0x68, 0x6F, 0x6F, 0x6B, 0x6C, 0x65, 0x66, 0x74, 0x61, 0x72, 0x72,
+  0x6F, 0x77, 0xE2, 0x86, 0xA9, 0x68, 0x6F, 0x6F, 0x6B, 0x72, 0x69, 0x67,
+  0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0xAA, 0x68, 0x6F,
+  0x70, 0x66, 0xF0, 0x9D, 0x95, 0x99, 0x68, 0x6F, 0x72, 0x62, 0x61, 0x72,
+  0xE2, 0x80, 0x95, 0x68, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xBD, 0x68,
+  0x73, 0x6C, 0x61, 0x73, 0x68, 0xE2, 0x84, 0x8F, 0x68, 0x73, 0x74, 0x72,
+  0x6F, 0x6B, 0xC4, 0xA7, 0x68, 0x79, 0x62, 0x75, 0x6C, 0x6C, 0xE2, 0x81,
+  0x83, 0x68, 0x79, 0x70, 0x68, 0x65, 0x6E, 0xE2, 0x80, 0x90, 0x69, 0x61,
+  0x63, 0x75, 0x74, 0x65, 0xC3, 0xAD, 0x69, 0x63, 0xE2, 0x81, 0xA3, 0x69,
+  0x63, 0x69, 0x72, 0x63, 0xC3, 0xAE, 0x69, 0x63, 0x79, 0xD0, 0xB8, 0x69,
+  0x65, 0x63, 0x79, 0xD0, 0xB5, 0x69, 0x65, 0x78, 0x63, 0x6C, 0xC2, 0xA1,
+  0x69, 0x66, 0x66, 0xE2, 0x87, 0x94, 0x69, 0x66, 0x72, 0xF0, 0x9D, 0x94,
+  0xA6, 0x69, 0x67, 0x72, 0x61, 0x76, 0x65, 0xC3, 0xAC, 0x69, 0x69, 0xE2,
+  0x85, 0x88, 0x69, 0x69, 0x69, 0x69, 0x6E, 0x74, 0xE2, 0xA8, 0x8C, 0x69,
+  0x69, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xAD, 0x69, 0x69, 0x6E, 0x66, 0x69,
+  0x6E, 0xE2, 0xA7, 0x9C, 0x69, 0x69, 0x6F, 0x74, 0x61, 0xE2, 0x84, 0xA9,
+  0x69, 0x6A, 0x6C, 0x69, 0x67, 0xC4, 0xB3, 0x69, 0x6D, 0x61, 0x63, 0x72,
+  0xC4, 0xAB, 0x69, 0x6D, 0x61, 0x67, 0x65, 0xE2, 0x84, 0x91, 0x69, 0x6D,
+  0x61, 0x67, 0x6C, 0x69, 0x6E, 0x65, 0xE2, 0x84, 0x90, 0x69, 0x6D, 0x61,
+  0x67, 0x70, 0x61, 0x72, 0x74, 0xE2, 0x84, 0x91, 0x69, 0x6D, 0x61, 0x74,
+  0x68, 0xC4, 0xB1, 0x69, 0x6D, 0x6F, 0x66, 0xE2, 0x8A, 0xB7, 0x69, 0x6D,
+  0x70, 0x65, 0x64, 0xC6, 0xB5, 0x69, 0x6E, 0xE2, 0x88, 0x88, 0x69, 0x6E,
+  0x63, 0x61, 0x72, 0x65, 0xE2, 0x84, 0x85, 0x69, 0x6E, 0x66, 0x69, 0x6E,
+  0xE2, 0x88, 0x9E, 0x69, 0x6E, 0x66, 0x69, 0x6E, 0x74, 0x69, 0x65, 0xE2,
+  0xA7, 0x9D, 0x69, 0x6E, 0x6F, 0x64, 0x6F, 0x74, 0xC4, 0xB1, 0x69, 0x6E,
+  0x74, 0xE2, 0x88, 0xAB, 0x69, 0x6E, 0x74, 0x63, 0x61, 0x6C, 0xE2, 0x8A,
+  0xBA, 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0x73, 0xE2, 0x84, 0xA4,
+  0x69, 0x6E, 0x74, 0x65, 0x72, 0x63, 0x61, 0x6C, 0xE2, 0x8A, 0xBA, 0x69,
+  0x6E, 0x74, 0x6C, 0x61, 0x72, 0x68, 0x6B, 0xE2, 0xA8, 0x97, 0x69, 0x6E,
+  0x74, 0x70, 0x72, 0x6F, 0x64, 0xE2, 0xA8, 0xBC, 0x69, 0x6F, 0x63, 0x79,
+  0xD1, 0x91, 0x69, 0x6F, 0x67, 0x6F, 0x6E, 0xC4, 0xAF, 0x69, 0x6F, 0x70,
+  0x66, 0xF0, 0x9D, 0x95, 0x9A, 0x69, 0x6F, 0x74, 0x61, 0xCE, 0xB9, 0x69,
+  0x70, 0x72, 0x6F, 0x64, 0xE2, 0xA8, 0xBC, 0x69, 0x71, 0x75, 0x65, 0x73,
+  0x74, 0xC2, 0xBF, 0x69, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xBE, 0x69,
+  0x73, 0x69, 0x6E, 0xE2, 0x88, 0x88, 0x69, 0x73, 0x69, 0x6E, 0x45, 0xE2,
+  0x8B, 0xB9, 0x69, 0x73, 0x69, 0x6E, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0xB5,
+  0x69, 0x73, 0x69, 0x6E, 0x73, 0xE2, 0x8B, 0xB4, 0x69, 0x73, 0x69, 0x6E,
+  0x73, 0x76, 0xE2, 0x8B, 0xB3, 0x69, 0x73, 0x69, 0x6E, 0x76, 0xE2, 0x88,
+  0x88, 0x69, 0x74, 0xE2, 0x81, 0xA2, 0x69, 0x74, 0x69, 0x6C, 0x64, 0x65,
+  0xC4, 0xA9, 0x69, 0x75, 0x6B, 0x63, 0x79, 0xD1, 0x96, 0x69, 0x75, 0x6D,
+  0x6C, 0xC3, 0xAF, 0x6A, 0x63, 0x69, 0x72, 0x63, 0xC4, 0xB5, 0x6A, 0x63,
+  0x79, 0xD0, 0xB9, 0x6A, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA7, 0x6A, 0x6D,
+  0x61, 0x74, 0x68, 0xC8, 0xB7, 0x6A, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95,
+  0x9B, 0x6A, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x92, 0xBF, 0x6A, 0x73, 0x65,
+  0x72, 0x63, 0x79, 0xD1, 0x98, 0x6A, 0x75, 0x6B, 0x63, 0x79, 0xD1, 0x94,
+  0x6B, 0x61, 0x70, 0x70, 0x61, 0xCE, 0xBA, 0x6B, 0x61, 0x70, 0x70, 0x61,
+  0x76, 0xCF, 0xB0, 0x6B, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC4, 0xB7, 0x6B,
+  0x63, 0x79, 0xD0, 0xBA, 0x6B, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA8, 0x6B,
+  0x67, 0x72, 0x65, 0x65, 0x6E, 0xC4, 0xB8, 0x6B, 0x68, 0x63, 0x79, 0xD1,
+  0x85, 0x6B, 0x6A, 0x63, 0x79, 0xD1, 0x9C, 0x6B, 0x6F, 0x70, 0x66, 0xF0,
+  0x9D, 0x95, 0x9C, 0x6B, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x80, 0x6C,
+  0x41, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x9A, 0x6C, 0x41, 0x72, 0x72, 0xE2,
+  0x87, 0x90, 0x6C, 0x41, 0x74, 0x61, 0x69, 0x6C, 0xE2, 0xA4, 0x9B, 0x6C,
+  0x42, 0x61, 0x72, 0x72, 0xE2, 0xA4, 0x8E, 0x6C, 0x45, 0xE2, 0x89, 0xA6,
+  0x6C, 0x45, 0x67, 0xE2, 0xAA, 0x8B, 0x6C, 0x48, 0x61, 0x72, 0xE2, 0xA5,
+  0xA2, 0x6C, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC4, 0xBA, 0x6C, 0x61, 0x65,
+  0x6D, 0x70, 0x74, 0x79, 0x76, 0xE2, 0xA6, 0xB4, 0x6C, 0x61, 0x67, 0x72,
+  0x61, 0x6E, 0xE2, 0x84, 0x92, 0x6C, 0x61, 0x6D, 0x62, 0x64, 0x61, 0xCE,
+  0xBB, 0x6C, 0x61, 0x6E, 0x67, 0xE2, 0x9F, 0xA8, 0x6C, 0x61, 0x6E, 0x67,
+  0x64, 0xE2, 0xA6, 0x91, 0x6C, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x9F,
+  0xA8, 0x6C, 0x61, 0x70, 0xE2, 0xAA, 0x85, 0x6C, 0x61, 0x71, 0x75, 0x6F,
+  0xC2, 0xAB, 0x6C, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x90, 0x6C, 0x61, 0x72,
+  0x72, 0x62, 0xE2, 0x87, 0xA4, 0x6C, 0x61, 0x72, 0x72, 0x62, 0x66, 0x73,
+  0xE2, 0xA4, 0x9F, 0x6C, 0x61, 0x72, 0x72, 0x66, 0x73, 0xE2, 0xA4, 0x9D,
+  0x6C, 0x61, 0x72, 0x72, 0x68, 0x6B, 0xE2, 0x86, 0xA9, 0x6C, 0x61, 0x72,
+  0x72, 0x6C, 0x70, 0xE2, 0x86, 0xAB, 0x6C, 0x61, 0x72, 0x72, 0x70, 0x6C,
+  0xE2, 0xA4, 0xB9, 0x6C, 0x61, 0x72, 0x72, 0x73, 0x69, 0x6D, 0xE2, 0xA5,
+  0xB3, 0x6C, 0x61, 0x72, 0x72, 0x74, 0x6C, 0xE2, 0x86, 0xA2, 0x6C, 0x61,
+  0x74, 0xE2, 0xAA, 0xAB, 0x6C, 0x61, 0x74, 0x61, 0x69, 0x6C, 0xE2, 0xA4,
+  0x99, 0x6C, 0x61, 0x74, 0x65, 0xE2, 0xAA, 0xAD, 0x6C, 0x61, 0x74, 0x65,
+  0x73, 0xE2, 0xAA, 0xAD, 0xEF, 0xB8, 0x80, 0x6C, 0x62, 0x61, 0x72, 0x72,
+  0xE2, 0xA4, 0x8C, 0x6C, 0x62, 0x62, 0x72, 0x6B, 0xE2, 0x9D, 0xB2, 0x6C,
+  0x62, 0x72, 0x61, 0x63, 0x65, 0x7B, 0x6C, 0x62, 0x72, 0x61, 0x63, 0x6B,
+  0x5B, 0x6C, 0x62, 0x72, 0x6B, 0x65, 0xE2, 0xA6, 0x8B, 0x6C, 0x62, 0x72,
+  0x6B, 0x73, 0x6C, 0x64, 0xE2, 0xA6, 0x8F, 0x6C, 0x62, 0x72, 0x6B, 0x73,
+  0x6C, 0x75, 0xE2, 0xA6, 0x8D, 0x6C, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC4,
+  0xBE, 0x6C, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC4, 0xBC, 0x6C, 0x63, 0x65,
+  0x69, 0x6C, 0xE2, 0x8C, 0x88, 0x6C, 0x63, 0x75, 0x62, 0x7B, 0x6C, 0x63,
+  0x79, 0xD0, 0xBB, 0x6C, 0x64, 0x63, 0x61, 0xE2, 0xA4, 0xB6, 0x6C, 0x64,
+  0x71, 0x75, 0x6F, 0xE2, 0x80, 0x9C, 0x6C, 0x64, 0x71, 0x75, 0x6F, 0x72,
+  0xE2, 0x80, 0x9E, 0x6C, 0x64, 0x72, 0x64, 0x68, 0x61, 0x72, 0xE2, 0xA5,
+  0xA7, 0x6C, 0x64, 0x72, 0x75, 0x73, 0x68, 0x61, 0x72, 0xE2, 0xA5, 0x8B,
+  0x6C, 0x64, 0x73, 0x68, 0xE2, 0x86, 0xB2, 0x6C, 0x65, 0xE2, 0x89, 0xA4,
+  0x6C, 0x65, 0x66, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x90,
+  0x6C, 0x65, 0x66, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x74, 0x61, 0x69,
+  0x6C, 0xE2, 0x86, 0xA2, 0x6C, 0x65, 0x66, 0x74, 0x68, 0x61, 0x72, 0x70,
+  0x6F, 0x6F, 0x6E, 0x64, 0x6F, 0x77, 0x6E, 0xE2, 0x86, 0xBD, 0x6C, 0x65,
+  0x66, 0x74, 0x68, 0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, 0x75, 0x70, 0xE2,
+  0x86, 0xBC, 0x6C, 0x65, 0x66, 0x74, 0x6C, 0x65, 0x66, 0x74, 0x61, 0x72,
+  0x72, 0x6F, 0x77, 0x73, 0xE2, 0x87, 0x87, 0x6C, 0x65, 0x66, 0x74, 0x72,
+  0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x94,
+  0x6C, 0x65, 0x66, 0x74, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72,
+  0x6F, 0x77, 0x73, 0xE2, 0x87, 0x86, 0x6C, 0x65, 0x66, 0x74, 0x72, 0x69,
+  0x67, 0x68, 0x74, 0x68, 0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, 0x73, 0xE2,
+  0x87, 0x8B, 0x6C, 0x65, 0x66, 0x74, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73,
+  0x71, 0x75, 0x69, 0x67, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0xAD,
+  0x6C, 0x65, 0x66, 0x74, 0x74, 0x68, 0x72, 0x65, 0x65, 0x74, 0x69, 0x6D,
+  0x65, 0x73, 0xE2, 0x8B, 0x8B, 0x6C, 0x65, 0x67, 0xE2, 0x8B, 0x9A, 0x6C,
+  0x65, 0x71, 0xE2, 0x89, 0xA4, 0x6C, 0x65, 0x71, 0x71, 0xE2, 0x89, 0xA6,
+  0x6C, 0x65, 0x71, 0x73, 0x6C, 0x61, 0x6E, 0x74, 0xE2, 0xA9, 0xBD, 0x6C,
+  0x65, 0x73, 0xE2, 0xA9, 0xBD, 0x6C, 0x65, 0x73, 0x63, 0x63, 0xE2, 0xAA,
+  0xA8, 0x6C, 0x65, 0x73, 0x64, 0x6F, 0x74, 0xE2, 0xA9, 0xBF, 0x6C, 0x65,
+  0x73, 0x64, 0x6F, 0x74, 0x6F, 0xE2, 0xAA, 0x81, 0x6C, 0x65, 0x73, 0x64,
+  0x6F, 0x74, 0x6F, 0x72, 0xE2, 0xAA, 0x83, 0x6C, 0x65, 0x73, 0x67, 0xE2,
+  0x8B, 0x9A, 0xEF, 0xB8, 0x80, 0x6C, 0x65, 0x73, 0x67, 0x65, 0x73, 0xE2,
+  0xAA, 0x93, 0x6C, 0x65, 0x73, 0x73, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78,
+  0xE2, 0xAA, 0x85, 0x6C, 0x65, 0x73, 0x73, 0x64, 0x6F, 0x74, 0xE2, 0x8B,
+  0x96, 0x6C, 0x65, 0x73, 0x73, 0x65, 0x71, 0x67, 0x74, 0x72, 0xE2, 0x8B,
+  0x9A, 0x6C, 0x65, 0x73, 0x73, 0x65, 0x71, 0x71, 0x67, 0x74, 0x72, 0xE2,
+  0xAA, 0x8B, 0x6C, 0x65, 0x73, 0x73, 0x67, 0x74, 0x72, 0xE2, 0x89, 0xB6,
+  0x6C, 0x65, 0x73, 0x73, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0xB2, 0x6C, 0x66,
+  0x69, 0x73, 0x68, 0x74, 0xE2, 0xA5, 0xBC, 0x6C, 0x66, 0x6C, 0x6F, 0x6F,
+  0x72, 0xE2, 0x8C, 0x8A, 0x6C, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xA9, 0x6C,
+  0x67, 0xE2, 0x89, 0xB6, 0x6C, 0x67, 0x45, 0xE2, 0xAA, 0x91, 0x6C, 0x68,
+  0x61, 0x72, 0x64, 0xE2, 0x86, 0xBD, 0x6C, 0x68, 0x61, 0x72, 0x75, 0xE2,
+  0x86, 0xBC, 0x6C, 0x68, 0x61, 0x72, 0x75, 0x6C, 0xE2, 0xA5, 0xAA, 0x6C,
+  0x68, 0x62, 0x6C, 0x6B, 0xE2, 0x96, 0x84, 0x6C, 0x6A, 0x63, 0x79, 0xD1,
+  0x99, 0x6C, 0x6C, 0xE2, 0x89, 0xAA, 0x6C, 0x6C, 0x61, 0x72, 0x72, 0xE2,
+  0x87, 0x87, 0x6C, 0x6C, 0x63, 0x6F, 0x72, 0x6E, 0x65, 0x72, 0xE2, 0x8C,
+  0x9E, 0x6C, 0x6C, 0x68, 0x61, 0x72, 0x64, 0xE2, 0xA5, 0xAB, 0x6C, 0x6C,
+  0x74, 0x72, 0x69, 0xE2, 0x97, 0xBA, 0x6C, 0x6D, 0x69, 0x64, 0x6F, 0x74,
+  0xC5, 0x80, 0x6C, 0x6D, 0x6F, 0x75, 0x73, 0x74, 0xE2, 0x8E, 0xB0, 0x6C,
+  0x6D, 0x6F, 0x75, 0x73, 0x74, 0x61, 0x63, 0x68, 0x65, 0xE2, 0x8E, 0xB0,
+  0x6C, 0x6E, 0x45, 0xE2, 0x89, 0xA8, 0x6C, 0x6E, 0x61, 0x70, 0xE2, 0xAA,
+  0x89, 0x6C, 0x6E, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0xE2, 0xAA, 0x89,
+  0x6C, 0x6E, 0x65, 0xE2, 0xAA, 0x87, 0x6C, 0x6E, 0x65, 0x71, 0xE2, 0xAA,
+  0x87, 0x6C, 0x6E, 0x65, 0x71, 0x71, 0xE2, 0x89, 0xA8, 0x6C, 0x6E, 0x73,
+  0x69, 0x6D, 0xE2, 0x8B, 0xA6, 0x6C, 0x6F, 0x61, 0x6E, 0x67, 0xE2, 0x9F,
+  0xAC, 0x6C, 0x6F, 0x61, 0x72, 0x72, 0xE2, 0x87, 0xBD, 0x6C, 0x6F, 0x62,
+  0x72, 0x6B, 0xE2, 0x9F, 0xA6, 0x6C, 0x6F, 0x6E, 0x67, 0x6C, 0x65, 0x66,
+  0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xB5, 0x6C, 0x6F, 0x6E,
+  0x67, 0x6C, 0x65, 0x66, 0x74, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72,
+  0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xB7, 0x6C, 0x6F, 0x6E, 0x67, 0x6D, 0x61,
+  0x70, 0x73, 0x74, 0x6F, 0xE2, 0x9F, 0xBC, 0x6C, 0x6F, 0x6E, 0x67, 0x72,
+  0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x9F, 0xB6,
+  0x6C, 0x6F, 0x6F, 0x70, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x6C, 0x65, 0x66,
+  0x74, 0xE2, 0x86, 0xAB, 0x6C, 0x6F, 0x6F, 0x70, 0x61, 0x72, 0x72, 0x6F,
+  0x77, 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2, 0x86, 0xAC, 0x6C, 0x6F, 0x70,
+  0x61, 0x72, 0xE2, 0xA6, 0x85, 0x6C, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95,
+  0x9D, 0x6C, 0x6F, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA8, 0xAD, 0x6C, 0x6F,
+  0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0xA8, 0xB4, 0x6C, 0x6F, 0x77, 0x61,
+  0x73, 0x74, 0xE2, 0x88, 0x97, 0x6C, 0x6F, 0x77, 0x62, 0x61, 0x72, 0x5F,
+  0x6C, 0x6F, 0x7A, 0xE2, 0x97, 0x8A, 0x6C, 0x6F, 0x7A, 0x65, 0x6E, 0x67,
+  0x65, 0xE2, 0x97, 0x8A, 0x6C, 0x6F, 0x7A, 0x66, 0xE2, 0xA7, 0xAB, 0x6C,
+  0x70, 0x61, 0x72, 0x28, 0x6C, 0x70, 0x61, 0x72, 0x6C, 0x74, 0xE2, 0xA6,
+  0x93, 0x6C, 0x72, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x86, 0x6C, 0x72, 0x63,
+  0x6F, 0x72, 0x6E, 0x65, 0x72, 0xE2, 0x8C, 0x9F, 0x6C, 0x72, 0x68, 0x61,
+  0x72, 0xE2, 0x87, 0x8B, 0x6C, 0x72, 0x68, 0x61, 0x72, 0x64, 0xE2, 0xA5,
+  0xAD, 0x6C, 0x72, 0x6D, 0xE2, 0x80, 0x8E, 0x6C, 0x72, 0x74, 0x72, 0x69,
+  0xE2, 0x8A, 0xBF, 0x6C, 0x73, 0x61, 0x71, 0x75, 0x6F, 0xE2, 0x80, 0xB9,
+  0x6C, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x81, 0x6C, 0x73, 0x68, 0xE2,
+  0x86, 0xB0, 0x6C, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0xB2, 0x6C, 0x73, 0x69,
+  0x6D, 0x65, 0xE2, 0xAA, 0x8D, 0x6C, 0x73, 0x69, 0x6D, 0x67, 0xE2, 0xAA,
+  0x8F, 0x6C, 0x73, 0x71, 0x62, 0x5B, 0x6C, 0x73, 0x71, 0x75, 0x6F, 0xE2,
+  0x80, 0x98, 0x6C, 0x73, 0x71, 0x75, 0x6F, 0x72, 0xE2, 0x80, 0x9A, 0x6C,
+  0x73, 0x74, 0x72, 0x6F, 0x6B, 0xC5, 0x82, 0x6C, 0x74, 0x3C, 0x6C, 0x74,
+  0x63, 0x63, 0xE2, 0xAA, 0xA6, 0x6C, 0x74, 0x63, 0x69, 0x72, 0xE2, 0xA9,
+  0xB9, 0x6C, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0x96, 0x6C, 0x74, 0x68,
+  0x72, 0x65, 0x65, 0xE2, 0x8B, 0x8B, 0x6C, 0x74, 0x69, 0x6D, 0x65, 0x73,
+  0xE2, 0x8B, 0x89, 0x6C, 0x74, 0x6C, 0x61, 0x72, 0x72, 0xE2, 0xA5, 0xB6,
+  0x6C, 0x74, 0x71, 0x75, 0x65, 0x73, 0x74, 0xE2, 0xA9, 0xBB, 0x6C, 0x74,
+  0x72, 0x50, 0x61, 0x72, 0xE2, 0xA6, 0x96, 0x6C, 0x74, 0x72, 0x69, 0xE2,
+  0x97, 0x83, 0x6C, 0x74, 0x72, 0x69, 0x65, 0xE2, 0x8A, 0xB4, 0x6C, 0x74,
+  0x72, 0x69, 0x66, 0xE2, 0x97, 0x82, 0x6C, 0x75, 0x72, 0x64, 0x73, 0x68,
+  0x61, 0x72, 0xE2, 0xA5, 0x8A, 0x6C, 0x75, 0x72, 0x75, 0x68, 0x61, 0x72,
+  0xE2, 0xA5, 0xA6, 0x6C, 0x76, 0x65, 0x72, 0x74, 0x6E, 0x65, 0x71, 0x71,
+  0xE2, 0x89, 0xA8, 0xEF, 0xB8, 0x80, 0x6C, 0x76, 0x6E, 0x45, 0xE2, 0x89,
+  0xA8, 0xEF, 0xB8, 0x80, 0x6D, 0x44, 0x44, 0x6F, 0x74, 0xE2, 0x88, 0xBA,
+  0x6D, 0x61, 0x63, 0x72, 0xC2, 0xAF, 0x6D, 0x61, 0x6C, 0x65, 0xE2, 0x99,
+  0x82, 0x6D, 0x61, 0x6C, 0x74, 0xE2, 0x9C, 0xA0, 0x6D, 0x61, 0x6C, 0x74,
+  0x65, 0x73, 0x65, 0xE2, 0x9C, 0xA0, 0x6D, 0x61, 0x70, 0xE2, 0x86, 0xA6,
+  0x6D, 0x61, 0x70, 0x73, 0x74, 0x6F, 0xE2, 0x86, 0xA6, 0x6D, 0x61, 0x70,
+  0x73, 0x74, 0x6F, 0x64, 0x6F, 0x77, 0x6E, 0xE2, 0x86, 0xA7, 0x6D, 0x61,
+  0x70, 0x73, 0x74, 0x6F, 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x86, 0xA4, 0x6D,
+  0x61, 0x70, 0x73, 0x74, 0x6F, 0x75, 0x70, 0xE2, 0x86, 0xA5, 0x6D, 0x61,
+  0x72, 0x6B, 0x65, 0x72, 0xE2, 0x96, 0xAE, 0x6D, 0x63, 0x6F, 0x6D, 0x6D,
+  0x61, 0xE2, 0xA8, 0xA9, 0x6D, 0x63, 0x79, 0xD0, 0xBC, 0x6D, 0x64, 0x61,
+  0x73, 0x68, 0xE2, 0x80, 0x94, 0x6D, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65,
+  0x64, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x88, 0xA1, 0x6D, 0x66, 0x72,
+  0xF0, 0x9D, 0x94, 0xAA, 0x6D, 0x68, 0x6F, 0xE2, 0x84, 0xA7, 0x6D, 0x69,
+  0x63, 0x72, 0x6F, 0xC2, 0xB5, 0x6D, 0x69, 0x64, 0xE2, 0x88, 0xA3, 0x6D,
+  0x69, 0x64, 0x61, 0x73, 0x74, 0x2A, 0x6D, 0x69, 0x64, 0x63, 0x69, 0x72,
+  0xE2, 0xAB, 0xB0, 0x6D, 0x69, 0x64, 0x64, 0x6F, 0x74, 0xC2, 0xB7, 0x6D,
+  0x69, 0x6E, 0x75, 0x73, 0xE2, 0x88, 0x92, 0x6D, 0x69, 0x6E, 0x75, 0x73,
+  0x62, 0xE2, 0x8A, 0x9F, 0x6D, 0x69, 0x6E, 0x75, 0x73, 0x64, 0xE2, 0x88,
+  0xB8, 0x6D, 0x69, 0x6E, 0x75, 0x73, 0x64, 0x75, 0xE2, 0xA8, 0xAA, 0x6D,
+  0x6C, 0x63, 0x70, 0xE2, 0xAB, 0x9B, 0x6D, 0x6C, 0x64, 0x72, 0xE2, 0x80,
+  0xA6, 0x6D, 0x6E, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0x88, 0x93, 0x6D, 0x6F,
+  0x64, 0x65, 0x6C, 0x73, 0xE2, 0x8A, 0xA7, 0x6D, 0x6F, 0x70, 0x66, 0xF0,
+  0x9D, 0x95, 0x9E, 0x6D, 0x70, 0xE2, 0x88, 0x93, 0x6D, 0x73, 0x63, 0x72,
+  0xF0, 0x9D, 0x93, 0x82, 0x6D, 0x73, 0x74, 0x70, 0x6F, 0x73, 0xE2, 0x88,
+  0xBE, 0x6D, 0x75, 0xCE, 0xBC, 0x6D, 0x75, 0x6C, 0x74, 0x69, 0x6D, 0x61,
+  0x70, 0xE2, 0x8A, 0xB8, 0x6D, 0x75, 0x6D, 0x61, 0x70, 0xE2, 0x8A, 0xB8,
+  0x6E, 0x47, 0x67, 0xE2, 0x8B, 0x99, 0xCC, 0xB8, 0x6E, 0x47, 0x74, 0xE2,
+  0x89, 0xAB, 0xE2, 0x83, 0x92, 0x6E, 0x47, 0x74, 0x76, 0xE2, 0x89, 0xAB,
+  0xCC, 0xB8, 0x6E, 0x4C, 0x65, 0x66, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77,
+  0xE2, 0x87, 0x8D, 0x6E, 0x4C, 0x65, 0x66, 0x74, 0x72, 0x69, 0x67, 0x68,
+  0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87, 0x8E, 0x6E, 0x4C, 0x6C,
+  0xE2, 0x8B, 0x98, 0xCC, 0xB8, 0x6E, 0x4C, 0x74, 0xE2, 0x89, 0xAA, 0xE2,
+  0x83, 0x92, 0x6E, 0x4C, 0x74, 0x76, 0xE2, 0x89, 0xAA, 0xCC, 0xB8, 0x6E,
+  0x52, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x87,
+  0x8F, 0x6E, 0x56, 0x44, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAF, 0x6E, 0x56,
+  0x64, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAE, 0x6E, 0x61, 0x62, 0x6C, 0x61,
+  0xE2, 0x88, 0x87, 0x6E, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0x84, 0x6E,
+  0x61, 0x6E, 0x67, 0xE2, 0x88, 0xA0, 0xE2, 0x83, 0x92, 0x6E, 0x61, 0x70,
+  0xE2, 0x89, 0x89, 0x6E, 0x61, 0x70, 0x45, 0xE2, 0xA9, 0xB0, 0xCC, 0xB8,
+  0x6E, 0x61, 0x70, 0x69, 0x64, 0xE2, 0x89, 0x8B, 0xCC, 0xB8, 0x6E, 0x61,
+  0x70, 0x6F, 0x73, 0xC5, 0x89, 0x6E, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78,
+  0xE2, 0x89, 0x89, 0x6E, 0x61, 0x74, 0x75, 0x72, 0xE2, 0x99, 0xAE, 0x6E,
+  0x61, 0x74, 0x75, 0x72, 0x61, 0x6C, 0xE2, 0x99, 0xAE, 0x6E, 0x61, 0x74,
+  0x75, 0x72, 0x61, 0x6C, 0x73, 0xE2, 0x84, 0x95, 0x6E, 0x62, 0x73, 0x70,
+  0xC2, 0xA0, 0x6E, 0x62, 0x75, 0x6D, 0x70, 0xE2, 0x89, 0x8E, 0xCC, 0xB8,
+  0x6E, 0x62, 0x75, 0x6D, 0x70, 0x65, 0xE2, 0x89, 0x8F, 0xCC, 0xB8, 0x6E,
+  0x63, 0x61, 0x70, 0xE2, 0xA9, 0x83, 0x6E, 0x63, 0x61, 0x72, 0x6F, 0x6E,
+  0xC5, 0x88, 0x6E, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0x86, 0x6E, 0x63,
+  0x6F, 0x6E, 0x67, 0xE2, 0x89, 0x87, 0x6E, 0x63, 0x6F, 0x6E, 0x67, 0x64,
+  0x6F, 0x74, 0xE2, 0xA9, 0xAD, 0xCC, 0xB8, 0x6E, 0x63, 0x75, 0x70, 0xE2,
+  0xA9, 0x82, 0x6E, 0x63, 0x79, 0xD0, 0xBD, 0x6E, 0x64, 0x61, 0x73, 0x68,
+  0xE2, 0x80, 0x93, 0x6E, 0x65, 0xE2, 0x89, 0xA0, 0x6E, 0x65, 0x41, 0x72,
+  0x72, 0xE2, 0x87, 0x97, 0x6E, 0x65, 0x61, 0x72, 0x68, 0x6B, 0xE2, 0xA4,
+  0xA4, 0x6E, 0x65, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x97, 0x6E, 0x65, 0x61,
+  0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x97, 0x6E, 0x65, 0x64, 0x6F, 0x74,
+  0xE2, 0x89, 0x90, 0xCC, 0xB8, 0x6E, 0x65, 0x71, 0x75, 0x69, 0x76, 0xE2,
+  0x89, 0xA2, 0x6E, 0x65, 0x73, 0x65, 0x61, 0x72, 0xE2, 0xA4, 0xA8, 0x6E,
+  0x65, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0x82, 0xCC, 0xB8, 0x6E, 0x65, 0x78,
+  0x69, 0x73, 0x74, 0xE2, 0x88, 0x84, 0x6E, 0x65, 0x78, 0x69, 0x73, 0x74,
+  0x73, 0xE2, 0x88, 0x84, 0x6E, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xAB, 0x6E,
+  0x67, 0x45, 0xE2, 0x89, 0xA7, 0xCC, 0xB8, 0x6E, 0x67, 0x65, 0xE2, 0x89,
+  0xB1, 0x6E, 0x67, 0x65, 0x71, 0xE2, 0x89, 0xB1, 0x6E, 0x67, 0x65, 0x71,
+  0x71, 0xE2, 0x89, 0xA7, 0xCC, 0xB8, 0x6E, 0x67, 0x65, 0x71, 0x73, 0x6C,
+  0x61, 0x6E, 0x74, 0xE2, 0xA9, 0xBE, 0xCC, 0xB8, 0x6E, 0x67, 0x65, 0x73,
+  0xE2, 0xA9, 0xBE, 0xCC, 0xB8, 0x6E, 0x67, 0x73, 0x69, 0x6D, 0xE2, 0x89,
+  0xB5, 0x6E, 0x67, 0x74, 0xE2, 0x89, 0xAF, 0x6E, 0x67, 0x74, 0x72, 0xE2,
+  0x89, 0xAF, 0x6E, 0x68, 0x41, 0x72, 0x72, 0xE2, 0x87, 0x8E, 0x6E, 0x68,
+  0x61, 0x72, 0x72, 0xE2, 0x86, 0xAE, 0x6E, 0x68, 0x70, 0x61, 0x72, 0xE2,
+  0xAB, 0xB2, 0x6E, 0x69, 0xE2, 0x88, 0x8B, 0x6E, 0x69, 0x73, 0xE2, 0x8B,
+  0xBC, 0x6E, 0x69, 0x73, 0x64, 0xE2, 0x8B, 0xBA, 0x6E, 0x69, 0x76, 0xE2,
+  0x88, 0x8B, 0x6E, 0x6A, 0x63, 0x79, 0xD1, 0x9A, 0x6E, 0x6C, 0x41, 0x72,
+  0x72, 0xE2, 0x87, 0x8D, 0x6E, 0x6C, 0x45, 0xE2, 0x89, 0xA6, 0xCC, 0xB8,
+  0x6E, 0x6C, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x9A, 0x6E, 0x6C, 0x64, 0x72,
+  0xE2, 0x80, 0xA5, 0x6E, 0x6C, 0x65, 0xE2, 0x89, 0xB0, 0x6E, 0x6C, 0x65,
+  0x66, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x9A, 0x6E, 0x6C,
+  0x65, 0x66, 0x74, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F,
+  0x77, 0xE2, 0x86, 0xAE, 0x6E, 0x6C, 0x65, 0x71, 0xE2, 0x89, 0xB0, 0x6E,
+  0x6C, 0x65, 0x71, 0x71, 0xE2, 0x89, 0xA6, 0xCC, 0xB8, 0x6E, 0x6C, 0x65,
+  0x71, 0x73, 0x6C, 0x61, 0x6E, 0x74, 0xE2, 0xA9, 0xBD, 0xCC, 0xB8, 0x6E,
+  0x6C, 0x65, 0x73, 0xE2, 0xA9, 0xBD, 0xCC, 0xB8, 0x6E, 0x6C, 0x65, 0x73,
+  0x73, 0xE2, 0x89, 0xAE, 0x6E, 0x6C, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0xB4,
+  0x6E, 0x6C, 0x74, 0xE2, 0x89, 0xAE, 0x6E, 0x6C, 0x74, 0x72, 0x69, 0xE2,
+  0x8B, 0xAA, 0x6E, 0x6C, 0x74, 0x72, 0x69, 0x65, 0xE2, 0x8B, 0xAC, 0x6E,
+  0x6D, 0x69, 0x64, 0xE2, 0x88, 0xA4, 0x6E, 0x6F, 0x70, 0x66, 0xF0, 0x9D,
+  0x95, 0x9F, 0x6E, 0x6F, 0x74, 0xC2, 0xAC, 0x6E, 0x6F, 0x74, 0x69, 0x6E,
+  0xE2, 0x88, 0x89, 0x6E, 0x6F, 0x74, 0x69, 0x6E, 0x45, 0xE2, 0x8B, 0xB9,
+  0xCC, 0xB8, 0x6E, 0x6F, 0x74, 0x69, 0x6E, 0x64, 0x6F, 0x74, 0xE2, 0x8B,
+  0xB5, 0xCC, 0xB8, 0x6E, 0x6F, 0x74, 0x69, 0x6E, 0x76, 0x61, 0xE2, 0x88,
+  0x89, 0x6E, 0x6F, 0x74, 0x69, 0x6E, 0x76, 0x62, 0xE2, 0x8B, 0xB7, 0x6E,
+  0x6F, 0x74, 0x69, 0x6E, 0x76, 0x63, 0xE2, 0x8B, 0xB6, 0x6E, 0x6F, 0x74,
+  0x6E, 0x69, 0xE2, 0x88, 0x8C, 0x6E, 0x6F, 0x74, 0x6E, 0x69, 0x76, 0x61,
+  0xE2, 0x88, 0x8C, 0x6E, 0x6F, 0x74, 0x6E, 0x69, 0x76, 0x62, 0xE2, 0x8B,
+  0xBE, 0x6E, 0x6F, 0x74, 0x6E, 0x69, 0x76, 0x63, 0xE2, 0x8B, 0xBD, 0x6E,
+  0x70, 0x61, 0x72, 0xE2, 0x88, 0xA6, 0x6E, 0x70, 0x61, 0x72, 0x61, 0x6C,
+  0x6C, 0x65, 0x6C, 0xE2, 0x88, 0xA6, 0x6E, 0x70, 0x61, 0x72, 0x73, 0x6C,
+  0xE2, 0xAB, 0xBD, 0xE2, 0x83, 0xA5, 0x6E, 0x70, 0x61, 0x72, 0x74, 0xE2,
+  0x88, 0x82, 0xCC, 0xB8, 0x6E, 0x70, 0x6F, 0x6C, 0x69, 0x6E, 0x74, 0xE2,
+  0xA8, 0x94, 0x6E, 0x70, 0x72, 0xE2, 0x8A, 0x80, 0x6E, 0x70, 0x72, 0x63,
+  0x75, 0x65, 0xE2, 0x8B, 0xA0, 0x6E, 0x70, 0x72, 0x65, 0xE2, 0xAA, 0xAF,
+  0xCC, 0xB8, 0x6E, 0x70, 0x72, 0x65, 0x63, 0xE2, 0x8A, 0x80, 0x6E, 0x70,
+  0x72, 0x65, 0x63, 0x65, 0x71, 0xE2, 0xAA, 0xAF, 0xCC, 0xB8, 0x6E, 0x72,
+  0x41, 0x72, 0x72, 0xE2, 0x87, 0x8F, 0x6E, 0x72, 0x61, 0x72, 0x72, 0xE2,
+  0x86, 0x9B, 0x6E, 0x72, 0x61, 0x72, 0x72, 0x63, 0xE2, 0xA4, 0xB3, 0xCC,
+  0xB8, 0x6E, 0x72, 0x61, 0x72, 0x72, 0x77, 0xE2, 0x86, 0x9D, 0xCC, 0xB8,
+  0x6E, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2,
+  0x86, 0x9B, 0x6E, 0x72, 0x74, 0x72, 0x69, 0xE2, 0x8B, 0xAB, 0x6E, 0x72,
+  0x74, 0x72, 0x69, 0x65, 0xE2, 0x8B, 0xAD, 0x6E, 0x73, 0x63, 0xE2, 0x8A,
+  0x81, 0x6E, 0x73, 0x63, 0x63, 0x75, 0x65, 0xE2, 0x8B, 0xA1, 0x6E, 0x73,
+  0x63, 0x65, 0xE2, 0xAA, 0xB0, 0xCC, 0xB8, 0x6E, 0x73, 0x63, 0x72, 0xF0,
+  0x9D, 0x93, 0x83, 0x6E, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x6D, 0x69, 0x64,
+  0xE2, 0x88, 0xA4, 0x6E, 0x73, 0x68, 0x6F, 0x72, 0x74, 0x70, 0x61, 0x72,
+  0x61, 0x6C, 0x6C, 0x65, 0x6C, 0xE2, 0x88, 0xA6, 0x6E, 0x73, 0x69, 0x6D,
+  0xE2, 0x89, 0x81, 0x6E, 0x73, 0x69, 0x6D, 0x65, 0xE2, 0x89, 0x84, 0x6E,
+  0x73, 0x69, 0x6D, 0x65, 0x71, 0xE2, 0x89, 0x84, 0x6E, 0x73, 0x6D, 0x69,
+  0x64, 0xE2, 0x88, 0xA4, 0x6E, 0x73, 0x70, 0x61, 0x72, 0xE2, 0x88, 0xA6,
+  0x6E, 0x73, 0x71, 0x73, 0x75, 0x62, 0x65, 0xE2, 0x8B, 0xA2, 0x6E, 0x73,
+  0x71, 0x73, 0x75, 0x70, 0x65, 0xE2, 0x8B, 0xA3, 0x6E, 0x73, 0x75, 0x62,
+  0xE2, 0x8A, 0x84, 0x6E, 0x73, 0x75, 0x62, 0x45, 0xE2, 0xAB, 0x85, 0xCC,
+  0xB8, 0x6E, 0x73, 0x75, 0x62, 0x65, 0xE2, 0x8A, 0x88, 0x6E, 0x73, 0x75,
+  0x62, 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x82, 0xE2, 0x83, 0x92, 0x6E, 0x73,
+  0x75, 0x62, 0x73, 0x65, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0x88, 0x6E, 0x73,
+  0x75, 0x62, 0x73, 0x65, 0x74, 0x65, 0x71, 0x71, 0xE2, 0xAB, 0x85, 0xCC,
+  0xB8, 0x6E, 0x73, 0x75, 0x63, 0x63, 0xE2, 0x8A, 0x81, 0x6E, 0x73, 0x75,
+  0x63, 0x63, 0x65, 0x71, 0xE2, 0xAA, 0xB0, 0xCC, 0xB8, 0x6E, 0x73, 0x75,
+  0x70, 0xE2, 0x8A, 0x85, 0x6E, 0x73, 0x75, 0x70, 0x45, 0xE2, 0xAB, 0x86,
+  0xCC, 0xB8, 0x6E, 0x73, 0x75, 0x70, 0x65, 0xE2, 0x8A, 0x89, 0x6E, 0x73,
+  0x75, 0x70, 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x83, 0xE2, 0x83, 0x92, 0x6E,
+  0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0x89, 0x6E,
+  0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x65, 0x71, 0x71, 0xE2, 0xAB, 0x86,
+  0xCC, 0xB8, 0x6E, 0x74, 0x67, 0x6C, 0xE2, 0x89, 0xB9, 0x6E, 0x74, 0x69,
+  0x6C, 0x64, 0x65, 0xC3, 0xB1, 0x6E, 0x74, 0x6C, 0x67, 0xE2, 0x89, 0xB8,
+  0x6E, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x6C, 0x65, 0x66,
+  0x74, 0xE2, 0x8B, 0xAA, 0x6E, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C,
+  0x65, 0x6C, 0x65, 0x66, 0x74, 0x65, 0x71, 0xE2, 0x8B, 0xAC, 0x6E, 0x74,
+  0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x72, 0x69, 0x67, 0x68, 0x74,
+  0xE2, 0x8B, 0xAB, 0x6E, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65,
+  0x72, 0x69, 0x67, 0x68, 0x74, 0x65, 0x71, 0xE2, 0x8B, 0xAD, 0x6E, 0x75,
+  0xCE, 0xBD, 0x6E, 0x75, 0x6D, 0x23, 0x6E, 0x75, 0x6D, 0x65, 0x72, 0x6F,
+  0xE2, 0x84, 0x96, 0x6E, 0x75, 0x6D, 0x73, 0x70, 0xE2, 0x80, 0x87, 0x6E,
+  0x76, 0x44, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAD, 0x6E, 0x76, 0x48, 0x61,
+  0x72, 0x72, 0xE2, 0xA4, 0x84, 0x6E, 0x76, 0x61, 0x70, 0xE2, 0x89, 0x8D,
+  0xE2, 0x83, 0x92, 0x6E, 0x76, 0x64, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0xAC,
+  0x6E, 0x76, 0x67, 0x65, 0xE2, 0x89, 0xA5, 0xE2, 0x83, 0x92, 0x6E, 0x76,
+  0x67, 0x74, 0x3E, 0xE2, 0x83, 0x92, 0x6E, 0x76, 0x69, 0x6E, 0x66, 0x69,
+  0x6E, 0xE2, 0xA7, 0x9E, 0x6E, 0x76, 0x6C, 0x41, 0x72, 0x72, 0xE2, 0xA4,
+  0x82, 0x6E, 0x76, 0x6C, 0x65, 0xE2, 0x89, 0xA4, 0xE2, 0x83, 0x92, 0x6E,
+  0x76, 0x6C, 0x74, 0x3C, 0xE2, 0x83, 0x92, 0x6E, 0x76, 0x6C, 0x74, 0x72,
+  0x69, 0x65, 0xE2, 0x8A, 0xB4, 0xE2, 0x83, 0x92, 0x6E, 0x76, 0x72, 0x41,
+  0x72, 0x72, 0xE2, 0xA4, 0x83, 0x6E, 0x76, 0x72, 0x74, 0x72, 0x69, 0x65,
+  0xE2, 0x8A, 0xB5, 0xE2, 0x83, 0x92, 0x6E, 0x76, 0x73, 0x69, 0x6D, 0xE2,
+  0x88, 0xBC, 0xE2, 0x83, 0x92, 0x6E, 0x77, 0x41, 0x72, 0x72, 0xE2, 0x87,
+  0x96, 0x6E, 0x77, 0x61, 0x72, 0x68, 0x6B, 0xE2, 0xA4, 0xA3, 0x6E, 0x77,
+  0x61, 0x72, 0x72, 0xE2, 0x86, 0x96, 0x6E, 0x77, 0x61, 0x72, 0x72, 0x6F,
+  0x77, 0xE2, 0x86, 0x96, 0x6E, 0x77, 0x6E, 0x65, 0x61, 0x72, 0xE2, 0xA4,
+  0xA7, 0x6F, 0x53, 0xE2, 0x93, 0x88, 0x6F, 0x61, 0x63, 0x75, 0x74, 0x65,
+  0xC3, 0xB3, 0x6F, 0x61, 0x73, 0x74, 0xE2, 0x8A, 0x9B, 0x6F, 0x63, 0x69,
+  0x72, 0xE2, 0x8A, 0x9A, 0x6F, 0x63, 0x69, 0x72, 0x63, 0xC3, 0xB4, 0x6F,
+  0x63, 0x79, 0xD0, 0xBE, 0x6F, 0x64, 0x61, 0x73, 0x68, 0xE2, 0x8A, 0x9D,
+  0x6F, 0x64, 0x62, 0x6C, 0x61, 0x63, 0xC5, 0x91, 0x6F, 0x64, 0x69, 0x76,
+  0xE2, 0xA8, 0xB8, 0x6F, 0x64, 0x6F, 0x74, 0xE2, 0x8A, 0x99, 0x6F, 0x64,
+  0x73, 0x6F, 0x6C, 0x64, 0xE2, 0xA6, 0xBC, 0x6F, 0x65, 0x6C, 0x69, 0x67,
+  0xC5, 0x93, 0x6F, 0x66, 0x63, 0x69, 0x72, 0xE2, 0xA6, 0xBF, 0x6F, 0x66,
+  0x72, 0xF0, 0x9D, 0x94, 0xAC, 0x6F, 0x67, 0x6F, 0x6E, 0xCB, 0x9B, 0x6F,
+  0x67, 0x72, 0x61, 0x76, 0x65, 0xC3, 0xB2, 0x6F, 0x67, 0x74, 0xE2, 0xA7,
+  0x81, 0x6F, 0x68, 0x62, 0x61, 0x72, 0xE2, 0xA6, 0xB5, 0x6F, 0x68, 0x6D,
+  0xCE, 0xA9, 0x6F, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xAE, 0x6F, 0x6C, 0x61,
+  0x72, 0x72, 0xE2, 0x86, 0xBA, 0x6F, 0x6C, 0x63, 0x69, 0x72, 0xE2, 0xA6,
+  0xBE, 0x6F, 0x6C, 0x63, 0x72, 0x6F, 0x73, 0x73, 0xE2, 0xA6, 0xBB, 0x6F,
+  0x6C, 0x69, 0x6E, 0x65, 0xE2, 0x80, 0xBE, 0x6F, 0x6C, 0x74, 0xE2, 0xA7,
+  0x80, 0x6F, 0x6D, 0x61, 0x63, 0x72, 0xC5, 0x8D, 0x6F, 0x6D, 0x65, 0x67,
+  0x61, 0xCF, 0x89, 0x6F, 0x6D, 0x69, 0x63, 0x72, 0x6F, 0x6E, 0xCE, 0xBF,
+  0x6F, 0x6D, 0x69, 0x64, 0xE2, 0xA6, 0xB6, 0x6F, 0x6D, 0x69, 0x6E, 0x75,
+  0x73, 0xE2, 0x8A, 0x96, 0x6F, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xA0,
+  0x6F, 0x70, 0x61, 0x72, 0xE2, 0xA6, 0xB7, 0x6F, 0x70, 0x65, 0x72, 0x70,
+  0xE2, 0xA6, 0xB9, 0x6F, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0x8A, 0x95, 0x6F,
+  0x72, 0xE2, 0x88, 0xA8, 0x6F, 0x72, 0x61, 0x72, 0x72, 0xE2, 0x86, 0xBB,
+  0x6F, 0x72, 0x64, 0xE2, 0xA9, 0x9D, 0x6F, 0x72, 0x64, 0x65, 0x72, 0xE2,
+  0x84, 0xB4, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x6F, 0x66, 0xE2, 0x84, 0xB4,
+  0x6F, 0x72, 0x64, 0x66, 0xC2, 0xAA, 0x6F, 0x72, 0x64, 0x6D, 0xC2, 0xBA,
+  0x6F, 0x72, 0x69, 0x67, 0x6F, 0x66, 0xE2, 0x8A, 0xB6, 0x6F, 0x72, 0x6F,
+  0x72, 0xE2, 0xA9, 0x96, 0x6F, 0x72, 0x73, 0x6C, 0x6F, 0x70, 0x65, 0xE2,
+  0xA9, 0x97, 0x6F, 0x72, 0x76, 0xE2, 0xA9, 0x9B, 0x6F, 0x73, 0x63, 0x72,
+  0xE2, 0x84, 0xB4, 0x6F, 0x73, 0x6C, 0x61, 0x73, 0x68, 0xC3, 0xB8, 0x6F,
+  0x73, 0x6F, 0x6C, 0xE2, 0x8A, 0x98, 0x6F, 0x74, 0x69, 0x6C, 0x64, 0x65,
+  0xC3, 0xB5, 0x6F, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0x8A, 0x97, 0x6F,
+  0x74, 0x69, 0x6D, 0x65, 0x73, 0x61, 0x73, 0xE2, 0xA8, 0xB6, 0x6F, 0x75,
+  0x6D, 0x6C, 0xC3, 0xB6, 0x6F, 0x76, 0x62, 0x61, 0x72, 0xE2, 0x8C, 0xBD,
+  0x70, 0x61, 0x72, 0xE2, 0x88, 0xA5, 0x70, 0x61, 0x72, 0x61, 0xC2, 0xB6,
+  0x70, 0x61, 0x72, 0x61, 0x6C, 0x6C, 0x65, 0x6C, 0xE2, 0x88, 0xA5, 0x70,
+  0x61, 0x72, 0x73, 0x69, 0x6D, 0xE2, 0xAB, 0xB3, 0x70, 0x61, 0x72, 0x73,
+  0x6C, 0xE2, 0xAB, 0xBD, 0x70, 0x61, 0x72, 0x74, 0xE2, 0x88, 0x82, 0x70,
+  0x63, 0x79, 0xD0, 0xBF, 0x70, 0x65, 0x72, 0x63, 0x6E, 0x74, 0x25, 0x70,
+  0x65, 0x72, 0x69, 0x6F, 0x64, 0x2E, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x6C,
+  0xE2, 0x80, 0xB0, 0x70, 0x65, 0x72, 0x70, 0xE2, 0x8A, 0xA5, 0x70, 0x65,
+  0x72, 0x74, 0x65, 0x6E, 0x6B, 0xE2, 0x80, 0xB1, 0x70, 0x66, 0x72, 0xF0,
+  0x9D, 0x94, 0xAD, 0x70, 0x68, 0x69, 0xCF, 0x86, 0x70, 0x68, 0x69, 0x76,
+  0xCF, 0x95, 0x70, 0x68, 0x6D, 0x6D, 0x61, 0x74, 0xE2, 0x84, 0xB3, 0x70,
+  0x68, 0x6F, 0x6E, 0x65, 0xE2, 0x98, 0x8E, 0x70, 0x69, 0xCF, 0x80, 0x70,
+  0x69, 0x74, 0x63, 0x68, 0x66, 0x6F, 0x72, 0x6B, 0xE2, 0x8B, 0x94, 0x70,
+  0x69, 0x76, 0xCF, 0x96, 0x70, 0x6C, 0x61, 0x6E, 0x63, 0x6B, 0xE2, 0x84,
+  0x8F, 0x70, 0x6C, 0x61, 0x6E, 0x63, 0x6B, 0x68, 0xE2, 0x84, 0x8E, 0x70,
+  0x6C, 0x61, 0x6E, 0x6B, 0x76, 0xE2, 0x84, 0x8F, 0x70, 0x6C, 0x75, 0x73,
+  0x2B, 0x70, 0x6C, 0x75, 0x73, 0x61, 0x63, 0x69, 0x72, 0xE2, 0xA8, 0xA3,
+  0x70, 0x6C, 0x75, 0x73, 0x62, 0xE2, 0x8A, 0x9E, 0x70, 0x6C, 0x75, 0x73,
+  0x63, 0x69, 0x72, 0xE2, 0xA8, 0xA2, 0x70, 0x6C, 0x75, 0x73, 0x64, 0x6F,
+  0xE2, 0x88, 0x94, 0x70, 0x6C, 0x75, 0x73, 0x64, 0x75, 0xE2, 0xA8, 0xA5,
+  0x70, 0x6C, 0x75, 0x73, 0x65, 0xE2, 0xA9, 0xB2, 0x70, 0x6C, 0x75, 0x73,
+  0x6D, 0x6E, 0xC2, 0xB1, 0x70, 0x6C, 0x75, 0x73, 0x73, 0x69, 0x6D, 0xE2,
+  0xA8, 0xA6, 0x70, 0x6C, 0x75, 0x73, 0x74, 0x77, 0x6F, 0xE2, 0xA8, 0xA7,
+  0x70, 0x6D, 0xC2, 0xB1, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x69, 0x6E, 0x74,
+  0xE2, 0xA8, 0x95, 0x70, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xA1, 0x70,
+  0x6F, 0x75, 0x6E, 0x64, 0xC2, 0xA3, 0x70, 0x72, 0xE2, 0x89, 0xBA, 0x70,
+  0x72, 0x45, 0xE2, 0xAA, 0xB3, 0x70, 0x72, 0x61, 0x70, 0xE2, 0xAA, 0xB7,
+  0x70, 0x72, 0x63, 0x75, 0x65, 0xE2, 0x89, 0xBC, 0x70, 0x72, 0x65, 0xE2,
+  0xAA, 0xAF, 0x70, 0x72, 0x65, 0x63, 0xE2, 0x89, 0xBA, 0x70, 0x72, 0x65,
+  0x63, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0xE2, 0xAA, 0xB7, 0x70, 0x72,
+  0x65, 0x63, 0x63, 0x75, 0x72, 0x6C, 0x79, 0x65, 0x71, 0xE2, 0x89, 0xBC,
+  0x70, 0x72, 0x65, 0x63, 0x65, 0x71, 0xE2, 0xAA, 0xAF, 0x70, 0x72, 0x65,
+  0x63, 0x6E, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0xE2, 0xAA, 0xB9, 0x70,
+  0x72, 0x65, 0x63, 0x6E, 0x65, 0x71, 0x71, 0xE2, 0xAA, 0xB5, 0x70, 0x72,
+  0x65, 0x63, 0x6E, 0x73, 0x69, 0x6D, 0xE2, 0x8B, 0xA8, 0x70, 0x72, 0x65,
+  0x63, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0xBE, 0x70, 0x72, 0x69, 0x6D, 0x65,
+  0xE2, 0x80, 0xB2, 0x70, 0x72, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0x84, 0x99,
+  0x70, 0x72, 0x6E, 0x45, 0xE2, 0xAA, 0xB5, 0x70, 0x72, 0x6E, 0x61, 0x70,
+  0xE2, 0xAA, 0xB9, 0x70, 0x72, 0x6E, 0x73, 0x69, 0x6D, 0xE2, 0x8B, 0xA8,
+  0x70, 0x72, 0x6F, 0x64, 0xE2, 0x88, 0x8F, 0x70, 0x72, 0x6F, 0x66, 0x61,
+  0x6C, 0x61, 0x72, 0xE2, 0x8C, 0xAE, 0x70, 0x72, 0x6F, 0x66, 0x6C, 0x69,
+  0x6E, 0x65, 0xE2, 0x8C, 0x92, 0x70, 0x72, 0x6F, 0x66, 0x73, 0x75, 0x72,
+  0x66, 0xE2, 0x8C, 0x93, 0x70, 0x72, 0x6F, 0x70, 0xE2, 0x88, 0x9D, 0x70,
+  0x72, 0x6F, 0x70, 0x74, 0x6F, 0xE2, 0x88, 0x9D, 0x70, 0x72, 0x73, 0x69,
+  0x6D, 0xE2, 0x89, 0xBE, 0x70, 0x72, 0x75, 0x72, 0x65, 0x6C, 0xE2, 0x8A,
+  0xB0, 0x70, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x85, 0x70, 0x73, 0x69,
+  0xCF, 0x88, 0x70, 0x75, 0x6E, 0x63, 0x73, 0x70, 0xE2, 0x80, 0x88, 0x71,
+  0x66, 0x72, 0xF0, 0x9D, 0x94, 0xAE, 0x71, 0x69, 0x6E, 0x74, 0xE2, 0xA8,
+  0x8C, 0x71, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xA2, 0x71, 0x70, 0x72,
+  0x69, 0x6D, 0x65, 0xE2, 0x81, 0x97, 0x71, 0x73, 0x63, 0x72, 0xF0, 0x9D,
+  0x93, 0x86, 0x71, 0x75, 0x61, 0x74, 0x65, 0x72, 0x6E, 0x69, 0x6F, 0x6E,
+  0x73, 0xE2, 0x84, 0x8D, 0x71, 0x75, 0x61, 0x74, 0x69, 0x6E, 0x74, 0xE2,
+  0xA8, 0x96, 0x71, 0x75, 0x65, 0x73, 0x74, 0x3F, 0x71, 0x75, 0x65, 0x73,
+  0x74, 0x65, 0x71, 0xE2, 0x89, 0x9F, 0x71, 0x75, 0x6F, 0x74, 0x22, 0x72,
+  0x41, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x9B, 0x72, 0x41, 0x72, 0x72, 0xE2,
+  0x87, 0x92, 0x72, 0x41, 0x74, 0x61, 0x69, 0x6C, 0xE2, 0xA4, 0x9C, 0x72,
+  0x42, 0x61, 0x72, 0x72, 0xE2, 0xA4, 0x8F, 0x72, 0x48, 0x61, 0x72, 0xE2,
+  0xA5, 0xA4, 0x72, 0x61, 0x63, 0x65, 0xE2, 0x88, 0xBD, 0xCC, 0xB1, 0x72,
+  0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0x95, 0x72, 0x61, 0x64, 0x69, 0x63,
+  0xE2, 0x88, 0x9A, 0x72, 0x61, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x76, 0xE2,
+  0xA6, 0xB3, 0x72, 0x61, 0x6E, 0x67, 0xE2, 0x9F, 0xA9, 0x72, 0x61, 0x6E,
+  0x67, 0x64, 0xE2, 0xA6, 0x92, 0x72, 0x61, 0x6E, 0x67, 0x65, 0xE2, 0xA6,
+  0xA5, 0x72, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x9F, 0xA9, 0x72, 0x61,
+  0x71, 0x75, 0x6F, 0xC2, 0xBB, 0x72, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x92,
+  0x72, 0x61, 0x72, 0x72, 0x61, 0x70, 0xE2, 0xA5, 0xB5, 0x72, 0x61, 0x72,
+  0x72, 0x62, 0xE2, 0x87, 0xA5, 0x72, 0x61, 0x72, 0x72, 0x62, 0x66, 0x73,
+  0xE2, 0xA4, 0xA0, 0x72, 0x61, 0x72, 0x72, 0x63, 0xE2, 0xA4, 0xB3, 0x72,
+  0x61, 0x72, 0x72, 0x66, 0x73, 0xE2, 0xA4, 0x9E, 0x72, 0x61, 0x72, 0x72,
+  0x68, 0x6B, 0xE2, 0x86, 0xAA, 0x72, 0x61, 0x72, 0x72, 0x6C, 0x70, 0xE2,
+  0x86, 0xAC, 0x72, 0x61, 0x72, 0x72, 0x70, 0x6C, 0xE2, 0xA5, 0x85, 0x72,
+  0x61, 0x72, 0x72, 0x73, 0x69, 0x6D, 0xE2, 0xA5, 0xB4, 0x72, 0x61, 0x72,
+  0x72, 0x74, 0x6C, 0xE2, 0x86, 0xA3, 0x72, 0x61, 0x72, 0x72, 0x77, 0xE2,
+  0x86, 0x9D, 0x72, 0x61, 0x74, 0x61, 0x69, 0x6C, 0xE2, 0xA4, 0x9A, 0x72,
+  0x61, 0x74, 0x69, 0x6F, 0xE2, 0x88, 0xB6, 0x72, 0x61, 0x74, 0x69, 0x6F,
+  0x6E, 0x61, 0x6C, 0x73, 0xE2, 0x84, 0x9A, 0x72, 0x62, 0x61, 0x72, 0x72,
+  0xE2, 0xA4, 0x8D, 0x72, 0x62, 0x62, 0x72, 0x6B, 0xE2, 0x9D, 0xB3, 0x72,
+  0x62, 0x72, 0x61, 0x63, 0x65, 0x7D, 0x72, 0x62, 0x72, 0x61, 0x63, 0x6B,
+  0x5D, 0x72, 0x62, 0x72, 0x6B, 0x65, 0xE2, 0xA6, 0x8C, 0x72, 0x62, 0x72,
+  0x6B, 0x73, 0x6C, 0x64, 0xE2, 0xA6, 0x8E, 0x72, 0x62, 0x72, 0x6B, 0x73,
+  0x6C, 0x75, 0xE2, 0xA6, 0x90, 0x72, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5,
+  0x99, 0x72, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0x97, 0x72, 0x63, 0x65,
+  0x69, 0x6C, 0xE2, 0x8C, 0x89, 0x72, 0x63, 0x75, 0x62, 0x7D, 0x72, 0x63,
+  0x79, 0xD1, 0x80, 0x72, 0x64, 0x63, 0x61, 0xE2, 0xA4, 0xB7, 0x72, 0x64,
+  0x6C, 0x64, 0x68, 0x61, 0x72, 0xE2, 0xA5, 0xA9, 0x72, 0x64, 0x71, 0x75,
+  0x6F, 0xE2, 0x80, 0x9D, 0x72, 0x64, 0x71, 0x75, 0x6F, 0x72, 0xE2, 0x80,
+  0x9D, 0x72, 0x64, 0x73, 0x68, 0xE2, 0x86, 0xB3, 0x72, 0x65, 0x61, 0x6C,
+  0xE2, 0x84, 0x9C, 0x72, 0x65, 0x61, 0x6C, 0x69, 0x6E, 0x65, 0xE2, 0x84,
+  0x9B, 0x72, 0x65, 0x61, 0x6C, 0x70, 0x61, 0x72, 0x74, 0xE2, 0x84, 0x9C,
+  0x72, 0x65, 0x61, 0x6C, 0x73, 0xE2, 0x84, 0x9D, 0x72, 0x65, 0x63, 0x74,
+  0xE2, 0x96, 0xAD, 0x72, 0x65, 0x67, 0xC2, 0xAE, 0x72, 0x66, 0x69, 0x73,
+  0x68, 0x74, 0xE2, 0xA5, 0xBD, 0x72, 0x66, 0x6C, 0x6F, 0x6F, 0x72, 0xE2,
+  0x8C, 0x8B, 0x72, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xAF, 0x72, 0x68, 0x61,
+  0x72, 0x64, 0xE2, 0x87, 0x81, 0x72, 0x68, 0x61, 0x72, 0x75, 0xE2, 0x87,
+  0x80, 0x72, 0x68, 0x61, 0x72, 0x75, 0x6C, 0xE2, 0xA5, 0xAC, 0x72, 0x68,
+  0x6F, 0xCF, 0x81, 0x72, 0x68, 0x6F, 0x76, 0xCF, 0xB1, 0x72, 0x69, 0x67,
+  0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x92, 0x72, 0x69,
+  0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x74, 0x61, 0x69, 0x6C,
+  0xE2, 0x86, 0xA3, 0x72, 0x69, 0x67, 0x68, 0x74, 0x68, 0x61, 0x72, 0x70,
+  0x6F, 0x6F, 0x6E, 0x64, 0x6F, 0x77, 0x6E, 0xE2, 0x87, 0x81, 0x72, 0x69,
+  0x67, 0x68, 0x74, 0x68, 0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, 0x75, 0x70,
+  0xE2, 0x87, 0x80, 0x72, 0x69, 0x67, 0x68, 0x74, 0x6C, 0x65, 0x66, 0x74,
+  0x61, 0x72, 0x72, 0x6F, 0x77, 0x73, 0xE2, 0x87, 0x84, 0x72, 0x69, 0x67,
+  0x68, 0x74, 0x6C, 0x65, 0x66, 0x74, 0x68, 0x61, 0x72, 0x70, 0x6F, 0x6F,
+  0x6E, 0x73, 0xE2, 0x87, 0x8C, 0x72, 0x69, 0x67, 0x68, 0x74, 0x72, 0x69,
+  0x67, 0x68, 0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0x73, 0xE2, 0x87, 0x89,
+  0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x71, 0x75, 0x69, 0x67, 0x61, 0x72,
+  0x72, 0x6F, 0x77, 0xE2, 0x86, 0x9D, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74,
+  0x68, 0x72, 0x65, 0x65, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0x8B, 0x8C,
+  0x72, 0x69, 0x6E, 0x67, 0xCB, 0x9A, 0x72, 0x69, 0x73, 0x69, 0x6E, 0x67,
+  0x64, 0x6F, 0x74, 0x73, 0x65, 0x71, 0xE2, 0x89, 0x93, 0x72, 0x6C, 0x61,
+  0x72, 0x72, 0xE2, 0x87, 0x84, 0x72, 0x6C, 0x68, 0x61, 0x72, 0xE2, 0x87,
+  0x8C, 0x72, 0x6C, 0x6D, 0xE2, 0x80, 0x8F, 0x72, 0x6D, 0x6F, 0x75, 0x73,
+  0x74, 0xE2, 0x8E, 0xB1, 0x72, 0x6D, 0x6F, 0x75, 0x73, 0x74, 0x61, 0x63,
+  0x68, 0x65, 0xE2, 0x8E, 0xB1, 0x72, 0x6E, 0x6D, 0x69, 0x64, 0xE2, 0xAB,
+  0xAE, 0x72, 0x6F, 0x61, 0x6E, 0x67, 0xE2, 0x9F, 0xAD, 0x72, 0x6F, 0x61,
+  0x72, 0x72, 0xE2, 0x87, 0xBE, 0x72, 0x6F, 0x62, 0x72, 0x6B, 0xE2, 0x9F,
+  0xA7, 0x72, 0x6F, 0x70, 0x61, 0x72, 0xE2, 0xA6, 0x86, 0x72, 0x6F, 0x70,
+  0x66, 0xF0, 0x9D, 0x95, 0xA3, 0x72, 0x6F, 0x70, 0x6C, 0x75, 0x73, 0xE2,
+  0xA8, 0xAE, 0x72, 0x6F, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0xA8, 0xB5,
+  0x72, 0x70, 0x61, 0x72, 0x29, 0x72, 0x70, 0x61, 0x72, 0x67, 0x74, 0xE2,
+  0xA6, 0x94, 0x72, 0x70, 0x70, 0x6F, 0x6C, 0x69, 0x6E, 0x74, 0xE2, 0xA8,
+  0x92, 0x72, 0x72, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x89, 0x72, 0x73, 0x61,
+  0x71, 0x75, 0x6F, 0xE2, 0x80, 0xBA, 0x72, 0x73, 0x63, 0x72, 0xF0, 0x9D,
+  0x93, 0x87, 0x72, 0x73, 0x68, 0xE2, 0x86, 0xB1, 0x72, 0x73, 0x71, 0x62,
+  0x5D, 0x72, 0x73, 0x71, 0x75, 0x6F, 0xE2, 0x80, 0x99, 0x72, 0x73, 0x71,
+  0x75, 0x6F, 0x72, 0xE2, 0x80, 0x99, 0x72, 0x74, 0x68, 0x72, 0x65, 0x65,
+  0xE2, 0x8B, 0x8C, 0x72, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xE2, 0x8B, 0x8A,
+  0x72, 0x74, 0x72, 0x69, 0xE2, 0x96, 0xB9, 0x72, 0x74, 0x72, 0x69, 0x65,
+  0xE2, 0x8A, 0xB5, 0x72, 0x74, 0x72, 0x69, 0x66, 0xE2, 0x96, 0xB8, 0x72,
+  0x74, 0x72, 0x69, 0x6C, 0x74, 0x72, 0x69, 0xE2, 0xA7, 0x8E, 0x72, 0x75,
+  0x6C, 0x75, 0x68, 0x61, 0x72, 0xE2, 0xA5, 0xA8, 0x72, 0x78, 0xE2, 0x84,
+  0x9E, 0x73, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0x9B, 0x73, 0x62, 0x71,
+  0x75, 0x6F, 0xE2, 0x80, 0x9A, 0x73, 0x63, 0xE2, 0x89, 0xBB, 0x73, 0x63,
+  0x45, 0xE2, 0xAA, 0xB4, 0x73, 0x63, 0x61, 0x70, 0xE2, 0xAA, 0xB8, 0x73,
+  0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5, 0xA1, 0x73, 0x63, 0x63, 0x75, 0x65,
+  0xE2, 0x89, 0xBD, 0x73, 0x63, 0x65, 0xE2, 0xAA, 0xB0, 0x73, 0x63, 0x65,
+  0x64, 0x69, 0x6C, 0xC5, 0x9F, 0x73, 0x63, 0x69, 0x72, 0x63, 0xC5, 0x9D,
+  0x73, 0x63, 0x6E, 0x45, 0xE2, 0xAA, 0xB6, 0x73, 0x63, 0x6E, 0x61, 0x70,
+  0xE2, 0xAA, 0xBA, 0x73, 0x63, 0x6E, 0x73, 0x69, 0x6D, 0xE2, 0x8B, 0xA9,
+  0x73, 0x63, 0x70, 0x6F, 0x6C, 0x69, 0x6E, 0x74, 0xE2, 0xA8, 0x93, 0x73,
+  0x63, 0x73, 0x69, 0x6D, 0xE2, 0x89, 0xBF, 0x73, 0x63, 0x79, 0xD1, 0x81,
+  0x73, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0x85, 0x73, 0x64, 0x6F, 0x74, 0x62,
+  0xE2, 0x8A, 0xA1, 0x73, 0x64, 0x6F, 0x74, 0x65, 0xE2, 0xA9, 0xA6, 0x73,
+  0x65, 0x41, 0x72, 0x72, 0xE2, 0x87, 0x98, 0x73, 0x65, 0x61, 0x72, 0x68,
+  0x6B, 0xE2, 0xA4, 0xA5, 0x73, 0x65, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x98,
+  0x73, 0x65, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x98, 0x73, 0x65,
+  0x63, 0x74, 0xC2, 0xA7, 0x73, 0x65, 0x6D, 0x69, 0x3B, 0x73, 0x65, 0x73,
+  0x77, 0x61, 0x72, 0xE2, 0xA4, 0xA9, 0x73, 0x65, 0x74, 0x6D, 0x69, 0x6E,
+  0x75, 0x73, 0xE2, 0x88, 0x96, 0x73, 0x65, 0x74, 0x6D, 0x6E, 0xE2, 0x88,
+  0x96, 0x73, 0x65, 0x78, 0x74, 0xE2, 0x9C, 0xB6, 0x73, 0x66, 0x72, 0xF0,
+  0x9D, 0x94, 0xB0, 0x73, 0x66, 0x72, 0x6F, 0x77, 0x6E, 0xE2, 0x8C, 0xA2,
+  0x73, 0x68, 0x61, 0x72, 0x70, 0xE2, 0x99, 0xAF, 0x73, 0x68, 0x63, 0x68,
+  0x63, 0x79, 0xD1, 0x89, 0x73, 0x68, 0x63, 0x79, 0xD1, 0x88, 0x73, 0x68,
+  0x6F, 0x72, 0x74, 0x6D, 0x69, 0x64, 0xE2, 0x88, 0xA3, 0x73, 0x68, 0x6F,
+  0x72, 0x74, 0x70, 0x61, 0x72, 0x61, 0x6C, 0x6C, 0x65, 0x6C, 0xE2, 0x88,
+  0xA5, 0x73, 0x68, 0x79, 0xC2, 0xAD, 0x73, 0x69, 0x67, 0x6D, 0x61, 0xCF,
+  0x83, 0x73, 0x69, 0x67, 0x6D, 0x61, 0x66, 0xCF, 0x82, 0x73, 0x69, 0x67,
+  0x6D, 0x61, 0x76, 0xCF, 0x82, 0x73, 0x69, 0x6D, 0xE2, 0x88, 0xBC, 0x73,
+  0x69, 0x6D, 0x64, 0x6F, 0x74, 0xE2, 0xA9, 0xAA, 0x73, 0x69, 0x6D, 0x65,
+  0xE2, 0x89, 0x83, 0x73, 0x69, 0x6D, 0x65, 0x71, 0xE2, 0x89, 0x83, 0x73,
+  0x69, 0x6D, 0x67, 0xE2, 0xAA, 0x9E, 0x73, 0x69, 0x6D, 0x67, 0x45, 0xE2,
+  0xAA, 0xA0, 0x73, 0x69, 0x6D, 0x6C, 0xE2, 0xAA, 0x9D, 0x73, 0x69, 0x6D,
+  0x6C, 0x45, 0xE2, 0xAA, 0x9F, 0x73, 0x69, 0x6D, 0x6E, 0x65, 0xE2, 0x89,
+  0x86, 0x73, 0x69, 0x6D, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA8, 0xA4, 0x73,
+  0x69, 0x6D, 0x72, 0x61, 0x72, 0x72, 0xE2, 0xA5, 0xB2, 0x73, 0x6C, 0x61,
+  0x72, 0x72, 0xE2, 0x86, 0x90, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x73, 0x65,
+  0x74, 0x6D, 0x69, 0x6E, 0x75, 0x73, 0xE2, 0x88, 0x96, 0x73, 0x6D, 0x61,
+  0x73, 0x68, 0x70, 0xE2, 0xA8, 0xB3, 0x73, 0x6D, 0x65, 0x70, 0x61, 0x72,
+  0x73, 0x6C, 0xE2, 0xA7, 0xA4, 0x73, 0x6D, 0x69, 0x64, 0xE2, 0x88, 0xA3,
+  0x73, 0x6D, 0x69, 0x6C, 0x65, 0xE2, 0x8C, 0xA3, 0x73, 0x6D, 0x74, 0xE2,
+  0xAA, 0xAA, 0x73, 0x6D, 0x74, 0x65, 0xE2, 0xAA, 0xAC, 0x73, 0x6D, 0x74,
+  0x65, 0x73, 0xE2, 0xAA, 0xAC, 0xEF, 0xB8, 0x80, 0x73, 0x6F, 0x66, 0x74,
+  0x63, 0x79, 0xD1, 0x8C, 0x73, 0x6F, 0x6C, 0x2F, 0x73, 0x6F, 0x6C, 0x62,
+  0xE2, 0xA7, 0x84, 0x73, 0x6F, 0x6C, 0x62, 0x61, 0x72, 0xE2, 0x8C, 0xBF,
+  0x73, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xA4, 0x73, 0x70, 0x61, 0x64,
+  0x65, 0x73, 0xE2, 0x99, 0xA0, 0x73, 0x70, 0x61, 0x64, 0x65, 0x73, 0x75,
+  0x69, 0x74, 0xE2, 0x99, 0xA0, 0x73, 0x70, 0x61, 0x72, 0xE2, 0x88, 0xA5,
+  0x73, 0x71, 0x63, 0x61, 0x70, 0xE2, 0x8A, 0x93, 0x73, 0x71, 0x63, 0x61,
+  0x70, 0x73, 0xE2, 0x8A, 0x93, 0xEF, 0xB8, 0x80, 0x73, 0x71, 0x63, 0x75,
+  0x70, 0xE2, 0x8A, 0x94, 0x73, 0x71, 0x63, 0x75, 0x70, 0x73, 0xE2, 0x8A,
+  0x94, 0xEF, 0xB8, 0x80, 0x73, 0x71, 0x73, 0x75, 0x62, 0xE2, 0x8A, 0x8F,
+  0x73, 0x71, 0x73, 0x75, 0x62, 0x65, 0xE2, 0x8A, 0x91, 0x73, 0x71, 0x73,
+  0x75, 0x62, 0x73, 0x65, 0x74, 0xE2, 0x8A, 0x8F, 0x73, 0x71, 0x73, 0x75,
+  0x62, 0x73, 0x65, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0x91, 0x73, 0x71, 0x73,
+  0x75, 0x70, 0xE2, 0x8A, 0x90, 0x73, 0x71, 0x73, 0x75, 0x70, 0x65, 0xE2,
+  0x8A, 0x92, 0x73, 0x71, 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0xE2, 0x8A,
+  0x90, 0x73, 0x71, 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x65, 0x71, 0xE2,
+  0x8A, 0x92, 0x73, 0x71, 0x75, 0xE2, 0x96, 0xA1, 0x73, 0x71, 0x75, 0x61,
+  0x72, 0x65, 0xE2, 0x96, 0xA1, 0x73, 0x71, 0x75, 0x61, 0x72, 0x66, 0xE2,
+  0x96, 0xAA, 0x73, 0x71, 0x75, 0x66, 0xE2, 0x96, 0xAA, 0x73, 0x72, 0x61,
+  0x72, 0x72, 0xE2, 0x86, 0x92, 0x73, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93,
+  0x88, 0x73, 0x73, 0x65, 0x74, 0x6D, 0x6E, 0xE2, 0x88, 0x96, 0x73, 0x73,
+  0x6D, 0x69, 0x6C, 0x65, 0xE2, 0x8C, 0xA3, 0x73, 0x73, 0x74, 0x61, 0x72,
+  0x66, 0xE2, 0x8B, 0x86, 0x73, 0x74, 0x61, 0x72, 0xE2, 0x98, 0x86, 0x73,
+  0x74, 0x61, 0x72, 0x66, 0xE2, 0x98, 0x85, 0x73, 0x74, 0x72, 0x61, 0x69,
+  0x67, 0x68, 0x74, 0x65, 0x70, 0x73, 0x69, 0x6C, 0x6F, 0x6E, 0xCF, 0xB5,
+  0x73, 0x74, 0x72, 0x61, 0x69, 0x67, 0x68, 0x74, 0x70, 0x68, 0x69, 0xCF,
+  0x95, 0x73, 0x74, 0x72, 0x6E, 0x73, 0xC2, 0xAF, 0x73, 0x75, 0x62, 0xE2,
+  0x8A, 0x82, 0x73, 0x75, 0x62, 0x45, 0xE2, 0xAB, 0x85, 0x73, 0x75, 0x62,
+  0x64, 0x6F, 0x74, 0xE2, 0xAA, 0xBD, 0x73, 0x75, 0x62, 0x65, 0xE2, 0x8A,
+  0x86, 0x73, 0x75, 0x62, 0x65, 0x64, 0x6F, 0x74, 0xE2, 0xAB, 0x83, 0x73,
+  0x75, 0x62, 0x6D, 0x75, 0x6C, 0x74, 0xE2, 0xAB, 0x81, 0x73, 0x75, 0x62,
+  0x6E, 0x45, 0xE2, 0xAB, 0x8B, 0x73, 0x75, 0x62, 0x6E, 0x65, 0xE2, 0x8A,
+  0x8A, 0x73, 0x75, 0x62, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xAA, 0xBF, 0x73,
+  0x75, 0x62, 0x72, 0x61, 0x72, 0x72, 0xE2, 0xA5, 0xB9, 0x73, 0x75, 0x62,
+  0x73, 0x65, 0x74, 0xE2, 0x8A, 0x82, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74,
+  0x65, 0x71, 0xE2, 0x8A, 0x86, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x65,
+  0x71, 0x71, 0xE2, 0xAB, 0x85, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x6E,
+  0x65, 0x71, 0xE2, 0x8A, 0x8A, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x6E,
+  0x65, 0x71, 0x71, 0xE2, 0xAB, 0x8B, 0x73, 0x75, 0x62, 0x73, 0x69, 0x6D,
+  0xE2, 0xAB, 0x87, 0x73, 0x75, 0x62, 0x73, 0x75, 0x62, 0xE2, 0xAB, 0x95,
+  0x73, 0x75, 0x62, 0x73, 0x75, 0x70, 0xE2, 0xAB, 0x93, 0x73, 0x75, 0x63,
+  0x63, 0xE2, 0x89, 0xBB, 0x73, 0x75, 0x63, 0x63, 0x61, 0x70, 0x70, 0x72,
+  0x6F, 0x78, 0xE2, 0xAA, 0xB8, 0x73, 0x75, 0x63, 0x63, 0x63, 0x75, 0x72,
+  0x6C, 0x79, 0x65, 0x71, 0xE2, 0x89, 0xBD, 0x73, 0x75, 0x63, 0x63, 0x65,
+  0x71, 0xE2, 0xAA, 0xB0, 0x73, 0x75, 0x63, 0x63, 0x6E, 0x61, 0x70, 0x70,
+  0x72, 0x6F, 0x78, 0xE2, 0xAA, 0xBA, 0x73, 0x75, 0x63, 0x63, 0x6E, 0x65,
+  0x71, 0x71, 0xE2, 0xAA, 0xB6, 0x73, 0x75, 0x63, 0x63, 0x6E, 0x73, 0x69,
+  0x6D, 0xE2, 0x8B, 0xA9, 0x73, 0x75, 0x63, 0x63, 0x73, 0x69, 0x6D, 0xE2,
+  0x89, 0xBF, 0x73, 0x75, 0x6D, 0xE2, 0x88, 0x91, 0x73, 0x75, 0x6E, 0x67,
+  0xE2, 0x99, 0xAA, 0x73, 0x75, 0x70, 0xE2, 0x8A, 0x83, 0x73, 0x75, 0x70,
+  0x31, 0xC2, 0xB9, 0x73, 0x75, 0x70, 0x32, 0xC2, 0xB2, 0x73, 0x75, 0x70,
+  0x33, 0xC2, 0xB3, 0x73, 0x75, 0x70, 0x45, 0xE2, 0xAB, 0x86, 0x73, 0x75,
+  0x70, 0x64, 0x6F, 0x74, 0xE2, 0xAA, 0xBE, 0x73, 0x75, 0x70, 0x64, 0x73,
+  0x75, 0x62, 0xE2, 0xAB, 0x98, 0x73, 0x75, 0x70, 0x65, 0xE2, 0x8A, 0x87,
+  0x73, 0x75, 0x70, 0x65, 0x64, 0x6F, 0x74, 0xE2, 0xAB, 0x84, 0x73, 0x75,
+  0x70, 0x68, 0x73, 0x6F, 0x6C, 0xE2, 0x9F, 0x89, 0x73, 0x75, 0x70, 0x68,
+  0x73, 0x75, 0x62, 0xE2, 0xAB, 0x97, 0x73, 0x75, 0x70, 0x6C, 0x61, 0x72,
+  0x72, 0xE2, 0xA5, 0xBB, 0x73, 0x75, 0x70, 0x6D, 0x75, 0x6C, 0x74, 0xE2,
+  0xAB, 0x82, 0x73, 0x75, 0x70, 0x6E, 0x45, 0xE2, 0xAB, 0x8C, 0x73, 0x75,
+  0x70, 0x6E, 0x65, 0xE2, 0x8A, 0x8B, 0x73, 0x75, 0x70, 0x70, 0x6C, 0x75,
+  0x73, 0xE2, 0xAB, 0x80, 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0xE2, 0x8A,
+  0x83, 0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0x87,
+  0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x65, 0x71, 0x71, 0xE2, 0xAB, 0x86,
+  0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x6E, 0x65, 0x71, 0xE2, 0x8A, 0x8B,
+  0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x6E, 0x65, 0x71, 0x71, 0xE2, 0xAB,
+  0x8C, 0x73, 0x75, 0x70, 0x73, 0x69, 0x6D, 0xE2, 0xAB, 0x88, 0x73, 0x75,
+  0x70, 0x73, 0x75, 0x62, 0xE2, 0xAB, 0x94, 0x73, 0x75, 0x70, 0x73, 0x75,
+  0x70, 0xE2, 0xAB, 0x96, 0x73, 0x77, 0x41, 0x72, 0x72, 0xE2, 0x87, 0x99,
+  0x73, 0x77, 0x61, 0x72, 0x68, 0x6B, 0xE2, 0xA4, 0xA6, 0x73, 0x77, 0x61,
+  0x72, 0x72, 0xE2, 0x86, 0x99, 0x73, 0x77, 0x61, 0x72, 0x72, 0x6F, 0x77,
+  0xE2, 0x86, 0x99, 0x73, 0x77, 0x6E, 0x77, 0x61, 0x72, 0xE2, 0xA4, 0xAA,
+  0x73, 0x7A, 0x6C, 0x69, 0x67, 0xC3, 0x9F, 0x74, 0x61, 0x72, 0x67, 0x65,
+  0x74, 0xE2, 0x8C, 0x96, 0x74, 0x61, 0x75, 0xCF, 0x84, 0x74, 0x62, 0x72,
+  0x6B, 0xE2, 0x8E, 0xB4, 0x74, 0x63, 0x61, 0x72, 0x6F, 0x6E, 0xC5, 0xA5,
+  0x74, 0x63, 0x65, 0x64, 0x69, 0x6C, 0xC5, 0xA3, 0x74, 0x63, 0x79, 0xD1,
+  0x82, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x83, 0x9B, 0x74, 0x65, 0x6C, 0x72,
+  0x65, 0x63, 0xE2, 0x8C, 0x95, 0x74, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xB1,
+  0x74, 0x68, 0x65, 0x72, 0x65, 0x34, 0xE2, 0x88, 0xB4, 0x74, 0x68, 0x65,
+  0x72, 0x65, 0x66, 0x6F, 0x72, 0x65, 0xE2, 0x88, 0xB4, 0x74, 0x68, 0x65,
+  0x74, 0x61, 0xCE, 0xB8, 0x74, 0x68, 0x65, 0x74, 0x61, 0x73, 0x79, 0x6D,
+  0xCF, 0x91, 0x74, 0x68, 0x65, 0x74, 0x61, 0x76, 0xCF, 0x91, 0x74, 0x68,
+  0x69, 0x63, 0x6B, 0x61, 0x70, 0x70, 0x72, 0x6F, 0x78, 0xE2, 0x89, 0x88,
+  0x74, 0x68, 0x69, 0x63, 0x6B, 0x73, 0x69, 0x6D, 0xE2, 0x88, 0xBC, 0x74,
+  0x68, 0x69, 0x6E, 0x73, 0x70, 0xE2, 0x80, 0x89, 0x74, 0x68, 0x6B, 0x61,
+  0x70, 0xE2, 0x89, 0x88, 0x74, 0x68, 0x6B, 0x73, 0x69, 0x6D, 0xE2, 0x88,
+  0xBC, 0x74, 0x68, 0x6F, 0x72, 0x6E, 0xC3, 0xBE, 0x74, 0x69, 0x6C, 0x64,
+  0x65, 0xCB, 0x9C, 0x74, 0x69, 0x6D, 0x65, 0x73, 0xC3, 0x97, 0x74, 0x69,
+  0x6D, 0x65, 0x73, 0x62, 0xE2, 0x8A, 0xA0, 0x74, 0x69, 0x6D, 0x65, 0x73,
+  0x62, 0x61, 0x72, 0xE2, 0xA8, 0xB1, 0x74, 0x69, 0x6D, 0x65, 0x73, 0x64,
+  0xE2, 0xA8, 0xB0, 0x74, 0x69, 0x6E, 0x74, 0xE2, 0x88, 0xAD, 0x74, 0x6F,
+  0x65, 0x61, 0xE2, 0xA4, 0xA8, 0x74, 0x6F, 0x70, 0xE2, 0x8A, 0xA4, 0x74,
+  0x6F, 0x70, 0x62, 0x6F, 0x74, 0xE2, 0x8C, 0xB6, 0x74, 0x6F, 0x70, 0x63,
+  0x69, 0x72, 0xE2, 0xAB, 0xB1, 0x74, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95,
+  0xA5, 0x74, 0x6F, 0x70, 0x66, 0x6F, 0x72, 0x6B, 0xE2, 0xAB, 0x9A, 0x74,
+  0x6F, 0x73, 0x61, 0xE2, 0xA4, 0xA9, 0x74, 0x70, 0x72, 0x69, 0x6D, 0x65,
+  0xE2, 0x80, 0xB4, 0x74, 0x72, 0x61, 0x64, 0x65, 0xE2, 0x84, 0xA2, 0x74,
+  0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0x96, 0xB5, 0x74, 0x72,
+  0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x64, 0x6F, 0x77, 0x6E, 0xE2, 0x96,
+  0xBF, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x6C, 0x65, 0x66,
+  0x74, 0xE2, 0x97, 0x83, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65,
+  0x6C, 0x65, 0x66, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0xB4, 0x74, 0x72, 0x69,
+  0x61, 0x6E, 0x67, 0x6C, 0x65, 0x71, 0xE2, 0x89, 0x9C, 0x74, 0x72, 0x69,
+  0x61, 0x6E, 0x67, 0x6C, 0x65, 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2, 0x96,
+  0xB9, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x72, 0x69, 0x67,
+  0x68, 0x74, 0x65, 0x71, 0xE2, 0x8A, 0xB5, 0x74, 0x72, 0x69, 0x64, 0x6F,
+  0x74, 0xE2, 0x97, 0xAC, 0x74, 0x72, 0x69, 0x65, 0xE2, 0x89, 0x9C, 0x74,
+  0x72, 0x69, 0x6D, 0x69, 0x6E, 0x75, 0x73, 0xE2, 0xA8, 0xBA, 0x74, 0x72,
+  0x69, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA8, 0xB9, 0x74, 0x72, 0x69, 0x73,
+  0x62, 0xE2, 0xA7, 0x8D, 0x74, 0x72, 0x69, 0x74, 0x69, 0x6D, 0x65, 0xE2,
+  0xA8, 0xBB, 0x74, 0x72, 0x70, 0x65, 0x7A, 0x69, 0x75, 0x6D, 0xE2, 0x8F,
+  0xA2, 0x74, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x89, 0x74, 0x73, 0x63,
+  0x79, 0xD1, 0x86, 0x74, 0x73, 0x68, 0x63, 0x79, 0xD1, 0x9B, 0x74, 0x73,
+  0x74, 0x72, 0x6F, 0x6B, 0xC5, 0xA7, 0x74, 0x77, 0x69, 0x78, 0x74, 0xE2,
+  0x89, 0xAC, 0x74, 0x77, 0x6F, 0x68, 0x65, 0x61, 0x64, 0x6C, 0x65, 0x66,
+  0x74, 0x61, 0x72, 0x72, 0x6F, 0x77, 0xE2, 0x86, 0x9E, 0x74, 0x77, 0x6F,
+  0x68, 0x65, 0x61, 0x64, 0x72, 0x69, 0x67, 0x68, 0x74, 0x61, 0x72, 0x72,
+  0x6F, 0x77, 0xE2, 0x86, 0xA0, 0x75, 0x41, 0x72, 0x72, 0xE2, 0x87, 0x91,
+  0x75, 0x48, 0x61, 0x72, 0xE2, 0xA5, 0xA3, 0x75, 0x61, 0x63, 0x75, 0x74,
+  0x65, 0xC3, 0xBA, 0x75, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x91, 0x75, 0x62,
+  0x72, 0x63, 0x79, 0xD1, 0x9E, 0x75, 0x62, 0x72, 0x65, 0x76, 0x65, 0xC5,
+  0xAD, 0x75, 0x63, 0x69, 0x72, 0x63, 0xC3, 0xBB, 0x75, 0x63, 0x79, 0xD1,
+  0x83, 0x75, 0x64, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x85, 0x75, 0x64, 0x62,
+  0x6C, 0x61, 0x63, 0xC5, 0xB1, 0x75, 0x64, 0x68, 0x61, 0x72, 0xE2, 0xA5,
+  0xAE, 0x75, 0x66, 0x69, 0x73, 0x68, 0x74, 0xE2, 0xA5, 0xBE, 0x75, 0x66,
+  0x72, 0xF0, 0x9D, 0x94, 0xB2, 0x75, 0x67, 0x72, 0x61, 0x76, 0x65, 0xC3,
+  0xB9, 0x75, 0x68, 0x61, 0x72, 0x6C, 0xE2, 0x86, 0xBF, 0x75, 0x68, 0x61,
+  0x72, 0x72, 0xE2, 0x86, 0xBE, 0x75, 0x68, 0x62, 0x6C, 0x6B, 0xE2, 0x96,
+  0x80, 0x75, 0x6C, 0x63, 0x6F, 0x72, 0x6E, 0xE2, 0x8C, 0x9C, 0x75, 0x6C,
+  0x63, 0x6F, 0x72, 0x6E, 0x65, 0x72, 0xE2, 0x8C, 0x9C, 0x75, 0x6C, 0x63,
+  0x72, 0x6F, 0x70, 0xE2, 0x8C, 0x8F, 0x75, 0x6C, 0x74, 0x72, 0x69, 0xE2,
+  0x97, 0xB8, 0x75, 0x6D, 0x61, 0x63, 0x72, 0xC5, 0xAB, 0x75, 0x6D, 0x6C,
+  0xC2, 0xA8, 0x75, 0x6F, 0x67, 0x6F, 0x6E, 0xC5, 0xB3, 0x75, 0x6F, 0x70,
+  0x66, 0xF0, 0x9D, 0x95, 0xA6, 0x75, 0x70, 0x61, 0x72, 0x72, 0x6F, 0x77,
+  0xE2, 0x86, 0x91, 0x75, 0x70, 0x64, 0x6F, 0x77, 0x6E, 0x61, 0x72, 0x72,
+  0x6F, 0x77, 0xE2, 0x86, 0x95, 0x75, 0x70, 0x68, 0x61, 0x72, 0x70, 0x6F,
+  0x6F, 0x6E, 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x86, 0xBF, 0x75, 0x70, 0x68,
+  0x61, 0x72, 0x70, 0x6F, 0x6F, 0x6E, 0x72, 0x69, 0x67, 0x68, 0x74, 0xE2,
+  0x86, 0xBE, 0x75, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0x8A, 0x8E, 0x75, 0x70,
+  0x73, 0x69, 0xCF, 0x85, 0x75, 0x70, 0x73, 0x69, 0x68, 0xCF, 0x92, 0x75,
+  0x70, 0x73, 0x69, 0x6C, 0x6F, 0x6E, 0xCF, 0x85, 0x75, 0x70, 0x75, 0x70,
+  0x61, 0x72, 0x72, 0x6F, 0x77, 0x73, 0xE2, 0x87, 0x88, 0x75, 0x72, 0x63,
+  0x6F, 0x72, 0x6E, 0xE2, 0x8C, 0x9D, 0x75, 0x72, 0x63, 0x6F, 0x72, 0x6E,
+  0x65, 0x72, 0xE2, 0x8C, 0x9D, 0x75, 0x72, 0x63, 0x72, 0x6F, 0x70, 0xE2,
+  0x8C, 0x8E, 0x75, 0x72, 0x69, 0x6E, 0x67, 0xC5, 0xAF, 0x75, 0x72, 0x74,
+  0x72, 0x69, 0xE2, 0x97, 0xB9, 0x75, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93,
+  0x8A, 0x75, 0x74, 0x64, 0x6F, 0x74, 0xE2, 0x8B, 0xB0, 0x75, 0x74, 0x69,
+  0x6C, 0x64, 0x65, 0xC5, 0xA9, 0x75, 0x74, 0x72, 0x69, 0xE2, 0x96, 0xB5,
+  0x75, 0x74, 0x72, 0x69, 0x66, 0xE2, 0x96, 0xB4, 0x75, 0x75, 0x61, 0x72,
+  0x72, 0xE2, 0x87, 0x88, 0x75, 0x75, 0x6D, 0x6C, 0xC3, 0xBC, 0x75, 0x77,
+  0x61, 0x6E, 0x67, 0x6C, 0x65, 0xE2, 0xA6, 0xA7, 0x76, 0x41, 0x72, 0x72,
+  0xE2, 0x87, 0x95, 0x76, 0x42, 0x61, 0x72, 0xE2, 0xAB, 0xA8, 0x76, 0x42,
+  0x61, 0x72, 0x76, 0xE2, 0xAB, 0xA9, 0x76, 0x44, 0x61, 0x73, 0x68, 0xE2,
+  0x8A, 0xA8, 0x76, 0x61, 0x6E, 0x67, 0x72, 0x74, 0xE2, 0xA6, 0x9C, 0x76,
+  0x61, 0x72, 0x65, 0x70, 0x73, 0x69, 0x6C, 0x6F, 0x6E, 0xCF, 0xB5, 0x76,
+  0x61, 0x72, 0x6B, 0x61, 0x70, 0x70, 0x61, 0xCF, 0xB0, 0x76, 0x61, 0x72,
+  0x6E, 0x6F, 0x74, 0x68, 0x69, 0x6E, 0x67, 0xE2, 0x88, 0x85, 0x76, 0x61,
+  0x72, 0x70, 0x68, 0x69, 0xCF, 0x95, 0x76, 0x61, 0x72, 0x70, 0x69, 0xCF,
+  0x96, 0x76, 0x61, 0x72, 0x70, 0x72, 0x6F, 0x70, 0x74, 0x6F, 0xE2, 0x88,
+  0x9D, 0x76, 0x61, 0x72, 0x72, 0xE2, 0x86, 0x95, 0x76, 0x61, 0x72, 0x72,
+  0x68, 0x6F, 0xCF, 0xB1, 0x76, 0x61, 0x72, 0x73, 0x69, 0x67, 0x6D, 0x61,
+  0xCF, 0x82, 0x76, 0x61, 0x72, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x6E,
+  0x65, 0x71, 0xE2, 0x8A, 0x8A, 0xEF, 0xB8, 0x80, 0x76, 0x61, 0x72, 0x73,
+  0x75, 0x62, 0x73, 0x65, 0x74, 0x6E, 0x65, 0x71, 0x71, 0xE2, 0xAB, 0x8B,
+  0xEF, 0xB8, 0x80, 0x76, 0x61, 0x72, 0x73, 0x75, 0x70, 0x73, 0x65, 0x74,
+  0x6E, 0x65, 0x71, 0xE2, 0x8A, 0x8B, 0xEF, 0xB8, 0x80, 0x76, 0x61, 0x72,
+  0x73, 0x75, 0x70, 0x73, 0x65, 0x74, 0x6E, 0x65, 0x71, 0x71, 0xE2, 0xAB,
+  0x8C, 0xEF, 0xB8, 0x80, 0x76, 0x61, 0x72, 0x74, 0x68, 0x65, 0x74, 0x61,
+  0xCF, 0x91, 0x76, 0x61, 0x72, 0x74, 0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C,
+  0x65, 0x6C, 0x65, 0x66, 0x74, 0xE2, 0x8A, 0xB2, 0x76, 0x61, 0x72, 0x74,
+  0x72, 0x69, 0x61, 0x6E, 0x67, 0x6C, 0x65, 0x72, 0x69, 0x67, 0x68, 0x74,
+  0xE2, 0x8A, 0xB3, 0x76, 0x63, 0x79, 0xD0, 0xB2, 0x76, 0x64, 0x61, 0x73,
+  0x68, 0xE2, 0x8A, 0xA2, 0x76, 0x65, 0x65, 0xE2, 0x88, 0xA8, 0x76, 0x65,
+  0x65, 0x62, 0x61, 0x72, 0xE2, 0x8A, 0xBB, 0x76, 0x65, 0x65, 0x65, 0x71,
+  0xE2, 0x89, 0x9A, 0x76, 0x65, 0x6C, 0x6C, 0x69, 0x70, 0xE2, 0x8B, 0xAE,
+  0x76, 0x65, 0x72, 0x62, 0x61, 0x72, 0x7C, 0x76, 0x65, 0x72, 0x74, 0x7C,
+  0x76, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xB3, 0x76, 0x6C, 0x74, 0x72, 0x69,
+  0xE2, 0x8A, 0xB2, 0x76, 0x6E, 0x73, 0x75, 0x62, 0xE2, 0x8A, 0x82, 0xE2,
+  0x83, 0x92, 0x76, 0x6E, 0x73, 0x75, 0x70, 0xE2, 0x8A, 0x83, 0xE2, 0x83,
+  0x92, 0x76, 0x6F, 0x70, 0x66, 0xF0, 0x9D, 0x95, 0xA7, 0x76, 0x70, 0x72,
+  0x6F, 0x70, 0xE2, 0x88, 0x9D, 0x76, 0x72, 0x74, 0x72, 0x69, 0xE2, 0x8A,
+  0xB3, 0x76, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x8B, 0x76, 0x73, 0x75,
+  0x62, 0x6E, 0x45, 0xE2, 0xAB, 0x8B, 0xEF, 0xB8, 0x80, 0x76, 0x73, 0x75,
+  0x62, 0x6E, 0x65, 0xE2, 0x8A, 0x8A, 0xEF, 0xB8, 0x80, 0x76, 0x73, 0x75,
+  0x70, 0x6E, 0x45, 0xE2, 0xAB, 0x8C, 0xEF, 0xB8, 0x80, 0x76, 0x73, 0x75,
+  0x70, 0x6E, 0x65, 0xE2, 0x8A, 0x8B, 0xEF, 0xB8, 0x80, 0x76, 0x7A, 0x69,
+  0x67, 0x7A, 0x61, 0x67, 0xE2, 0xA6, 0x9A, 0x77, 0x63, 0x69, 0x72, 0x63,
+  0xC5, 0xB5, 0x77, 0x65, 0x64, 0x62, 0x61, 0x72, 0xE2, 0xA9, 0x9F, 0x77,
+  0x65, 0x64, 0x67, 0x65, 0xE2, 0x88, 0xA7, 0x77, 0x65, 0x64, 0x67, 0x65,
+  0x71, 0xE2, 0x89, 0x99, 0x77, 0x65, 0x69, 0x65, 0x72, 0x70, 0xE2, 0x84,
+  0x98, 0x77, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xB4, 0x77, 0x6F, 0x70, 0x66,
+  0xF0, 0x9D, 0x95, 0xA8, 0x77, 0x70, 0xE2, 0x84, 0x98, 0x77, 0x72, 0xE2,
+  0x89, 0x80, 0x77, 0x72, 0x65, 0x61, 0x74, 0x68, 0xE2, 0x89, 0x80, 0x77,
+  0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x8C, 0x78, 0x63, 0x61, 0x70, 0xE2,
+  0x8B, 0x82, 0x78, 0x63, 0x69, 0x72, 0x63, 0xE2, 0x97, 0xAF, 0x78, 0x63,
+  0x75, 0x70, 0xE2, 0x8B, 0x83, 0x78, 0x64, 0x74, 0x72, 0x69, 0xE2, 0x96,
+  0xBD, 0x78, 0x66, 0x72, 0xF0, 0x9D, 0x94, 0xB5, 0x78, 0x68, 0x41, 0x72,
+  0x72, 0xE2, 0x9F, 0xBA, 0x78, 0x68, 0x61, 0x72, 0x72, 0xE2, 0x9F, 0xB7,
+  0x78, 0x69, 0xCE, 0xBE, 0x78, 0x6C, 0x41, 0x72, 0x72, 0xE2, 0x9F, 0xB8,
+  0x78, 0x6C, 0x61, 0x72, 0x72, 0xE2, 0x9F, 0xB5, 0x78, 0x6D, 0x61, 0x70,
+  0xE2, 0x9F, 0xBC, 0x78, 0x6E, 0x69, 0x73, 0xE2, 0x8B, 0xBB, 0x78, 0x6F,
+  0x64, 0x6F, 0x74, 0xE2, 0xA8, 0x80, 0x78, 0x6F, 0x70, 0x66, 0xF0, 0x9D,
+  0x95, 0xA9, 0x78, 0x6F, 0x70, 0x6C, 0x75, 0x73, 0xE2, 0xA8, 0x81, 0x78,
+  0x6F, 0x74, 0x69, 0x6D, 0x65, 0xE2, 0xA8, 0x82, 0x78, 0x72, 0x41, 0x72,
+  0x72, 0xE2, 0x9F, 0xB9, 0x78, 0x72, 0x61, 0x72, 0x72, 0xE2, 0x9F, 0xB6,
+  0x78, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x8D, 0x78, 0x73, 0x71, 0x63,
+  0x75, 0x70, 0xE2, 0xA8, 0x86, 0x78, 0x75, 0x70, 0x6C, 0x75, 0x73, 0xE2,
+  0xA8, 0x84, 0x78, 0x75, 0x74, 0x72, 0x69, 0xE2, 0x96, 0xB3, 0x78, 0x76,
+  0x65, 0x65, 0xE2, 0x8B, 0x81, 0x78, 0x77, 0x65, 0x64, 0x67, 0x65, 0xE2,
+  0x8B, 0x80, 0x79, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC3, 0xBD, 0x79, 0x61,
+  0x63, 0x79, 0xD1, 0x8F, 0x79, 0x63, 0x69, 0x72, 0x63, 0xC5, 0xB7, 0x79,
+  0x63, 0x79, 0xD1, 0x8B, 0x79, 0x65, 0x6E, 0xC2, 0xA5, 0x79, 0x66, 0x72,
+  0xF0, 0x9D, 0x94, 0xB6, 0x79, 0x69, 0x63, 0x79, 0xD1, 0x97, 0x79, 0x6F,
+  0x70, 0x66, 0xF0, 0x9D, 0x95, 0xAA, 0x79, 0x73, 0x63, 0x72, 0xF0, 0x9D,
+  0x93, 0x8E, 0x79, 0x75, 0x63, 0x79, 0xD1, 0x8E, 0x79, 0x75, 0x6D, 0x6C,
+  0xC3, 0xBF, 0x7A, 0x61, 0x63, 0x75, 0x74, 0x65, 0xC5, 0xBA, 0x7A, 0x63,
+  0x61, 0x72, 0x6F, 0x6E, 0xC5, 0xBE, 0x7A, 0x63, 0x79, 0xD0, 0xB7, 0x7A,
+  0x64, 0x6F, 0x74, 0xC5, 0xBC, 0x7A, 0x65, 0x65, 0x74, 0x72, 0x66, 0xE2,
+  0x84, 0xA8, 0x7A, 0x65, 0x74, 0x61, 0xCE, 0xB6, 0x7A, 0x66, 0x72, 0xF0,
+  0x9D, 0x94, 0xB7, 0x7A, 0x68, 0x63, 0x79, 0xD0, 0xB6, 0x7A, 0x69, 0x67,
+  0x72, 0x61, 0x72, 0x72, 0xE2, 0x87, 0x9D, 0x7A, 0x6F, 0x70, 0x66, 0xF0,
+  0x9D, 0x95, 0xAB, 0x7A, 0x73, 0x63, 0x72, 0xF0, 0x9D, 0x93, 0x8F, 0x7A,
+  0x77, 0x6A, 0xE2, 0x80, 0x8D, 0x7A, 0x77, 0x6E, 0x6A, 0xE2, 0x80, 0x8C
+};
diff --git a/cmark/src/houdini.h b/cmark/src/houdini.h
new file mode 100644
index 0000000000..69d4fec95c
--- /dev/null
+++ b/cmark/src/houdini.h
@@ -0,0 +1,41 @@
+#ifndef CMARK_HOUDINI_H
+#define CMARK_HOUDINI_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#include "buffer.h"
+
+#ifdef HOUDINI_USE_LOCALE
+#define _isxdigit(c) isxdigit(c)
+#define _isdigit(c) isdigit(c)
+#else
+/*
+ * Helper _isdigit methods -- do not trust the current locale
+ * */
+#define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL)
+#define _isdigit(c) ((c) >= '0' && (c) <= '9')
+#endif
+
+#define HOUDINI_ESCAPED_SIZE(x) (((x)*12) / 10)
+#define HOUDINI_UNESCAPED_SIZE(x) (x)
+
+bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src,
+                               bufsize_t size);
+int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src,
+                         bufsize_t size, int secure);
+int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src,
+                          bufsize_t size);
+void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src,
+                             bufsize_t size);
+int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src,
+                        bufsize_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/houdini_href_e.c b/cmark/src/houdini_href_e.c
new file mode 100644
index 0000000000..38f2a58264
--- /dev/null
+++ b/cmark/src/houdini_href_e.c
@@ -0,0 +1,111 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+#if !defined(__has_builtin)
+# define __has_builtin(b) 0
+#endif
+
+#if !__has_builtin(__builtin_expect)
+# define __builtin_expect(e, v) (e)
+#endif
+
+#define likely(e) __builtin_expect((e), 1)
+#define unlikely(e) __builtin_expect((e), 0)
+
+/*
+ * The following characters will not be escaped:
+ *
+ *              -_.+!*'(),%#@?=;:/,+&$~ alphanum
+ *
+ * Note that this character set is the addition of:
+ *
+ *      - The characters which are safe to be in an URL
+ *      - The characters which are *not* safe to be in
+ *      an URL because they are RESERVED characters.
+ *
+ * We assume (lazily) that any RESERVED char that
+ * appears inside an URL is actually meant to
+ * have its native function (i.e. as an URL
+ * component/separator) and hence needs no escaping.
+ *
+ * There are two exceptions: the characters & (amp)
+ * and ' (single quote) do not appear in the table.
+ * They are meant to appear in the URL as components,
+ * yet they require special HTML-entity escaping
+ * to generate valid HTML markup.
+ *
+ * All other characters will be escaped to %XX.
+ *
+ */
+static const char HREF_SAFE[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) {
+  static const uint8_t hex_chars[] = "0123456789ABCDEF";
+  bufsize_t i = 0, org;
+  uint8_t hex_str[3];
+
+  hex_str[0] = '%';
+
+  while (i < size) {
+    org = i;
+    while (i < size && HREF_SAFE[src[i]] != 0)
+      i++;
+
+    if (likely(i > org))
+      cmark_strbuf_put(ob, src + org, i - org);
+
+    /* escaping */
+    if (i >= size)
+      break;
+
+    switch (src[i]) {
+    /* amp appears all the time in URLs, but needs
+     * HTML-entity escaping to be inside an href */
+    case '&':
+      cmark_strbuf_puts(ob, "&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/cmark/src/houdini_html_e.c b/cmark/src/houdini_html_e.c
new file mode 100644
index 0000000000..111bc1374f
--- /dev/null
+++ b/cmark/src/houdini_html_e.c
@@ -0,0 +1,73 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+#if !defined(__has_builtin)
+# define __has_builtin(b) 0
+#endif
+
+#if !__has_builtin(__builtin_expect)
+# define __builtin_expect(e, v) (e)
+#endif
+
+#define likely(e) __builtin_expect((e), 1)
+#define unlikely(e) __builtin_expect((e), 0)
+
+/**
+ * According to the OWASP rules:
+ *
+ * & --> &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_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size,
+                         int secure) {
+  bufsize_t i = 0, org, esc = 0;
+
+  while (i < size) {
+    org = i;
+    while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0)
+      i++;
+
+    if (i > org)
+      cmark_strbuf_put(ob, src + org, i - org);
+
+    /* escaping */
+    if (unlikely(i >= size))
+      break;
+
+    /* The forward slash is only escaped in secure mode */
+    if ((src[i] == '/' || src[i] == '\'') && !secure) {
+      cmark_strbuf_putc(ob, src[i]);
+    } else {
+      cmark_strbuf_puts(ob, HTML_ESCAPES[esc]);
+    }
+
+    i++;
+  }
+
+  return 1;
+}
diff --git a/cmark/src/houdini_html_u.c b/cmark/src/houdini_html_u.c
new file mode 100644
index 0000000000..07ac34a412
--- /dev/null
+++ b/cmark/src/houdini_html_u.c
@@ -0,0 +1,174 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "buffer.h"
+#include "houdini.h"
+#include "utf8.h"
+#include "entities.inc"
+
+#if !defined(__has_builtin)
+# define __has_builtin(b) 0
+#endif
+
+#if !__has_builtin(__builtin_expect)
+# define __builtin_expect(e, v) (e)
+#endif
+
+#define likely(e) __builtin_expect((e), 1)
+#define unlikely(e) __builtin_expect((e), 0)
+
+/* Binary tree lookup code for entities added by JGM */
+
+static const unsigned char *S_lookup(int i, int low, int hi,
+                                     const unsigned char *s, int len,
+                                     bufsize_t *size_out) {
+  int j;
+  uint32_t value = cmark_entities[i];
+  const unsigned char *ent_name = cmark_entity_text + ENT_TEXT_IDX(value);
+  int ent_len = ENT_NAME_SIZE(value);
+  int min_len = len < ent_len ? len : ent_len;
+  int cmp =
+      strncmp((const char *)s, (const char *)ent_name, min_len);
+  if (cmp == 0)
+    cmp = len - ent_len;
+  if (cmp == 0) {
+    *size_out = ENT_REPL_SIZE(value);
+    return ent_name + ent_len;
+  } else if (cmp <= 0 && i > low) {
+    j = i - ((i - low) / 2);
+    if (j == i)
+      j -= 1;
+    return S_lookup(j, low, i - 1, s, len, size_out);
+  } else if (cmp > 0 && i < hi) {
+    j = i + ((hi - i) / 2);
+    if (j == i)
+      j += 1;
+    return S_lookup(j, i + 1, hi, s, len, size_out);
+  } else {
+    return NULL;
+  }
+}
+
+static const unsigned char *S_lookup_entity(const unsigned char *s, int len,
+                                            bufsize_t *size_out) {
+  return S_lookup(ENT_TABLE_SIZE / 2, 0, ENT_TABLE_SIZE - 1, s, len, size_out);
+}
+
+bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src,
+                               bufsize_t size) {
+  bufsize_t i = 0;
+
+  if (size >= 3 && src[0] == '#') {
+    int codepoint = 0;
+    int num_digits = 0;
+    int max_digits = 7;
+
+    if (_isdigit(src[1])) {
+      for (i = 1; i < size && _isdigit(src[i]); ++i) {
+        codepoint = (codepoint * 10) + (src[i] - '0');
+
+        if (codepoint >= 0x110000) {
+          // Keep counting digits but
+          // avoid integer overflow.
+          codepoint = 0x110000;
+        }
+      }
+
+      num_digits = i - 1;
+      max_digits = 7;
+    }
+
+    else if (src[1] == 'x' || src[1] == 'X') {
+      for (i = 2; i < size && _isxdigit(src[i]); ++i) {
+        codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9);
+
+        if (codepoint >= 0x110000) {
+          // Keep counting digits but
+          // avoid integer overflow.
+          codepoint = 0x110000;
+        }
+      }
+
+      num_digits = i - 2;
+      max_digits = 6;
+    }
+
+    if (num_digits >= 1 && num_digits <= max_digits &&
+                    i < size && src[i] == ';') {
+      if (codepoint == 0 || (codepoint >= 0xD800 && codepoint < 0xE000) ||
+          codepoint >= 0x110000) {
+        codepoint = 0xFFFD;
+      }
+      cmark_utf8proc_encode_char(codepoint, ob);
+      return i + 1;
+    }
+  }
+
+  else {
+    if (size > ENT_MAX_LENGTH)
+      size = ENT_MAX_LENGTH;
+
+    for (i = ENT_MIN_LENGTH; i < size; ++i) {
+      if (src[i] == ' ')
+        break;
+
+      if (src[i] == ';') {
+        bufsize_t size;
+        const unsigned char *entity = S_lookup_entity(src, i, &size);
+
+        if (entity != NULL) {
+          cmark_strbuf_put(ob, entity, size);
+          return i + 1;
+        }
+
+        break;
+      }
+    }
+  }
+
+  return 0;
+}
+
+int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src,
+                          bufsize_t size) {
+  bufsize_t i = 0, org, ent;
+
+  while (i < size) {
+    org = i;
+    while (i < size && src[i] != '&')
+      i++;
+
+    if (likely(i > org)) {
+      if (unlikely(org == 0)) {
+        if (i >= size)
+          return 0;
+
+        cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size));
+      }
+
+      cmark_strbuf_put(ob, src + org, i - org);
+    }
+
+    /* escaping */
+    if (i >= size)
+      break;
+
+    i++;
+
+    ent = houdini_unescape_ent(ob, src + i, size - i);
+    i += ent;
+
+    /* not really an entity */
+    if (ent == 0)
+      cmark_strbuf_putc(ob, '&');
+  }
+
+  return 1;
+}
+
+void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src,
+                             bufsize_t size) {
+  if (!houdini_unescape_html(ob, src, size))
+    cmark_strbuf_put(ob, src, size);
+}
diff --git a/cmark/src/html.c b/cmark/src/html.c
new file mode 100644
index 0000000000..5c14fa6f89
--- /dev/null
+++ b/cmark/src/html.c
@@ -0,0 +1,345 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmark_ctype.h"
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "houdini.h"
+#include "scanners.h"
+
+#define BUFFER_SIZE 100
+
+// Functions to convert cmark_nodes to HTML strings.
+
+static void escape_html(cmark_strbuf *dest, const unsigned char *source,
+                        bufsize_t length) {
+  houdini_escape_html(dest, source, length, 0);
+}
+
+static inline void cr(cmark_strbuf *html) {
+  if (html->size && html->ptr[html->size - 1] != '\n')
+    cmark_strbuf_putc(html, '\n');
+}
+
+struct render_state {
+  cmark_strbuf *html;
+  cmark_node *plain;
+};
+
+static void S_render_sourcepos(cmark_node *node, cmark_strbuf *html,
+                               int options) {
+  char buffer[BUFFER_SIZE];
+  if (CMARK_OPT_SOURCEPOS & options) {
+    snprintf(buffer, BUFFER_SIZE, " data-sourcepos=\"%d:%d-%d:%d\"",
+             cmark_node_get_start_line(node), cmark_node_get_start_column(node),
+             cmark_node_get_end_line(node), cmark_node_get_end_column(node));
+    cmark_strbuf_puts(html, buffer);
+  }
+}
+
+static int S_render_node(cmark_node *node, cmark_event_type ev_type,
+                         struct render_state *state, int options) {
+  cmark_node *parent;
+  cmark_node *grandparent;
+  cmark_strbuf *html = state->html;
+  char start_heading[] = "<h0";
+  char end_heading[] = "</h0";
+  bool tight;
+  char buffer[BUFFER_SIZE];
+
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+
+  if (state->plain == node) { // back at original node
+    state->plain = NULL;
+  }
+
+  if (state->plain != NULL) {
+    switch (node->type) {
+    case CMARK_NODE_TEXT:
+    case CMARK_NODE_CODE:
+    case CMARK_NODE_HTML_INLINE:
+      escape_html(html, node->data, node->len);
+      break;
+
+    case CMARK_NODE_LINEBREAK:
+    case CMARK_NODE_SOFTBREAK:
+      cmark_strbuf_putc(html, ' ');
+      break;
+
+    default:
+      break;
+    }
+    return 1;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    if (entering) {
+      cr(html);
+      cmark_strbuf_puts(html, "<blockquote");
+      S_render_sourcepos(node, html, options);
+      cmark_strbuf_puts(html, ">\n");
+    } else {
+      cr(html);
+      cmark_strbuf_puts(html, "</blockquote>\n");
+    }
+    break;
+
+  case CMARK_NODE_LIST: {
+    cmark_list_type list_type = (cmark_list_type)node->as.list.list_type;
+    int start = node->as.list.start;
+
+    if (entering) {
+      cr(html);
+      if (list_type == CMARK_BULLET_LIST) {
+        cmark_strbuf_puts(html, "<ul");
+        S_render_sourcepos(node, html, options);
+        cmark_strbuf_puts(html, ">\n");
+      } else if (start == 1) {
+        cmark_strbuf_puts(html, "<ol");
+        S_render_sourcepos(node, html, options);
+        cmark_strbuf_puts(html, ">\n");
+      } else {
+        snprintf(buffer, BUFFER_SIZE, "<ol start=\"%d\"", start);
+        cmark_strbuf_puts(html, buffer);
+        S_render_sourcepos(node, html, options);
+        cmark_strbuf_puts(html, ">\n");
+      }
+    } else {
+      cmark_strbuf_puts(html,
+                        list_type == CMARK_BULLET_LIST ? "</ul>\n" : "</ol>\n");
+    }
+    break;
+  }
+
+  case CMARK_NODE_ITEM:
+    if (entering) {
+      cr(html);
+      cmark_strbuf_puts(html, "<li");
+      S_render_sourcepos(node, html, options);
+      cmark_strbuf_putc(html, '>');
+    } else {
+      cmark_strbuf_puts(html, "</li>\n");
+    }
+    break;
+
+  case CMARK_NODE_HEADING:
+    if (entering) {
+      cr(html);
+      start_heading[2] = (char)('0' + node->as.heading.level);
+      cmark_strbuf_puts(html, start_heading);
+      S_render_sourcepos(node, html, options);
+      cmark_strbuf_putc(html, '>');
+    } else {
+      end_heading[3] = (char)('0' + node->as.heading.level);
+      cmark_strbuf_puts(html, end_heading);
+      cmark_strbuf_puts(html, ">\n");
+    }
+    break;
+
+  case CMARK_NODE_CODE_BLOCK:
+    cr(html);
+
+    if (node->as.code.info == NULL || node->as.code.info[0] == 0) {
+      cmark_strbuf_puts(html, "<pre");
+      S_render_sourcepos(node, html, options);
+      cmark_strbuf_puts(html, "><code>");
+    } else {
+      bufsize_t first_tag = 0;
+      while (node->as.code.info[first_tag] &&
+             !cmark_isspace(node->as.code.info[first_tag])) {
+        first_tag += 1;
+      }
+
+      cmark_strbuf_puts(html, "<pre");
+      S_render_sourcepos(node, html, options);
+      cmark_strbuf_puts(html, "><code class=\"");
+      if (strncmp((char *)node->as.code.info, "language-", 9) != 0) {
+        cmark_strbuf_puts(html, "language-");
+      }
+      escape_html(html, node->as.code.info, first_tag);
+      cmark_strbuf_puts(html, "\">");
+    }
+
+    escape_html(html, node->data, node->len);
+    cmark_strbuf_puts(html, "</code></pre>\n");
+    break;
+
+  case CMARK_NODE_HTML_BLOCK:
+    cr(html);
+    if (!(options & CMARK_OPT_UNSAFE)) {
+      cmark_strbuf_puts(html, "<!-- raw HTML omitted -->");
+    } else {
+      cmark_strbuf_put(html, node->data, node->len);
+    }
+    cr(html);
+    break;
+
+  case CMARK_NODE_CUSTOM_BLOCK: {
+    unsigned char *block = entering ? node->as.custom.on_enter :
+                                      node->as.custom.on_exit;
+    cr(html);
+    if (block) {
+      cmark_strbuf_puts(html, (char *)block);
+    }
+    cr(html);
+    break;
+  }
+
+  case CMARK_NODE_THEMATIC_BREAK:
+    cr(html);
+    cmark_strbuf_puts(html, "<hr");
+    S_render_sourcepos(node, html, options);
+    cmark_strbuf_puts(html, " />\n");
+    break;
+
+  case CMARK_NODE_PARAGRAPH:
+    parent = cmark_node_parent(node);
+    grandparent = cmark_node_parent(parent);
+    if (grandparent != NULL && grandparent->type == CMARK_NODE_LIST) {
+      tight = grandparent->as.list.tight;
+    } else {
+      tight = false;
+    }
+    if (!tight) {
+      if (entering) {
+        cr(html);
+        cmark_strbuf_puts(html, "<p");
+        S_render_sourcepos(node, html, options);
+        cmark_strbuf_putc(html, '>');
+      } else {
+        cmark_strbuf_puts(html, "</p>\n");
+      }
+    }
+    break;
+
+  case CMARK_NODE_TEXT:
+    escape_html(html, node->data, node->len);
+    break;
+
+  case CMARK_NODE_LINEBREAK:
+    cmark_strbuf_puts(html, "<br />\n");
+    break;
+
+  case CMARK_NODE_SOFTBREAK:
+    if (options & CMARK_OPT_HARDBREAKS) {
+      cmark_strbuf_puts(html, "<br />\n");
+    } else if (options & CMARK_OPT_NOBREAKS) {
+      cmark_strbuf_putc(html, ' ');
+    } else {
+      cmark_strbuf_putc(html, '\n');
+    }
+    break;
+
+  case CMARK_NODE_CODE:
+    cmark_strbuf_puts(html, "<code>");
+    escape_html(html, node->data, node->len);
+    cmark_strbuf_puts(html, "</code>");
+    break;
+
+  case CMARK_NODE_HTML_INLINE:
+    if (!(options & CMARK_OPT_UNSAFE)) {
+      cmark_strbuf_puts(html, "<!-- raw HTML omitted -->");
+    } else {
+      cmark_strbuf_put(html, node->data, node->len);
+    }
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE: {
+    unsigned char *block = entering ? node->as.custom.on_enter :
+                                      node->as.custom.on_exit;
+    if (block) {
+      cmark_strbuf_puts(html, (char *)block);
+    }
+    break;
+  }
+
+  case CMARK_NODE_STRONG:
+    if (entering) {
+      cmark_strbuf_puts(html, "<strong>");
+    } else {
+      cmark_strbuf_puts(html, "</strong>");
+    }
+    break;
+
+  case CMARK_NODE_EMPH:
+    if (entering) {
+      cmark_strbuf_puts(html, "<em>");
+    } else {
+      cmark_strbuf_puts(html, "</em>");
+    }
+    break;
+
+  case CMARK_NODE_LINK:
+    if (entering) {
+      cmark_strbuf_puts(html, "<a href=\"");
+      if (node->as.link.url && ((options & CMARK_OPT_UNSAFE) ||
+                                !(_scan_dangerous_url(node->as.link.url)))) {
+        houdini_escape_href(html, node->as.link.url,
+                            (bufsize_t)strlen((char *)node->as.link.url));
+      }
+      if (node->as.link.title) {
+        cmark_strbuf_puts(html, "\" title=\"");
+        escape_html(html, node->as.link.title,
+                    (bufsize_t)strlen((char *)node->as.link.title));
+      }
+      cmark_strbuf_puts(html, "\">");
+    } else {
+      cmark_strbuf_puts(html, "</a>");
+    }
+    break;
+
+  case CMARK_NODE_IMAGE:
+    if (entering) {
+      cmark_strbuf_puts(html, "<img src=\"");
+      if (node->as.link.url && ((options & CMARK_OPT_UNSAFE) ||
+                                !(_scan_dangerous_url(node->as.link.url)))) {
+        houdini_escape_href(html, node->as.link.url,
+                            (bufsize_t)strlen((char *)node->as.link.url));
+      }
+      cmark_strbuf_puts(html, "\" alt=\"");
+      state->plain = node;
+    } else {
+      if (node->as.link.title) {
+        cmark_strbuf_puts(html, "\" title=\"");
+        escape_html(html, node->as.link.title,
+                    (bufsize_t)strlen((char *)node->as.link.title));
+      }
+
+      cmark_strbuf_puts(html, "\" />");
+    }
+    break;
+
+  default:
+    assert(false);
+    break;
+  }
+
+  // cmark_strbuf_putc(html, 'x');
+  return 1;
+}
+
+char *cmark_render_html(cmark_node *root, int options) {
+  char *result;
+  cmark_strbuf html = CMARK_BUF_INIT(root->mem);
+  cmark_event_type ev_type;
+  cmark_node *cur;
+  struct render_state state = {&html, NULL};
+  cmark_iter *iter = cmark_iter_new(root);
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    S_render_node(cur, ev_type, &state, options);
+  }
+  result = (char *)cmark_strbuf_detach(&html);
+
+  cmark_iter_free(iter);
+  return result;
+}
diff --git a/cmark/src/inlines.c b/cmark/src/inlines.c
new file mode 100644
index 0000000000..ab82ca74e2
--- /dev/null
+++ b/cmark/src/inlines.c
@@ -0,0 +1,1503 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmark_ctype.h"
+#include "node.h"
+#include "parser.h"
+#include "references.h"
+#include "cmark.h"
+#include "houdini.h"
+#include "utf8.h"
+#include "scanners.h"
+#include "inlines.h"
+
+static const char *EMDASH = "\xE2\x80\x94";
+static const char *ENDASH = "\xE2\x80\x93";
+static const char *ELLIPSES = "\xE2\x80\xA6";
+static const char *LEFTDOUBLEQUOTE = "\xE2\x80\x9C";
+static const char *RIGHTDOUBLEQUOTE = "\xE2\x80\x9D";
+static const char *LEFTSINGLEQUOTE = "\xE2\x80\x98";
+static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99";
+
+// Macros for creating various kinds of simple.
+#define make_linebreak(mem) make_simple(mem, CMARK_NODE_LINEBREAK)
+#define make_softbreak(mem) make_simple(mem, CMARK_NODE_SOFTBREAK)
+#define make_emph(mem) make_simple(mem, CMARK_NODE_EMPH)
+#define make_strong(mem) make_simple(mem, CMARK_NODE_STRONG)
+
+#define MAXBACKTICKS 1000
+
+typedef struct delimiter {
+  struct delimiter *previous;
+  struct delimiter *next;
+  cmark_node *inl_text;
+  bufsize_t position;
+  bufsize_t length;
+  unsigned char delim_char;
+  bool can_open;
+  bool can_close;
+} delimiter;
+
+typedef struct bracket {
+  struct bracket *previous;
+  cmark_node *inl_text;
+  bufsize_t position;
+  bool image;
+  bool active;
+  bool bracket_after;
+} bracket;
+
+#define FLAG_SKIP_HTML_CDATA        (1u << 0)
+#define FLAG_SKIP_HTML_DECLARATION  (1u << 1)
+#define FLAG_SKIP_HTML_PI           (1u << 2)
+#define FLAG_SKIP_HTML_COMMENT      (1u << 3)
+
+typedef struct {
+  cmark_mem *mem;
+  cmark_chunk input;
+  unsigned flags;
+  int line;
+  bufsize_t pos;
+  int block_offset;
+  int column_offset;
+  cmark_reference_map *refmap;
+  delimiter *last_delim;
+  bracket *last_bracket;
+  bufsize_t backticks[MAXBACKTICKS + 1];
+  bool scanned_for_backticks;
+  bool no_link_openers;
+} subject;
+
+static inline bool S_is_line_end_char(char c) {
+  return (c == '\n' || c == '\r');
+}
+
+static delimiter *S_insert_emph(subject *subj, delimiter *opener,
+                                delimiter *closer);
+
+static int parse_inline(subject *subj, cmark_node *parent, int options);
+
+static void subject_from_buf(cmark_mem *mem, int line_number, int block_offset, subject *e,
+                             cmark_chunk *chunk, cmark_reference_map *refmap);
+static bufsize_t subject_find_special_char(subject *subj, int options);
+
+// Create an inline with a literal string value.
+static inline cmark_node *make_literal(subject *subj, cmark_node_type t,
+                                       int start_column, int end_column) {
+  cmark_node *e = (cmark_node *)subj->mem->calloc(1, sizeof(*e));
+  e->mem = subj->mem;
+  e->type = (uint16_t)t;
+  e->start_line = e->end_line = subj->line;
+  // columns are 1 based.
+  e->start_column = start_column + 1 + subj->column_offset + subj->block_offset;
+  e->end_column = end_column + 1 + subj->column_offset + subj->block_offset;
+  return e;
+}
+
+// Create an inline with no value.
+static inline cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) {
+  cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e));
+  e->mem = mem;
+  e->type = t;
+  return e;
+}
+
+static cmark_node *make_str(subject *subj, int sc, int ec, cmark_chunk s) {
+  cmark_node *e = make_literal(subj, CMARK_NODE_TEXT, sc, ec);
+  e->data = (unsigned char *)subj->mem->realloc(NULL, s.len + 1);
+  if (s.data != NULL) {
+    memcpy(e->data, s.data, s.len);
+  }
+  e->data[s.len] = 0;
+  e->len = s.len;
+  return e;
+}
+
+static cmark_node *make_str_from_buf(subject *subj, int sc, int ec,
+                                     cmark_strbuf *buf) {
+  cmark_node *e = make_literal(subj, CMARK_NODE_TEXT, sc, ec);
+  e->len = buf->size;
+  e->data = cmark_strbuf_detach(buf);
+  return e;
+}
+
+// Like make_str, but parses entities.
+static cmark_node *make_str_with_entities(subject *subj,
+                                          int start_column, int end_column,
+                                          cmark_chunk *content) {
+  cmark_strbuf unescaped = CMARK_BUF_INIT(subj->mem);
+
+  if (houdini_unescape_html(&unescaped, content->data, content->len)) {
+    return make_str_from_buf(subj, start_column, end_column, &unescaped);
+  } else {
+    return make_str(subj, start_column, end_column, *content);
+  }
+}
+
+// Like cmark_node_append_child but without costly sanity checks.
+// Assumes that child was newly created.
+static void append_child(cmark_node *node, cmark_node *child) {
+  cmark_node *old_last_child = node->last_child;
+
+  child->next = NULL;
+  child->prev = old_last_child;
+  child->parent = node;
+  node->last_child = child;
+
+  if (old_last_child) {
+    old_last_child->next = child;
+  } else {
+    // Also set first_child if node previously had no children.
+    node->first_child = child;
+  }
+}
+
+// Duplicate a chunk by creating a copy of the buffer not by reusing the
+// buffer like cmark_chunk_dup does.
+static unsigned char *cmark_strdup(cmark_mem *mem, unsigned char *src) {
+  if (src == NULL) {
+    return NULL;
+  }
+  size_t len = strlen((char *)src);
+  unsigned char *data = (unsigned char *)mem->realloc(NULL, len + 1);
+  memcpy(data, src, len + 1);
+  return data;
+}
+
+static unsigned char *cmark_clean_autolink(cmark_mem *mem, cmark_chunk *url,
+                                           int is_email) {
+  cmark_strbuf buf = CMARK_BUF_INIT(mem);
+
+  cmark_chunk_trim(url);
+
+  if (is_email)
+    cmark_strbuf_puts(&buf, "mailto:");
+
+  houdini_unescape_html_f(&buf, url->data, url->len);
+  return cmark_strbuf_detach(&buf);
+}
+
+static inline cmark_node *make_autolink(subject *subj, int start_column,
+                                        int end_column, cmark_chunk url,
+                                        int is_email) {
+  cmark_node *link = make_simple(subj->mem, CMARK_NODE_LINK);
+  link->as.link.url = cmark_clean_autolink(subj->mem, &url, is_email);
+  link->as.link.title = NULL;
+  link->start_line = link->end_line = subj->line;
+  link->start_column = start_column + 1;
+  link->end_column = end_column + 1;
+  append_child(link, make_str_with_entities(subj, start_column + 1, end_column - 1, &url));
+  return link;
+}
+
+static void subject_from_buf(cmark_mem *mem, int line_number, int block_offset, subject *e,
+                             cmark_chunk *chunk, cmark_reference_map *refmap) {
+  int i;
+  e->mem = mem;
+  e->input = *chunk;
+  e->flags = 0;
+  e->line = line_number;
+  e->pos = 0;
+  e->block_offset = block_offset;
+  e->column_offset = 0;
+  e->refmap = refmap;
+  e->last_delim = NULL;
+  e->last_bracket = NULL;
+  for (i = 0; i <= MAXBACKTICKS; i++) {
+    e->backticks[i] = 0;
+  }
+  e->scanned_for_backticks = false;
+  e->no_link_openers = true;
+}
+
+static inline int isbacktick(int c) { return (c == '`'); }
+
+static inline unsigned char peek_char(subject *subj) {
+  // NULL bytes should have been stripped out by now.  If they're
+  // present, it's a programming error:
+  assert(!(subj->pos < subj->input.len && subj->input.data[subj->pos] == 0));
+  return (subj->pos < subj->input.len) ? subj->input.data[subj->pos] : 0;
+}
+
+static inline unsigned char peek_at(subject *subj, bufsize_t pos) {
+  return subj->input.data[pos];
+}
+
+// Return true if there are more characters in the subject.
+static inline int is_eof(subject *subj) {
+  return (subj->pos >= subj->input.len);
+}
+
+// Advance the subject.  Doesn't check for eof.
+#define advance(subj) (subj)->pos += 1
+
+static inline bool skip_spaces(subject *subj) {
+  bool skipped = false;
+  while (peek_char(subj) == ' ' || peek_char(subj) == '\t') {
+    advance(subj);
+    skipped = true;
+  }
+  return skipped;
+}
+
+static inline bool skip_line_end(subject *subj) {
+  bool seen_line_end_char = false;
+  if (peek_char(subj) == '\r') {
+    advance(subj);
+    seen_line_end_char = true;
+  }
+  if (peek_char(subj) == '\n') {
+    advance(subj);
+    seen_line_end_char = true;
+  }
+  return seen_line_end_char || is_eof(subj);
+}
+
+// Take characters while a predicate holds, and return a string.
+static inline cmark_chunk take_while(subject *subj, int (*f)(int)) {
+  unsigned char c;
+  bufsize_t startpos = subj->pos;
+  bufsize_t len = 0;
+
+  while ((c = peek_char(subj)) && (*f)(c)) {
+    advance(subj);
+    len++;
+  }
+
+  return cmark_chunk_dup(&subj->input, startpos, len);
+}
+
+// Return the number of newlines in a given span of text in a subject.  If
+// the number is greater than zero, also return the number of characters
+// between the last newline and the end of the span in `since_newline`.
+static int count_newlines(subject *subj, bufsize_t from, bufsize_t len, int *since_newline) {
+  int nls = 0;
+  int since_nl = 0;
+
+  while (len--) {
+    if (subj->input.data[from++] == '\n') {
+      ++nls;
+      since_nl = 0;
+    } else {
+      ++since_nl;
+    }
+  }
+
+  if (!nls)
+    return 0;
+
+  *since_newline = since_nl;
+  return nls;
+}
+
+// Adjust `node`'s `end_line`, `end_column`, and `subj`'s `line` and
+// `column_offset` according to the number of newlines in a just-matched span
+// of text in `subj`.
+static void adjust_subj_node_newlines(subject *subj, cmark_node *node, int matchlen, int extra, int options) {
+  if (!(options & CMARK_OPT_SOURCEPOS)) {
+    return;
+  }
+
+  int since_newline;
+  int newlines = count_newlines(subj, subj->pos - matchlen - extra, matchlen, &since_newline);
+  if (newlines) {
+    subj->line += newlines;
+    node->end_line += newlines;
+    node->end_column = since_newline;
+    subj->column_offset = -subj->pos + since_newline + extra;
+  }
+}
+
+// Try to process a backtick code span that began with a
+// span of ticks of length openticklength length (already
+// parsed).  Return 0 if you don't find matching closing
+// backticks, otherwise return the position in the subject
+// after the closing backticks.
+static bufsize_t scan_to_closing_backticks(subject *subj,
+                                           bufsize_t openticklength) {
+
+  bool found = false;
+  if (openticklength > MAXBACKTICKS) {
+    // we limit backtick string length because of the array subj->backticks:
+    return 0;
+  }
+  if (subj->scanned_for_backticks &&
+      subj->backticks[openticklength] <= subj->pos) {
+    // return if we already know there's no closer
+    return 0;
+  }
+  while (!found) {
+    // read non backticks
+    unsigned char c;
+    while ((c = peek_char(subj)) && c != '`') {
+      advance(subj);
+    }
+    if (is_eof(subj)) {
+      break;
+    }
+    bufsize_t numticks = 0;
+    while (peek_char(subj) == '`') {
+      advance(subj);
+      numticks++;
+    }
+    // store position of ender
+    if (numticks <= MAXBACKTICKS) {
+      subj->backticks[numticks] = subj->pos - numticks;
+    }
+    if (numticks == openticklength) {
+      return (subj->pos);
+    }
+  }
+  // got through whole input without finding closer
+  subj->scanned_for_backticks = true;
+  return 0;
+}
+
+// Destructively modify string, converting newlines to
+// spaces, then removing a single leading + trailing space,
+// unless the code span consists entirely of space characters.
+static void S_normalize_code(cmark_strbuf *s) {
+  bufsize_t r, w;
+  bool contains_nonspace = false;
+
+  for (r = 0, w = 0; r < s->size; ++r) {
+    switch (s->ptr[r]) {
+    case '\r':
+      if (s->ptr[r + 1] != '\n') {
+        s->ptr[w++] = ' ';
+      }
+      break;
+    case '\n':
+      s->ptr[w++] = ' ';
+      break;
+    default:
+      s->ptr[w++] = s->ptr[r];
+    }
+    if (s->ptr[r] != ' ') {
+      contains_nonspace = true;
+    }
+  }
+
+  // begins and ends with space?
+  if (contains_nonspace &&
+      s->ptr[0] == ' ' && s->ptr[w - 1] == ' ') {
+    cmark_strbuf_drop(s, 1);
+    cmark_strbuf_truncate(s, w - 2);
+  } else {
+    cmark_strbuf_truncate(s, w);
+  }
+
+}
+
+
+// Parse backtick code section or raw backticks, return an inline.
+// Assumes that the subject has a backtick at the current position.
+static cmark_node *handle_backticks(subject *subj, int options) {
+  bufsize_t initpos = subj->pos;
+  cmark_chunk openticks = take_while(subj, isbacktick);
+  bufsize_t startpos = subj->pos;
+  bufsize_t endpos = scan_to_closing_backticks(subj, openticks.len);
+
+  if (endpos == 0) {      // not found
+    subj->pos = startpos; // rewind
+    return make_str(subj, initpos, initpos + openticks.len - 1, openticks);
+  } else {
+    cmark_strbuf buf = CMARK_BUF_INIT(subj->mem);
+
+    cmark_strbuf_set(&buf, subj->input.data + startpos,
+                     endpos - startpos - openticks.len);
+    S_normalize_code(&buf);
+
+    cmark_node *node = make_literal(subj, CMARK_NODE_CODE, startpos,
+                                    endpos - openticks.len - 1);
+    node->len = buf.size;
+    node->data = cmark_strbuf_detach(&buf);
+    adjust_subj_node_newlines(subj, node, endpos - startpos, openticks.len, options);
+    return node;
+  }
+}
+
+
+// Scan ***, **, or * and return number scanned, or 0.
+// Advances position.
+static int scan_delims(subject *subj, unsigned char c, bool *can_open,
+                       bool *can_close) {
+  int numdelims = 0;
+  bufsize_t before_char_pos;
+  int32_t after_char = 0;
+  int32_t before_char = 0;
+  int len;
+  bool left_flanking, right_flanking;
+
+  if (subj->pos == 0) {
+    before_char = 10;
+  } else {
+    before_char_pos = subj->pos - 1;
+    // walk back to the beginning of the UTF_8 sequence:
+    while (peek_at(subj, before_char_pos) >> 6 == 2 && before_char_pos > 0) {
+      before_char_pos -= 1;
+    }
+    len = cmark_utf8proc_iterate(subj->input.data + before_char_pos,
+                                 subj->pos - before_char_pos, &before_char);
+    if (len == -1) {
+      before_char = 10;
+    }
+  }
+
+  if (c == '\'' || c == '"') {
+    numdelims++;
+    advance(subj); // limit to 1 delim for quotes
+  } else {
+    while (peek_char(subj) == c) {
+      numdelims++;
+      advance(subj);
+    }
+  }
+
+  len = cmark_utf8proc_iterate(subj->input.data + subj->pos,
+                               subj->input.len - subj->pos, &after_char);
+  if (len == -1) {
+    after_char = 10;
+  }
+  left_flanking = numdelims > 0 && !cmark_utf8proc_is_space(after_char) &&
+                  (!cmark_utf8proc_is_punctuation_or_symbol(after_char) ||
+                   cmark_utf8proc_is_space(before_char) ||
+                   cmark_utf8proc_is_punctuation_or_symbol(before_char));
+  right_flanking = numdelims > 0 && !cmark_utf8proc_is_space(before_char) &&
+                   (!cmark_utf8proc_is_punctuation_or_symbol(before_char) ||
+                    cmark_utf8proc_is_space(after_char) ||
+                    cmark_utf8proc_is_punctuation_or_symbol(after_char));
+  if (c == '_') {
+    *can_open = left_flanking &&
+                (!right_flanking ||
+                 cmark_utf8proc_is_punctuation_or_symbol(before_char));
+    *can_close = right_flanking &&
+                 (!left_flanking ||
+                  cmark_utf8proc_is_punctuation_or_symbol(after_char));
+  } else if (c == '\'' || c == '"') {
+    *can_open = left_flanking &&
+         (!right_flanking || before_char == '(' || before_char == '[') &&
+         before_char != ']' && before_char != ')';
+    *can_close = right_flanking;
+  } else {
+    *can_open = left_flanking;
+    *can_close = right_flanking;
+  }
+  return numdelims;
+}
+
+/*
+static void print_delimiters(subject *subj)
+{
+        delimiter *delim;
+        delim = subj->last_delim;
+        while (delim != NULL) {
+                printf("Item at stack pos %p: %d %d %d next(%p) prev(%p)\n",
+                       (void*)delim, delim->delim_char,
+                       delim->can_open, delim->can_close,
+                       (void*)delim->next, (void*)delim->previous);
+                delim = delim->previous;
+        }
+}
+*/
+
+static void remove_delimiter(subject *subj, delimiter *delim) {
+  if (delim == NULL)
+    return;
+  if (delim->next == NULL) {
+    // end of list:
+    assert(delim == subj->last_delim);
+    subj->last_delim = delim->previous;
+  } else {
+    delim->next->previous = delim->previous;
+  }
+  if (delim->previous != NULL) {
+    delim->previous->next = delim->next;
+  }
+  subj->mem->free(delim);
+}
+
+static void pop_bracket(subject *subj) {
+  bracket *b;
+  if (subj->last_bracket == NULL)
+    return;
+  b = subj->last_bracket;
+  subj->last_bracket = subj->last_bracket->previous;
+  subj->mem->free(b);
+}
+
+static void push_delimiter(subject *subj, unsigned char c, bool can_open,
+                           bool can_close, cmark_node *inl_text) {
+  delimiter *delim = (delimiter *)subj->mem->calloc(1, sizeof(delimiter));
+  delim->delim_char = c;
+  delim->can_open = can_open;
+  delim->can_close = can_close;
+  delim->inl_text = inl_text;
+  delim->position = subj->pos;
+  delim->length = inl_text->len;
+  delim->previous = subj->last_delim;
+  delim->next = NULL;
+  if (delim->previous != NULL) {
+    delim->previous->next = delim;
+  }
+  subj->last_delim = delim;
+}
+
+static void push_bracket(subject *subj, bool image, cmark_node *inl_text) {
+  bracket *b = (bracket *)subj->mem->calloc(1, sizeof(bracket));
+  if (subj->last_bracket != NULL) {
+    subj->last_bracket->bracket_after = true;
+  }
+  b->image = image;
+  b->active = true;
+  b->inl_text = inl_text;
+  b->previous = subj->last_bracket;
+  b->position = subj->pos;
+  b->bracket_after = false;
+  subj->last_bracket = b;
+  if (!image) {
+    subj->no_link_openers = false;
+  }
+}
+
+// Assumes the subject has a c at the current position.
+static cmark_node *handle_delim(subject *subj, unsigned char c, bool smart) {
+  bufsize_t numdelims;
+  cmark_node *inl_text;
+  bool can_open, can_close;
+  cmark_chunk contents;
+
+  numdelims = scan_delims(subj, c, &can_open, &can_close);
+
+  if (c == '\'' && smart) {
+    contents = cmark_chunk_literal(RIGHTSINGLEQUOTE);
+  } else if (c == '"' && smart) {
+    contents =
+        cmark_chunk_literal(can_close ? RIGHTDOUBLEQUOTE : LEFTDOUBLEQUOTE);
+  } else {
+    contents = cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims);
+  }
+
+  inl_text = make_str(subj, subj->pos - numdelims, subj->pos - 1, contents);
+
+  if ((can_open || can_close) && (!(c == '\'' || c == '"') || smart)) {
+    push_delimiter(subj, c, can_open, can_close, inl_text);
+  }
+
+  return inl_text;
+}
+
+// Assumes we have a hyphen at the current position.
+static cmark_node *handle_hyphen(subject *subj, bool smart) {
+  int startpos = subj->pos;
+
+  advance(subj);
+
+  if (!smart || peek_char(subj) != '-') {
+    return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("-"));
+  }
+
+  while (smart && peek_char(subj) == '-') {
+    advance(subj);
+  }
+
+  int numhyphens = subj->pos - startpos;
+  int en_count = 0;
+  int em_count = 0;
+  int i;
+  cmark_strbuf buf = CMARK_BUF_INIT(subj->mem);
+
+  if (numhyphens % 3 == 0) { // if divisible by 3, use all em dashes
+    em_count = numhyphens / 3;
+  } else if (numhyphens % 2 == 0) { // if divisible by 2, use all en dashes
+    en_count = numhyphens / 2;
+  } else if (numhyphens % 3 == 2) { // use one en dash at end
+    en_count = 1;
+    em_count = (numhyphens - 2) / 3;
+  } else { // use two en dashes at the end
+    en_count = 2;
+    em_count = (numhyphens - 4) / 3;
+  }
+
+  for (i = em_count; i > 0; i--) {
+    cmark_strbuf_puts(&buf, EMDASH);
+  }
+
+  for (i = en_count; i > 0; i--) {
+    cmark_strbuf_puts(&buf, ENDASH);
+  }
+
+  return make_str_from_buf(subj, startpos, subj->pos - 1, &buf);
+}
+
+// Assumes we have a period at the current position.
+static cmark_node *handle_period(subject *subj, bool smart) {
+  advance(subj);
+  if (smart && peek_char(subj) == '.') {
+    advance(subj);
+    if (peek_char(subj) == '.') {
+      advance(subj);
+      return make_str(subj, subj->pos - 3, subj->pos - 1, cmark_chunk_literal(ELLIPSES));
+    } else {
+      return make_str(subj, subj->pos - 2, subj->pos - 1, cmark_chunk_literal(".."));
+    }
+  } else {
+    return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("."));
+  }
+}
+
+static void process_emphasis(subject *subj, bufsize_t stack_bottom) {
+  delimiter *candidate;
+  delimiter *closer = NULL;
+  delimiter *opener;
+  delimiter *old_closer;
+  bool opener_found;
+  int openers_bottom_index = 0;
+  bufsize_t openers_bottom[15] = {stack_bottom, stack_bottom, stack_bottom,
+                                  stack_bottom, stack_bottom, stack_bottom,
+                                  stack_bottom, stack_bottom, stack_bottom,
+                                  stack_bottom, stack_bottom, stack_bottom,
+                                  stack_bottom, stack_bottom, stack_bottom};
+
+  // move back to first relevant delim.
+  candidate = subj->last_delim;
+  while (candidate != NULL && candidate->position >= stack_bottom) {
+    closer = candidate;
+    candidate = candidate->previous;
+  }
+
+  // now move forward, looking for closers, and handling each
+  while (closer != NULL) {
+    if (closer->can_close) {
+      switch (closer->delim_char) {
+      case '"':
+        openers_bottom_index = 0;
+        break;
+      case '\'':
+        openers_bottom_index = 1;
+        break;
+      case '_':
+        openers_bottom_index = 2 +
+                (closer->can_open ? 3 : 0) + (closer->length % 3);
+        break;
+      case '*':
+        openers_bottom_index = 8 +
+                (closer->can_open ? 3 : 0) + (closer->length % 3);
+        break;
+      default:
+        assert(false);
+      }
+
+      // Now look backwards for first matching opener:
+      opener = closer->previous;
+      opener_found = false;
+      while (opener != NULL &&
+             opener->position >= openers_bottom[openers_bottom_index]) {
+        if (opener->can_open && opener->delim_char == closer->delim_char) {
+          // interior closer of size 2 can't match opener of size 1
+          // or of size 1 can't match 2
+          if (!(closer->can_open || opener->can_close) ||
+              closer->length % 3 == 0 ||
+              (opener->length + closer->length) % 3 != 0) {
+            opener_found = true;
+            break;
+          }
+        }
+        opener = opener->previous;
+      }
+      old_closer = closer;
+      if (closer->delim_char == '*' || closer->delim_char == '_') {
+        if (opener_found) {
+          closer = S_insert_emph(subj, opener, closer);
+        } else {
+          closer = closer->next;
+        }
+      } else if (closer->delim_char == '\'' || closer->delim_char == '"') {
+        if (closer->delim_char == '\'') {
+          cmark_node_set_literal(closer->inl_text, RIGHTSINGLEQUOTE);
+        } else {
+          cmark_node_set_literal(closer->inl_text, RIGHTDOUBLEQUOTE);
+        }
+        closer = closer->next;
+        if (opener_found) {
+          if (old_closer->delim_char == '\'') {
+            cmark_node_set_literal(opener->inl_text, LEFTSINGLEQUOTE);
+          } else {
+            cmark_node_set_literal(opener->inl_text, LEFTDOUBLEQUOTE);
+          }
+          remove_delimiter(subj, opener);
+          remove_delimiter(subj, old_closer);
+        }
+      }
+      if (!opener_found) {
+        // set lower bound for future searches for openers
+        openers_bottom[openers_bottom_index] = old_closer->position;
+        if (!old_closer->can_open) {
+          // we can remove a closer that can't be an
+          // opener, once we've seen there's no
+          // matching opener:
+          remove_delimiter(subj, old_closer);
+        }
+      }
+    } else {
+      closer = closer->next;
+    }
+  }
+  // free all delimiters in list until stack_bottom:
+  while (subj->last_delim != NULL &&
+         subj->last_delim->position >= stack_bottom) {
+    remove_delimiter(subj, subj->last_delim);
+  }
+}
+
+static delimiter *S_insert_emph(subject *subj, delimiter *opener,
+                                delimiter *closer) {
+  delimiter *delim, *tmp_delim;
+  bufsize_t use_delims;
+  cmark_node *opener_inl = opener->inl_text;
+  cmark_node *closer_inl = closer->inl_text;
+  bufsize_t opener_num_chars = opener_inl->len;
+  bufsize_t closer_num_chars = closer_inl->len;
+  cmark_node *tmp, *tmpnext, *emph;
+
+  // calculate the actual number of characters used from this closer
+  use_delims = (closer_num_chars >= 2 && opener_num_chars >= 2) ? 2 : 1;
+
+  // remove used characters from associated inlines.
+  opener_num_chars -= use_delims;
+  closer_num_chars -= use_delims;
+  opener_inl->len = opener_num_chars;
+  opener_inl->data[opener_num_chars] = 0;
+  opener_inl->end_column -= use_delims;
+  closer_inl->len = closer_num_chars;
+  closer_inl->data[closer_num_chars] = 0;
+  closer_inl->start_column += use_delims;
+
+  // free delimiters between opener and closer
+  delim = closer->previous;
+  while (delim != NULL && delim != opener) {
+    tmp_delim = delim->previous;
+    remove_delimiter(subj, delim);
+    delim = tmp_delim;
+  }
+
+  // create new emph or strong, and splice it in to our inlines
+  // between the opener and closer
+  emph = use_delims == 1 ? make_emph(subj->mem) : make_strong(subj->mem);
+
+  tmp = opener_inl->next;
+  if (tmp && tmp != closer_inl) {
+    emph->first_child = tmp;
+    tmp->prev = NULL;
+
+    while (tmp && tmp != closer_inl) {
+      tmpnext = tmp->next;
+      tmp->parent = emph;
+      if (tmpnext == closer_inl) {
+        emph->last_child = tmp;
+        tmp->next = NULL;
+      }
+      tmp = tmpnext;
+    }
+  }
+
+  opener_inl->next = emph;
+  closer_inl->prev = emph;
+  emph->prev = opener_inl;
+  emph->next = closer_inl;
+  emph->parent = opener_inl->parent;
+
+  emph->start_line = opener_inl->start_line;
+  emph->end_line = closer_inl->end_line;
+  emph->start_column = opener_inl->start_column + opener_inl->len;
+  emph->end_column = closer_inl->end_column - closer_inl->len;
+
+  // if opener has 0 characters, remove it and its associated inline
+  if (opener_num_chars == 0) {
+    cmark_node_free(opener_inl);
+    remove_delimiter(subj, opener);
+  }
+
+  // if closer has 0 characters, remove it and its associated inline
+  if (closer_num_chars == 0) {
+    // remove empty closer inline
+    cmark_node_free(closer_inl);
+    // remove closer from list
+    tmp_delim = closer->next;
+    remove_delimiter(subj, closer);
+    closer = tmp_delim;
+  }
+
+  return closer;
+}
+
+// Parse backslash-escape or just a backslash, returning an inline.
+static cmark_node *handle_backslash(subject *subj) {
+  advance(subj);
+  unsigned char nextchar = peek_char(subj);
+  if (cmark_ispunct(
+          nextchar)) { // only ascii symbols and newline can be escaped
+    advance(subj);
+    return make_str(subj, subj->pos - 2, subj->pos - 1, cmark_chunk_dup(&subj->input, subj->pos - 1, 1));
+  } else if (!is_eof(subj) && skip_line_end(subj)) {
+    return make_linebreak(subj->mem);
+  } else {
+    return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("\\"));
+  }
+}
+
+// Parse an entity or a regular "&" string.
+// Assumes the subject has an '&' character at the current position.
+static cmark_node *handle_entity(subject *subj) {
+  cmark_strbuf ent = CMARK_BUF_INIT(subj->mem);
+  bufsize_t len;
+
+  advance(subj);
+
+  len = houdini_unescape_ent(&ent, subj->input.data + subj->pos,
+                             subj->input.len - subj->pos);
+
+  if (len <= 0)
+    return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("&"));
+
+  subj->pos += len;
+  return make_str_from_buf(subj, subj->pos - 1 - len, subj->pos - 1, &ent);
+}
+
+// Clean a URL: remove surrounding whitespace, and remove \ that escape
+// punctuation.
+unsigned char *cmark_clean_url(cmark_mem *mem, cmark_chunk *url) {
+  cmark_strbuf buf = CMARK_BUF_INIT(mem);
+
+  cmark_chunk_trim(url);
+
+  houdini_unescape_html_f(&buf, url->data, url->len);
+
+  cmark_strbuf_unescape(&buf);
+  return cmark_strbuf_detach(&buf);
+}
+
+unsigned char *cmark_clean_title(cmark_mem *mem, cmark_chunk *title) {
+  cmark_strbuf buf = CMARK_BUF_INIT(mem);
+  unsigned char first, last;
+
+  if (title->len == 0) {
+    return NULL;
+  }
+
+  first = title->data[0];
+  last = title->data[title->len - 1];
+
+  // remove surrounding quotes if any:
+  if ((first == '\'' && last == '\'') || (first == '(' && last == ')') ||
+      (first == '"' && last == '"')) {
+    houdini_unescape_html_f(&buf, title->data + 1, title->len - 2);
+  } else {
+    houdini_unescape_html_f(&buf, title->data, title->len);
+  }
+
+  cmark_strbuf_unescape(&buf);
+  return cmark_strbuf_detach(&buf);
+}
+
+// Parse an autolink or HTML tag.
+// Assumes the subject has a '<' character at the current position.
+static cmark_node *handle_pointy_brace(subject *subj, int options) {
+  bufsize_t matchlen = 0;
+  cmark_chunk contents;
+
+  advance(subj); // advance past first <
+
+  // first try to match a URL autolink
+  matchlen = scan_autolink_uri(&subj->input, subj->pos);
+  if (matchlen > 0) {
+    contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1);
+    subj->pos += matchlen;
+
+    return make_autolink(subj, subj->pos - 1 - matchlen, subj->pos - 1, contents, 0);
+  }
+
+  // next try to match an email autolink
+  matchlen = scan_autolink_email(&subj->input, subj->pos);
+  if (matchlen > 0) {
+    contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1);
+    subj->pos += matchlen;
+
+    return make_autolink(subj, subj->pos - 1 - matchlen, subj->pos - 1, contents, 1);
+  }
+
+  // finally, try to match an html tag
+  if (subj->pos + 2 <= subj->input.len) {
+    int c = subj->input.data[subj->pos];
+    if (c == '!' && (subj->flags & FLAG_SKIP_HTML_COMMENT) == 0) {
+      c = subj->input.data[subj->pos+1];
+      if (c == '-' && subj->input.data[subj->pos+2] == '-') {
+	if (subj->input.data[subj->pos+3] == '>') {
+	  matchlen = 4;
+	} else if (subj->input.data[subj->pos+3] == '-' &&
+                   subj->input.data[subj->pos+4] == '>') {
+          matchlen = 5;
+        } else {
+          matchlen = scan_html_comment(&subj->input, subj->pos + 1);
+          if (matchlen > 0) {
+            matchlen += 1; // prefix "<"
+	  } else { // no match through end of input: set a flag so
+		   // we don't reparse looking for -->:
+	    subj->flags |= FLAG_SKIP_HTML_COMMENT;
+	  }
+	}
+      } else if (c == '[') {
+        if ((subj->flags & FLAG_SKIP_HTML_CDATA) == 0) {
+          matchlen = scan_html_cdata(&subj->input, subj->pos + 2);
+          if (matchlen > 0) {
+            // The regex doesn't require the final "]]>". But if we're not at
+            // the end of input, it must come after the match. Otherwise,
+            // disable subsequent scans to avoid quadratic behavior.
+            matchlen += 5; // prefix "![", suffix "]]>"
+            if (subj->pos + matchlen > subj->input.len) {
+              subj->flags |= FLAG_SKIP_HTML_CDATA;
+              matchlen = 0;
+            }
+          }
+        }
+      } else if ((subj->flags & FLAG_SKIP_HTML_DECLARATION) == 0) {
+        matchlen = scan_html_declaration(&subj->input, subj->pos + 1);
+        if (matchlen > 0) {
+          matchlen += 2; // prefix "!", suffix ">"
+          if (subj->pos + matchlen > subj->input.len) {
+            subj->flags |= FLAG_SKIP_HTML_DECLARATION;
+            matchlen = 0;
+          }
+        }
+      }
+    } else if (c == '?') {
+      if ((subj->flags & FLAG_SKIP_HTML_PI) == 0) {
+        // Note that we allow an empty match.
+        matchlen = scan_html_pi(&subj->input, subj->pos + 1);
+        matchlen += 3; // prefix "?", suffix "?>"
+        if (subj->pos + matchlen > subj->input.len) {
+          subj->flags |= FLAG_SKIP_HTML_PI;
+          matchlen = 0;
+        }
+      }
+    } else {
+      matchlen = scan_html_tag(&subj->input, subj->pos);
+    }
+  }
+  if (matchlen > 0) {
+    const unsigned char *src = subj->input.data + subj->pos - 1;
+    bufsize_t len = matchlen + 1;
+    subj->pos += matchlen;
+    cmark_node *node = make_literal(subj, CMARK_NODE_HTML_INLINE,
+                                    subj->pos - matchlen - 1, subj->pos - 1);
+    node->data = (unsigned char *)subj->mem->realloc(NULL, len + 1);
+    memcpy(node->data, src, len);
+    node->data[len] = 0;
+    node->len = len;
+    adjust_subj_node_newlines(subj, node, matchlen, 1, options);
+    return node;
+  }
+
+  // if nothing matches, just return the opening <:
+  return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("<"));
+}
+
+// Parse a link label.  Returns 1 if successful.
+// Note:  unescaped brackets are not allowed in labels.
+// The label begins with `[` and ends with the first `]` character
+// encountered.  Backticks in labels do not start code spans.
+static int link_label(subject *subj, cmark_chunk *raw_label) {
+  bufsize_t startpos = subj->pos;
+  int length = 0;
+  unsigned char c;
+
+  // advance past [
+  if (peek_char(subj) == '[') {
+    advance(subj);
+  } else {
+    return 0;
+  }
+
+  while ((c = peek_char(subj)) && c != '[' && c != ']') {
+    if (c == '\\') {
+      advance(subj);
+      length++;
+      if (cmark_ispunct(peek_char(subj))) {
+        advance(subj);
+        length++;
+      }
+    } else {
+      advance(subj);
+      length++;
+    }
+    if (length > MAX_LINK_LABEL_LENGTH) {
+      goto noMatch;
+    }
+  }
+
+  if (c == ']') { // match found
+    *raw_label =
+        cmark_chunk_dup(&subj->input, startpos + 1, subj->pos - (startpos + 1));
+    cmark_chunk_trim(raw_label);
+    advance(subj); // advance past ]
+    return 1;
+  }
+
+noMatch:
+  subj->pos = startpos; // rewind
+  return 0;
+}
+
+static bufsize_t manual_scan_link_url_2(cmark_chunk *input, bufsize_t offset,
+                                        cmark_chunk *output) {
+  bufsize_t i = offset;
+  size_t nb_p = 0;
+
+  while (i < input->len) {
+    if (input->data[i] == '\\' &&
+        i + 1 < input-> len &&
+        cmark_ispunct(input->data[i+1]))
+      i += 2;
+    else if (input->data[i] == '(') {
+      ++nb_p;
+      ++i;
+      if (nb_p > 32)
+        return -1;
+    } else if (input->data[i] == ')') {
+      if (nb_p == 0)
+        break;
+      --nb_p;
+      ++i;
+    } else if (cmark_isspace(input->data[i])) {
+      if (i == offset) {
+        return -1;
+      }
+      break;
+    } else {
+      ++i;
+    }
+  }
+
+  if (i >= input->len || nb_p != 0)
+    return -1;
+
+  {
+    cmark_chunk result = {input->data + offset, i - offset};
+    *output = result;
+  }
+  return i - offset;
+}
+
+static bufsize_t manual_scan_link_url(cmark_chunk *input, bufsize_t offset,
+                                      cmark_chunk *output) {
+  bufsize_t i = offset;
+
+  if (i < input->len && input->data[i] == '<') {
+    ++i;
+    while (i < input->len) {
+      if (input->data[i] == '>') {
+        ++i;
+        break;
+      } else if (input->data[i] == '\\')
+        i += 2;
+      else if (input->data[i] == '\n' || input->data[i] == '<')
+        return -1;
+      else
+        ++i;
+    }
+  } else {
+    return manual_scan_link_url_2(input, offset, output);
+  }
+
+  if (i >= input->len)
+    return -1;
+
+  {
+    cmark_chunk result = {input->data + offset + 1, i - 2 - offset};
+    *output = result;
+  }
+  return i - offset;
+}
+
+// Return a link, an image, or a literal close bracket.
+static cmark_node *handle_close_bracket(subject *subj) {
+  bufsize_t initial_pos, after_link_text_pos;
+  bufsize_t endurl, starttitle, endtitle, endall;
+  bufsize_t sps, n;
+  cmark_reference *ref = NULL;
+  cmark_chunk url_chunk, title_chunk;
+  unsigned char *url, *title;
+  bracket *opener;
+  cmark_node *inl;
+  cmark_chunk raw_label;
+  int found_label;
+  cmark_node *tmp, *tmpnext;
+  bool is_image;
+
+  advance(subj); // advance past ]
+  initial_pos = subj->pos;
+
+  // get last [ or ![
+  opener = subj->last_bracket;
+
+  if (opener == NULL) {
+    return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("]"));
+  }
+
+  // If we got here, we matched a potential link/image text.
+  // Now we check to see if it's a link/image.
+  is_image = opener->image;
+
+  if (!is_image && subj->no_link_openers) {
+    // take delimiter off stack
+    pop_bracket(subj);
+    return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("]"));
+  }
+
+  after_link_text_pos = subj->pos;
+
+  // First, look for an inline link.
+  if (peek_char(subj) == '(' &&
+      ((sps = scan_spacechars(&subj->input, subj->pos + 1)) > -1) &&
+      ((n = manual_scan_link_url(&subj->input, subj->pos + 1 + sps,
+                                 &url_chunk)) > -1)) {
+
+    // try to parse an explicit link:
+    endurl = subj->pos + 1 + sps + n;
+    starttitle = endurl + scan_spacechars(&subj->input, endurl);
+
+    // ensure there are spaces btw url and title
+    endtitle = (starttitle == endurl)
+                   ? starttitle
+                   : starttitle + scan_link_title(&subj->input, starttitle);
+
+    endall = endtitle + scan_spacechars(&subj->input, endtitle);
+
+    if (peek_at(subj, endall) == ')') {
+      subj->pos = endall + 1;
+
+      title_chunk =
+          cmark_chunk_dup(&subj->input, starttitle, endtitle - starttitle);
+      url = cmark_clean_url(subj->mem, &url_chunk);
+      title = cmark_clean_title(subj->mem, &title_chunk);
+      cmark_chunk_free(&url_chunk);
+      cmark_chunk_free(&title_chunk);
+      goto match;
+
+    } else {
+      // it could still be a shortcut reference link
+      subj->pos = after_link_text_pos;
+    }
+  }
+
+  // Next, look for a following [link label] that matches in refmap.
+  // skip spaces
+  raw_label = cmark_chunk_literal("");
+  found_label = link_label(subj, &raw_label);
+  if (!found_label) {
+    // If we have a shortcut reference link, back up
+    // to before the spaces we skipped.
+    subj->pos = initial_pos;
+  }
+
+  if ((!found_label || raw_label.len == 0) && !opener->bracket_after) {
+    cmark_chunk_free(&raw_label);
+    raw_label = cmark_chunk_dup(&subj->input, opener->position,
+                                initial_pos - opener->position - 1);
+    found_label = true;
+  }
+
+  if (found_label) {
+    ref = cmark_reference_lookup(subj->refmap, &raw_label);
+    cmark_chunk_free(&raw_label);
+  }
+
+  if (ref != NULL) { // found
+    url = cmark_strdup(subj->mem, ref->url);
+    title = cmark_strdup(subj->mem, ref->title);
+    goto match;
+  } else {
+    goto noMatch;
+  }
+
+noMatch:
+  // If we fall through to here, it means we didn't match a link:
+  pop_bracket(subj); // remove this opener from delimiter list
+  subj->pos = initial_pos;
+  return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("]"));
+
+match:
+  inl = make_simple(subj->mem, is_image ? CMARK_NODE_IMAGE : CMARK_NODE_LINK);
+  inl->as.link.url = url;
+  inl->as.link.title = title;
+  inl->start_line = inl->end_line = subj->line;
+  inl->start_column = opener->inl_text->start_column;
+  inl->end_column = subj->pos + subj->column_offset + subj->block_offset;
+  cmark_node_insert_before(opener->inl_text, inl);
+  // Add link text:
+  tmp = opener->inl_text->next;
+  while (tmp) {
+    tmpnext = tmp->next;
+    cmark_node_unlink(tmp);
+    append_child(inl, tmp);
+    tmp = tmpnext;
+  }
+
+  // Free the bracket [:
+  cmark_node_free(opener->inl_text);
+
+  process_emphasis(subj, opener->position);
+  pop_bracket(subj);
+
+  // Now, if we have a link, we also want to deactivate links until
+  // we get a new opener. (This code can be removed if we decide to allow links
+  // inside links.)
+  if (!is_image) {
+    subj->no_link_openers = true;
+  }
+
+  return NULL;
+}
+
+// Parse a hard or soft linebreak, returning an inline.
+// Assumes the subject has a cr or newline at the current position.
+static cmark_node *handle_newline(subject *subj) {
+  bufsize_t nlpos = subj->pos;
+  // skip over cr, crlf, or lf:
+  if (peek_at(subj, subj->pos) == '\r') {
+    advance(subj);
+  }
+  if (peek_at(subj, subj->pos) == '\n') {
+    advance(subj);
+  }
+  ++subj->line;
+  subj->column_offset = -subj->pos;
+  // skip spaces at beginning of line
+  skip_spaces(subj);
+  if (nlpos > 1 && peek_at(subj, nlpos - 1) == ' ' &&
+      peek_at(subj, nlpos - 2) == ' ') {
+    return make_linebreak(subj->mem);
+  } else {
+    return make_softbreak(subj->mem);
+  }
+}
+
+static bufsize_t subject_find_special_char(subject *subj, int options) {
+  // "\r\n\\`&_*[]<!"
+  static const int8_t SPECIAL_CHARS[256] = {
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1,
+      1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+  // " ' . -
+  static const char SMART_PUNCT_CHARS[] = {
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  };
+
+  bufsize_t n = subj->pos + 1;
+
+  while (n < subj->input.len) {
+    if (SPECIAL_CHARS[subj->input.data[n]])
+      return n;
+    if (options & CMARK_OPT_SMART && SMART_PUNCT_CHARS[subj->input.data[n]])
+      return n;
+    n++;
+  }
+
+  return subj->input.len;
+}
+
+// Parse an inline, advancing subject, and add it as a child of parent.
+// Return 0 if no inline can be parsed, 1 otherwise.
+static int parse_inline(subject *subj, cmark_node *parent, int options) {
+  cmark_node *new_inl = NULL;
+  cmark_chunk contents;
+  unsigned char c;
+  bufsize_t startpos, endpos;
+  c = peek_char(subj);
+  if (c == 0) {
+    return 0;
+  }
+  switch (c) {
+  case '\r':
+  case '\n':
+    new_inl = handle_newline(subj);
+    break;
+  case '`':
+    new_inl = handle_backticks(subj, options);
+    break;
+  case '\\':
+    new_inl = handle_backslash(subj);
+    break;
+  case '&':
+    new_inl = handle_entity(subj);
+    break;
+  case '<':
+    new_inl = handle_pointy_brace(subj, options);
+    break;
+  case '*':
+  case '_':
+  case '\'':
+  case '"':
+    new_inl = handle_delim(subj, c, (options & CMARK_OPT_SMART) != 0);
+    break;
+  case '-':
+    new_inl = handle_hyphen(subj, (options & CMARK_OPT_SMART) != 0);
+    break;
+  case '.':
+    new_inl = handle_period(subj, (options & CMARK_OPT_SMART) != 0);
+    break;
+  case '[':
+    advance(subj);
+    new_inl = make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("["));
+    push_bracket(subj, false, new_inl);
+    break;
+  case ']':
+    new_inl = handle_close_bracket(subj);
+    break;
+  case '!':
+    advance(subj);
+    if (peek_char(subj) == '[') {
+      advance(subj);
+      new_inl = make_str(subj, subj->pos - 2, subj->pos - 1, cmark_chunk_literal("!["));
+      push_bracket(subj, true, new_inl);
+    } else {
+      new_inl = make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("!"));
+    }
+    break;
+  default:
+    endpos = subject_find_special_char(subj, options);
+    contents = cmark_chunk_dup(&subj->input, subj->pos, endpos - subj->pos);
+    startpos = subj->pos;
+    subj->pos = endpos;
+
+    // if we're at a newline, strip trailing spaces.
+    if (S_is_line_end_char(peek_char(subj))) {
+      cmark_chunk_rtrim(&contents);
+    }
+
+    new_inl = make_str(subj, startpos, endpos - 1, contents);
+  }
+  if (new_inl != NULL) {
+    append_child(parent, new_inl);
+  }
+
+  return 1;
+}
+
+// Parse inlines from parent's string_content, adding as children of parent.
+void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent,
+                         cmark_reference_map *refmap, int options) {
+  int internal_offset = parent->type == CMARK_NODE_HEADING ?
+    parent->as.heading.internal_offset : 0;
+  subject subj;
+  cmark_chunk content = {parent->data, parent->len};
+  subject_from_buf(mem, parent->start_line, parent->start_column - 1 + internal_offset, &subj, &content, refmap);
+  cmark_chunk_rtrim(&subj.input);
+
+  while (!is_eof(&subj) && parse_inline(&subj, parent, options))
+    ;
+
+  process_emphasis(&subj, 0);
+  // free bracket and delim stack
+  while (subj.last_delim) {
+    remove_delimiter(&subj, subj.last_delim);
+  }
+  while (subj.last_bracket) {
+    pop_bracket(&subj);
+  }
+}
+
+// Parse zero or more space characters, including at most one newline.
+static void spnl(subject *subj) {
+  skip_spaces(subj);
+  if (skip_line_end(subj)) {
+    skip_spaces(subj);
+  }
+}
+
+// Parse reference.  Assumes string begins with '[' character.
+// Modify refmap if a reference is encountered.
+// Return 0 if no reference found, otherwise position of subject
+// after reference is parsed.
+bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
+                                       cmark_reference_map *refmap) {
+  subject subj;
+
+  cmark_chunk lab;
+  cmark_chunk url;
+  cmark_chunk title;
+
+  bufsize_t matchlen = 0;
+  bufsize_t beforetitle;
+
+  subject_from_buf(mem, -1, 0, &subj, input, NULL);
+
+  // parse label:
+  if (!link_label(&subj, &lab) || lab.len == 0)
+    return 0;
+
+  // colon:
+  if (peek_char(&subj) == ':') {
+    advance(&subj);
+  } else {
+    return 0;
+  }
+
+  // parse link url:
+  spnl(&subj);
+  if ((matchlen = manual_scan_link_url(&subj.input, subj.pos, &url)) > -1) {
+    subj.pos += matchlen;
+  } else {
+    return 0;
+  }
+
+  // parse optional link_title
+  beforetitle = subj.pos;
+  spnl(&subj);
+  matchlen = subj.pos == beforetitle ? 0 : scan_link_title(&subj.input, subj.pos);
+  if (matchlen) {
+    title = cmark_chunk_dup(&subj.input, subj.pos, matchlen);
+    subj.pos += matchlen;
+  } else {
+    subj.pos = beforetitle;
+    title = cmark_chunk_literal("");
+  }
+
+  // parse final spaces and newline:
+  skip_spaces(&subj);
+  if (!skip_line_end(&subj)) {
+    if (matchlen) { // try rewinding before title
+      subj.pos = beforetitle;
+      skip_spaces(&subj);
+      if (!skip_line_end(&subj)) {
+        return 0;
+      }
+    } else {
+      return 0;
+    }
+  }
+  // insert reference into refmap
+  cmark_reference_create(refmap, &lab, &url, &title);
+  return subj.pos;
+}
diff --git a/cmark/src/inlines.h b/cmark/src/inlines.h
new file mode 100644
index 0000000000..800ed0c68f
--- /dev/null
+++ b/cmark/src/inlines.h
@@ -0,0 +1,24 @@
+#ifndef CMARK_INLINES_H
+#define CMARK_INLINES_H
+
+#include "chunk.h"
+#include "references.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+unsigned char *cmark_clean_url(cmark_mem *mem, cmark_chunk *url);
+unsigned char *cmark_clean_title(cmark_mem *mem, cmark_chunk *title);
+
+void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent,
+                         cmark_reference_map *refmap, int options);
+
+bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
+                                       cmark_reference_map *refmap);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/iterator.c b/cmark/src/iterator.c
new file mode 100644
index 0000000000..cc428285ea
--- /dev/null
+++ b/cmark/src/iterator.c
@@ -0,0 +1,122 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "node.h"
+#include "cmark.h"
+#include "iterator.h"
+
+static const int S_leaf_mask =
+    (1 << CMARK_NODE_HTML_BLOCK) | (1 << CMARK_NODE_THEMATIC_BREAK) |
+    (1 << CMARK_NODE_CODE_BLOCK) | (1 << CMARK_NODE_TEXT) |
+    (1 << CMARK_NODE_SOFTBREAK) | (1 << CMARK_NODE_LINEBREAK) |
+    (1 << CMARK_NODE_CODE) | (1 << CMARK_NODE_HTML_INLINE);
+
+cmark_iter *cmark_iter_new(cmark_node *root) {
+  if (root == NULL) {
+    return NULL;
+  }
+  cmark_mem *mem = root->mem;
+  cmark_iter *iter = (cmark_iter *)mem->calloc(1, sizeof(cmark_iter));
+  iter->mem = mem;
+  iter->root = root;
+  iter->cur.ev_type = CMARK_EVENT_NONE;
+  iter->cur.node = NULL;
+  iter->next.ev_type = CMARK_EVENT_ENTER;
+  iter->next.node = root;
+  return iter;
+}
+
+void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter); }
+
+static bool S_is_leaf(cmark_node *node) {
+  return ((1 << node->type) & S_leaf_mask) != 0;
+}
+
+cmark_event_type cmark_iter_next(cmark_iter *iter) {
+  cmark_event_type ev_type = iter->next.ev_type;
+  cmark_node *node = iter->next.node;
+
+  iter->cur.ev_type = ev_type;
+  iter->cur.node = node;
+
+  if (ev_type == CMARK_EVENT_DONE) {
+    return ev_type;
+  }
+
+  /* roll forward to next item, setting both fields */
+  if (ev_type == CMARK_EVENT_ENTER && !S_is_leaf(node)) {
+    if (node->first_child == NULL) {
+      /* stay on this node but exit */
+      iter->next.ev_type = CMARK_EVENT_EXIT;
+    } else {
+      iter->next.ev_type = CMARK_EVENT_ENTER;
+      iter->next.node = node->first_child;
+    }
+  } else if (node == iter->root) {
+    /* don't move past root */
+    iter->next.ev_type = CMARK_EVENT_DONE;
+    iter->next.node = NULL;
+  } else if (node->next) {
+    iter->next.ev_type = CMARK_EVENT_ENTER;
+    iter->next.node = node->next;
+  } else if (node->parent) {
+    iter->next.ev_type = CMARK_EVENT_EXIT;
+    iter->next.node = node->parent;
+  } else {
+    assert(false);
+    iter->next.ev_type = CMARK_EVENT_DONE;
+    iter->next.node = NULL;
+  }
+
+  return ev_type;
+}
+
+void cmark_iter_reset(cmark_iter *iter, cmark_node *current,
+                      cmark_event_type event_type) {
+  iter->next.ev_type = event_type;
+  iter->next.node = current;
+  cmark_iter_next(iter);
+}
+
+cmark_node *cmark_iter_get_node(cmark_iter *iter) { return iter->cur.node; }
+
+cmark_event_type cmark_iter_get_event_type(cmark_iter *iter) {
+  return iter->cur.ev_type;
+}
+
+cmark_node *cmark_iter_get_root(cmark_iter *iter) { return iter->root; }
+
+void cmark_consolidate_text_nodes(cmark_node *root) {
+  if (root == NULL) {
+    return;
+  }
+  cmark_iter *iter = cmark_iter_new(root);
+  cmark_strbuf buf = CMARK_BUF_INIT(iter->mem);
+  cmark_event_type ev_type;
+  cmark_node *cur, *tmp, *next;
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    if (ev_type == CMARK_EVENT_ENTER && cur->type == CMARK_NODE_TEXT &&
+        cur->next && cur->next->type == CMARK_NODE_TEXT) {
+      cmark_strbuf_clear(&buf);
+      cmark_strbuf_put(&buf, cur->data, cur->len);
+      tmp = cur->next;
+      while (tmp && tmp->type == CMARK_NODE_TEXT) {
+        cmark_iter_next(iter); // advance pointer
+        cmark_strbuf_put(&buf, tmp->data, tmp->len);
+        cur->end_column = tmp->end_column;
+        next = tmp->next;
+        cmark_node_free(tmp);
+        tmp = next;
+      }
+      iter->mem->free(cur->data);
+      cur->len = buf.size;
+      cur->data = cmark_strbuf_detach(&buf);
+    }
+  }
+
+  cmark_strbuf_free(&buf);
+  cmark_iter_free(iter);
+}
diff --git a/cmark/src/iterator.h b/cmark/src/iterator.h
new file mode 100644
index 0000000000..30ce76f519
--- /dev/null
+++ b/cmark/src/iterator.h
@@ -0,0 +1,26 @@
+#ifndef CMARK_ITERATOR_H
+#define CMARK_ITERATOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cmark.h"
+
+typedef struct {
+  cmark_event_type ev_type;
+  cmark_node *node;
+} cmark_iter_state;
+
+struct cmark_iter {
+  cmark_mem *mem;
+  cmark_node *root;
+  cmark_iter_state cur;
+  cmark_iter_state next;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/latex.c b/cmark/src/latex.c
new file mode 100644
index 0000000000..386c14ff58
--- /dev/null
+++ b/cmark/src/latex.c
@@ -0,0 +1,456 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "utf8.h"
+#include "scanners.h"
+#include "render.h"
+
+#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define CR() renderer->cr(renderer)
+#define BLANKLINE() renderer->blankline(renderer)
+#define LIST_NUMBER_STRING_SIZE 20
+
+static inline void outc(cmark_renderer *renderer, cmark_escaping escape,
+                        int32_t c, unsigned char nextc) {
+  if (escape == LITERAL) {
+    cmark_render_code_point(renderer, c);
+    return;
+  }
+
+  switch (c) {
+  case 123: // '{'
+  case 125: // '}'
+  case 35:  // '#'
+  case 37:  // '%'
+  case 38:  // '&'
+    cmark_render_ascii(renderer, "\\");
+    cmark_render_code_point(renderer, c);
+    break;
+  case 36: // '$'
+  case 95: // '_'
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "\\");
+    }
+    cmark_render_code_point(renderer, c);
+    break;
+  case 45:             // '-'
+    if (nextc == 45) { // prevent ligature
+      cmark_render_ascii(renderer, "-{}");
+    } else {
+      cmark_render_ascii(renderer, "-");
+    }
+    break;
+  case 126: // '~'
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "\\textasciitilde{}");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 94: // '^'
+    cmark_render_ascii(renderer, "\\^{}");
+    break;
+  case 92: // '\\'
+    if (escape == URL) {
+      // / acts as path sep even on windows:
+      cmark_render_ascii(renderer, "/");
+    } else {
+      cmark_render_ascii(renderer, "\\textbackslash{}");
+    }
+    break;
+  case 124: // '|'
+    cmark_render_ascii(renderer, "\\textbar{}");
+    break;
+  case 60: // '<'
+    cmark_render_ascii(renderer, "\\textless{}");
+    break;
+  case 62: // '>'
+    cmark_render_ascii(renderer, "\\textgreater{}");
+    break;
+  case 91: // '['
+  case 93: // ']'
+    cmark_render_ascii(renderer, "{");
+    cmark_render_code_point(renderer, c);
+    cmark_render_ascii(renderer, "}");
+    break;
+  case 34: // '"'
+    cmark_render_ascii(renderer, "\\textquotedbl{}");
+    // requires \usepackage[T1]{fontenc}
+    break;
+  case 39: // '\''
+    cmark_render_ascii(renderer, "\\textquotesingle{}");
+    // requires \usepackage{textcomp}
+    break;
+  case 160: // nbsp
+    cmark_render_ascii(renderer, "~");
+    break;
+  case 8230: // hellip
+    cmark_render_ascii(renderer, "\\ldots{}");
+    break;
+  case 8216: // lsquo
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "`");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 8217: // rsquo
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "\'");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 8220: // ldquo
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "``");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 8221: // rdquo
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "''");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 8212: // emdash
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "---");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 8211: // endash
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "--");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  default:
+    cmark_render_code_point(renderer, c);
+  }
+}
+
+typedef enum {
+  NO_LINK,
+  URL_AUTOLINK,
+  EMAIL_AUTOLINK,
+  NORMAL_LINK,
+  INTERNAL_LINK
+} link_type;
+
+static link_type get_link_type(cmark_node *node) {
+  size_t title_len, url_len;
+  cmark_node *link_text;
+  char *realurl;
+  int realurllen;
+  bool isemail = false;
+
+  if (node->type != CMARK_NODE_LINK) {
+    return NO_LINK;
+  }
+
+  const char *url = cmark_node_get_url(node);
+  cmark_chunk url_chunk = cmark_chunk_literal(url);
+
+  if (url && *url == '#') {
+    return INTERNAL_LINK;
+  }
+
+  url_len = strlen(url);
+  if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) {
+    return NO_LINK;
+  }
+
+  const char *title = cmark_node_get_title(node);
+  title_len = strlen(title);
+  // if it has a title, we can't treat it as an autolink:
+  if (title_len == 0) {
+
+    link_text = node->first_child;
+    cmark_consolidate_text_nodes(link_text);
+
+    if (!link_text)
+      return NO_LINK;
+
+    realurl = (char *)url;
+    realurllen = (int)url_len;
+    if (strncmp(realurl, "mailto:", 7) == 0) {
+      realurl += 7;
+      realurllen -= 7;
+      isemail = true;
+    }
+    if (realurllen == link_text->len &&
+        strncmp(realurl, (char *)link_text->data,
+                link_text->len) == 0) {
+      if (isemail) {
+        return EMAIL_AUTOLINK;
+      } else {
+        return URL_AUTOLINK;
+      }
+    }
+  }
+
+  return NORMAL_LINK;
+}
+
+static int S_get_enumlevel(cmark_node *node) {
+  int enumlevel = 0;
+  cmark_node *tmp = node;
+  while (tmp) {
+    if (tmp->type == CMARK_NODE_LIST &&
+        cmark_node_get_list_type(node) == CMARK_ORDERED_LIST) {
+      enumlevel++;
+    }
+    tmp = tmp->parent;
+  }
+  return enumlevel;
+}
+
+static int S_render_node(cmark_renderer *renderer, cmark_node *node,
+                         cmark_event_type ev_type, int options) {
+  int list_number;
+  int enumlevel;
+  char list_number_string[LIST_NUMBER_STRING_SIZE];
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  cmark_list_type list_type;
+  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options);
+
+  // avoid warning about unused parameter:
+  (void)(options);
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    if (entering) {
+      LIT("\\begin{quote}");
+      CR();
+    } else {
+      LIT("\\end{quote}");
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_LIST:
+    list_type = cmark_node_get_list_type(node);
+    if (entering) {
+      LIT("\\begin{");
+      LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize");
+      LIT("}");
+      CR();
+      list_number = cmark_node_get_list_start(node);
+      if (list_number > 1) {
+        enumlevel = S_get_enumlevel(node);
+        // latex normally supports only five levels
+        if (enumlevel >= 1 && enumlevel <= 5) {
+          snprintf(list_number_string, LIST_NUMBER_STRING_SIZE, "%d",
+                   list_number - 1); // the next item will increment this
+          LIT("\\setcounter{enum");
+          switch (enumlevel) {
+          case 1: LIT("i"); break;
+          case 2: LIT("ii"); break;
+          case 3: LIT("iii"); break;
+          case 4: LIT("iv"); break;
+          case 5: LIT("v"); break;
+          default: LIT("i"); break;
+          }
+          LIT("}{");
+          OUT(list_number_string, false, NORMAL);
+          LIT("}");
+        }
+        CR();
+      }
+    } else {
+      LIT("\\end{");
+      LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize");
+      LIT("}");
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_ITEM:
+    if (entering) {
+      LIT("\\item ");
+    } else {
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_HEADING:
+    if (entering) {
+      switch (cmark_node_get_heading_level(node)) {
+      case 1:
+        LIT("\\section");
+        break;
+      case 2:
+        LIT("\\subsection");
+        break;
+      case 3:
+        LIT("\\subsubsection");
+        break;
+      case 4:
+        LIT("\\paragraph");
+        break;
+      case 5:
+        LIT("\\subparagraph");
+        break;
+      }
+      LIT("{");
+    } else {
+      LIT("}");
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_CODE_BLOCK:
+    CR();
+    LIT("\\begin{verbatim}");
+    CR();
+    OUT(cmark_node_get_literal(node), false, LITERAL);
+    CR();
+    LIT("\\end{verbatim}");
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_HTML_BLOCK:
+    break;
+
+  case CMARK_NODE_CUSTOM_BLOCK:
+    CR();
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    CR();
+    break;
+
+  case CMARK_NODE_THEMATIC_BREAK:
+    BLANKLINE();
+    LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}");
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_PARAGRAPH:
+    if (!entering) {
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_TEXT:
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
+    break;
+
+  case CMARK_NODE_LINEBREAK:
+    LIT("\\\\");
+    CR();
+    break;
+
+  case CMARK_NODE_SOFTBREAK:
+    if (options & CMARK_OPT_HARDBREAKS) {
+      LIT("\\\\");
+      CR();
+    } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) {
+      CR();
+    } else {
+      OUT(" ", allow_wrap, NORMAL);
+    }
+    break;
+
+  case CMARK_NODE_CODE:
+    LIT("\\texttt{");
+    OUT(cmark_node_get_literal(node), false, NORMAL);
+    LIT("}");
+    break;
+
+  case CMARK_NODE_HTML_INLINE:
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE:
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    break;
+
+  case CMARK_NODE_STRONG:
+    if (entering) {
+      LIT("\\textbf{");
+    } else {
+      LIT("}");
+    }
+    break;
+
+  case CMARK_NODE_EMPH:
+    if (entering) {
+      LIT("\\emph{");
+    } else {
+      LIT("}");
+    }
+    break;
+
+  case CMARK_NODE_LINK:
+    if (entering) {
+      const char *url = cmark_node_get_url(node);
+      // requires \usepackage{hyperref}
+      switch (get_link_type(node)) {
+      case URL_AUTOLINK:
+        LIT("\\url{");
+        OUT(url, false, URL);
+        LIT("}");
+        return 0; // Don't process further nodes to avoid double-rendering artefacts
+      case EMAIL_AUTOLINK:
+        LIT("\\href{");
+        OUT(url, false, URL);
+        LIT("}{\\nolinkurl{");
+        break;
+      case NORMAL_LINK:
+        LIT("\\href{");
+        OUT(url, false, URL);
+        LIT("}{");
+        break;
+      case INTERNAL_LINK:
+        LIT("\\protect\\hyperlink{");
+        OUT(url + 1, false, URL);
+        LIT("}{");
+        break;
+      case NO_LINK:
+        LIT("{"); // error?
+      }
+    } else {
+      if (get_link_type(node) == EMAIL_AUTOLINK) {
+        LIT("}"); // Close up \nolinkurl argument
+      }
+      LIT("}");
+    }
+
+    break;
+
+  case CMARK_NODE_IMAGE:
+    if (entering) {
+      LIT("\\protect\\includegraphics{");
+      // requires \include{graphicx}
+      OUT(cmark_node_get_url(node), false, URL);
+      LIT("}");
+      return 0;
+    }
+    break;
+
+  default:
+    assert(false);
+    break;
+  }
+
+  return 1;
+}
+
+char *cmark_render_latex(cmark_node *root, int options, int width) {
+  return cmark_render(root, options, width, outc, S_render_node);
+}
diff --git a/cmark/src/libcmark.pc.in b/cmark/src/libcmark.pc.in
new file mode 100644
index 0000000000..e259898a91
--- /dev/null
+++ b/cmark/src/libcmark.pc.in
@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: libcmark
+Description: CommonMark parsing, rendering, and manipulation
+Version: @PROJECT_VERSION@
+Libs: -L${libdir} -lcmark
+Cflags: -I${includedir}
diff --git a/cmark/src/main.c b/cmark/src/main.c
new file mode 100644
index 0000000000..9a43cceda7
--- /dev/null
+++ b/cmark/src/main.c
@@ -0,0 +1,213 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmark.h"
+#include "node.h"
+
+#if defined(__OpenBSD__)
+#  include <sys/param.h>
+#  if OpenBSD >= 201605
+#    define USE_PLEDGE
+#    include <unistd.h>
+#  endif
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+typedef enum {
+  FORMAT_NONE,
+  FORMAT_HTML,
+  FORMAT_XML,
+  FORMAT_MAN,
+  FORMAT_COMMONMARK,
+  FORMAT_LATEX
+} writer_format;
+
+void print_usage(void) {
+  printf("Usage:   cmark [FILE*]\n");
+  printf("Options:\n");
+  printf("  --to, -t FORMAT  Specify output format (html, xml, man, "
+         "commonmark, latex)\n");
+  printf("  --width WIDTH    Specify wrap width (default 0 = nowrap)\n");
+  printf("  --sourcepos      Include source position attribute\n");
+  printf("  --hardbreaks     Treat newlines as hard line breaks\n");
+  printf("  --nobreaks       Render soft line breaks as spaces\n");
+  printf("  --safe           Omit raw HTML and dangerous URLs\n");
+  printf("  --unsafe         Render raw HTML and dangerous URLs\n");
+  printf("  --smart          Use smart punctuation\n");
+  printf("  --validate-utf8  Replace invalid UTF-8 sequences with U+FFFD\n");
+  printf("  --help, -h       Print usage information\n");
+  printf("  --version        Print version\n");
+}
+
+static void print_document(cmark_node *document, writer_format writer,
+                           int options, int width) {
+  char *result;
+
+  switch (writer) {
+  case FORMAT_HTML:
+    result = cmark_render_html(document, options);
+    break;
+  case FORMAT_XML:
+    result = cmark_render_xml(document, options);
+    break;
+  case FORMAT_MAN:
+    result = cmark_render_man(document, options, width);
+    break;
+  case FORMAT_COMMONMARK:
+    result = cmark_render_commonmark(document, options, width);
+    break;
+  case FORMAT_LATEX:
+    result = cmark_render_latex(document, options, width);
+    break;
+  default:
+    fprintf(stderr, "Unknown format %d\n", writer);
+    exit(1);
+  }
+  fwrite(result, strlen(result), 1, stdout);
+  document->mem->free(result);
+}
+
+int main(int argc, char *argv[]) {
+  int i, numfps = 0;
+  int *files;
+  char buffer[4096];
+  cmark_parser *parser;
+  size_t bytes;
+  cmark_node *document;
+  int width = 0;
+  char *unparsed;
+  writer_format writer = FORMAT_HTML;
+  int options = CMARK_OPT_DEFAULT;
+
+#ifdef USE_PLEDGE
+  if (pledge("stdio rpath", NULL) != 0) {
+    perror("pledge");
+    return 1;
+  }
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  _setmode(_fileno(stdin), _O_BINARY);
+  _setmode(_fileno(stdout), _O_BINARY);
+#endif
+
+  files = (int *)calloc(argc, sizeof(*files));
+
+  for (i = 1; i < argc; i++) {
+    if (strcmp(argv[i], "--version") == 0) {
+      printf("cmark %s", CMARK_VERSION_STRING);
+      printf(" - CommonMark converter\n(C) 2014-2016 John MacFarlane\n");
+      exit(0);
+    } else if (strcmp(argv[i], "--sourcepos") == 0) {
+      options |= CMARK_OPT_SOURCEPOS;
+    } else if (strcmp(argv[i], "--hardbreaks") == 0) {
+      options |= CMARK_OPT_HARDBREAKS;
+    } else if (strcmp(argv[i], "--nobreaks") == 0) {
+      options |= CMARK_OPT_NOBREAKS;
+    } else if (strcmp(argv[i], "--smart") == 0) {
+      options |= CMARK_OPT_SMART;
+    } else if (strcmp(argv[i], "--safe") == 0) {
+      options |= CMARK_OPT_SAFE;
+    } else if (strcmp(argv[i], "--unsafe") == 0) {
+      options |= CMARK_OPT_UNSAFE;
+    } else if (strcmp(argv[i], "--validate-utf8") == 0) {
+      options |= CMARK_OPT_VALIDATE_UTF8;
+    } else if ((strcmp(argv[i], "--help") == 0) ||
+               (strcmp(argv[i], "-h") == 0)) {
+      print_usage();
+      exit(0);
+    } else if (strcmp(argv[i], "--width") == 0) {
+      i += 1;
+      if (i < argc) {
+        width = (int)strtol(argv[i], &unparsed, 10);
+        if (unparsed && strlen(unparsed) > 0) {
+          fprintf(stderr, "failed parsing width '%s' at '%s'\n", argv[i],
+                  unparsed);
+          exit(1);
+        }
+      } else {
+        fprintf(stderr, "--width requires an argument\n");
+        exit(1);
+      }
+    } else if ((strcmp(argv[i], "-t") == 0) || (strcmp(argv[i], "--to") == 0)) {
+      i += 1;
+      if (i < argc) {
+        if (strcmp(argv[i], "man") == 0) {
+          writer = FORMAT_MAN;
+        } else if (strcmp(argv[i], "html") == 0) {
+          writer = FORMAT_HTML;
+        } else if (strcmp(argv[i], "xml") == 0) {
+          writer = FORMAT_XML;
+        } else if (strcmp(argv[i], "commonmark") == 0) {
+          writer = FORMAT_COMMONMARK;
+        } else if (strcmp(argv[i], "latex") == 0) {
+          writer = FORMAT_LATEX;
+        } else {
+          fprintf(stderr, "Unknown format %s\n", argv[i]);
+          exit(1);
+        }
+      } else {
+        fprintf(stderr, "No argument provided for %s\n", argv[i - 1]);
+        exit(1);
+      }
+    } else if (*argv[i] == '-') {
+      print_usage();
+      exit(1);
+    } else { // treat as file argument
+      files[numfps++] = i;
+    }
+  }
+
+  parser = cmark_parser_new(options);
+  for (i = 0; i < numfps; i++) {
+    FILE *fp = fopen(argv[files[i]], "rb");
+    if (fp == NULL) {
+      fprintf(stderr, "Error opening file %s: %s\n", argv[files[i]],
+              strerror(errno));
+      exit(1);
+    }
+
+    while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
+      cmark_parser_feed(parser, buffer, bytes);
+      if (bytes < sizeof(buffer)) {
+        break;
+      }
+    }
+
+    fclose(fp);
+  }
+
+  if (numfps == 0) {
+
+    while ((bytes = fread(buffer, 1, sizeof(buffer), stdin)) > 0) {
+      cmark_parser_feed(parser, buffer, bytes);
+      if (bytes < sizeof(buffer)) {
+        break;
+      }
+    }
+  }
+
+#ifdef USE_PLEDGE
+  if (pledge("stdio", NULL) != 0) {
+    perror("pledge");
+    return 1;
+  }
+#endif
+
+  document = cmark_parser_finish(parser);
+  cmark_parser_free(parser);
+
+  print_document(document, writer, options, width);
+
+  cmark_node_free(document);
+
+  free(files);
+
+  return 0;
+}
diff --git a/cmark/src/man.c b/cmark/src/man.c
new file mode 100644
index 0000000000..02dfb7cb39
--- /dev/null
+++ b/cmark/src/man.c
@@ -0,0 +1,281 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "utf8.h"
+#include "render.h"
+
+#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define CR() renderer->cr(renderer)
+#define BLANKLINE() renderer->blankline(renderer)
+#define LIST_NUMBER_SIZE 20
+
+// Functions to convert cmark_nodes to groff man strings.
+static void S_outc(cmark_renderer *renderer, cmark_escaping escape, int32_t c,
+                   unsigned char nextc) {
+  (void)(nextc);
+
+  if (escape == LITERAL) {
+    cmark_render_code_point(renderer, c);
+    return;
+  }
+
+  switch (c) {
+  case 46:
+    if (renderer->begin_line) {
+      cmark_render_ascii(renderer, "\\&.");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 39:
+    if (renderer->begin_line) {
+      cmark_render_ascii(renderer, "\\&'");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 45:
+    cmark_render_ascii(renderer, "\\-");
+    break;
+  case 92:
+    cmark_render_ascii(renderer, "\\e");
+    break;
+  case 8216: // left single quote
+    cmark_render_ascii(renderer, "\\[oq]");
+    break;
+  case 8217: // right single quote
+    cmark_render_ascii(renderer, "\\[cq]");
+    break;
+  case 8220: // left double quote
+    cmark_render_ascii(renderer, "\\[lq]");
+    break;
+  case 8221: // right double quote
+    cmark_render_ascii(renderer, "\\[rq]");
+    break;
+  case 8212: // em dash
+    cmark_render_ascii(renderer, "\\[em]");
+    break;
+  case 8211: // en dash
+    cmark_render_ascii(renderer, "\\[en]");
+    break;
+  default:
+    cmark_render_code_point(renderer, c);
+  }
+}
+
+static int S_render_node(cmark_renderer *renderer, cmark_node *node,
+                         cmark_event_type ev_type, int options) {
+  cmark_node *tmp;
+  int list_number;
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options);
+  struct block_number *new_block_number;
+  cmark_mem *allocator = cmark_get_default_mem_allocator();
+
+  // avoid unused parameter error:
+  (void)(options);
+
+  // indent inside nested lists
+  if (renderer->block_number_in_list_item &&
+      node->type < CMARK_NODE_FIRST_INLINE) {
+    if (entering) {
+      renderer->block_number_in_list_item->number += 1;
+      if (renderer->block_number_in_list_item->number == 2) {
+        CR();
+        LIT(".RS"); // indent
+        CR();
+      }
+    }
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    if (entering) {
+      CR();
+      LIT(".RS");
+      CR();
+    } else {
+      CR();
+      LIT(".RE");
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_LIST:
+    break;
+
+  case CMARK_NODE_ITEM:
+    if (entering) {
+      new_block_number = allocator->calloc(1, sizeof(struct block_number));
+      new_block_number->number = 0;
+      new_block_number->parent = renderer->block_number_in_list_item;
+      renderer->block_number_in_list_item = new_block_number;
+      CR();
+      LIT(".IP ");
+      if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+        LIT("\\[bu] 2");
+      } else {
+        list_number = cmark_node_get_list_start(node->parent);
+        tmp = node;
+        while (tmp->prev) {
+          tmp = tmp->prev;
+          list_number += 1;
+        }
+        char list_number_s[LIST_NUMBER_SIZE];
+        snprintf(list_number_s, LIST_NUMBER_SIZE, "\"%d.\" 4", list_number);
+        LIT(list_number_s);
+      }
+      CR();
+    } else {
+      if (renderer->block_number_in_list_item) {
+        if (renderer->block_number_in_list_item->number >= 2) {
+          CR();
+          LIT(".RE"); // de-indent
+        }
+        new_block_number = renderer->block_number_in_list_item;
+        renderer->block_number_in_list_item =
+          renderer->block_number_in_list_item->parent;
+        allocator->free(new_block_number);
+      }
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_HEADING:
+    if (entering) {
+      CR();
+      LIT(cmark_node_get_heading_level(node) == 1 ? ".SH" : ".SS");
+      CR();
+    } else {
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_CODE_BLOCK:
+    CR();
+    LIT(".IP\n.nf\n\\f[C]\n");
+    OUT(cmark_node_get_literal(node), false, NORMAL);
+    CR();
+    LIT("\\f[]\n.fi");
+    CR();
+    break;
+
+  case CMARK_NODE_HTML_BLOCK:
+    break;
+
+  case CMARK_NODE_CUSTOM_BLOCK:
+    CR();
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    CR();
+    break;
+
+  case CMARK_NODE_THEMATIC_BREAK:
+    CR();
+    LIT(".PP\n  *  *  *  *  *");
+    CR();
+    break;
+
+  case CMARK_NODE_PARAGRAPH:
+    if (entering) {
+      // no blank line if first paragraph in list:
+      if (node->parent && node->parent->type == CMARK_NODE_ITEM &&
+          node->prev == NULL) {
+        // no blank line or .PP
+      } else {
+        CR();
+        LIT(".PP");
+        CR();
+      }
+    } else {
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_TEXT:
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
+    break;
+
+  case CMARK_NODE_LINEBREAK:
+    LIT(".PD 0\n.P\n.PD");
+    CR();
+    break;
+
+  case CMARK_NODE_SOFTBREAK:
+    if (options & CMARK_OPT_HARDBREAKS) {
+      LIT(".PD 0\n.P\n.PD");
+      CR();
+    } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) {
+      CR();
+    } else {
+      OUT(" ", allow_wrap, LITERAL);
+    }
+    break;
+
+  case CMARK_NODE_CODE:
+    LIT("\\f[C]");
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
+    LIT("\\f[]");
+    break;
+
+  case CMARK_NODE_HTML_INLINE:
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE:
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    break;
+
+  case CMARK_NODE_STRONG:
+    if (entering) {
+      LIT("\\f[B]");
+    } else {
+      LIT("\\f[]");
+    }
+    break;
+
+  case CMARK_NODE_EMPH:
+    if (entering) {
+      LIT("\\f[I]");
+    } else {
+      LIT("\\f[]");
+    }
+    break;
+
+  case CMARK_NODE_LINK:
+    if (!entering) {
+      LIT(" (");
+      OUT(cmark_node_get_url(node), allow_wrap, URL);
+      LIT(")");
+    }
+    break;
+
+  case CMARK_NODE_IMAGE:
+    if (entering) {
+      LIT("[IMAGE: ");
+    } else {
+      LIT("]");
+    }
+    break;
+
+  default:
+    assert(false);
+    break;
+  }
+
+  return 1;
+}
+
+char *cmark_render_man(cmark_node *root, int options, int width) {
+  return cmark_render(root, options, width, S_outc, S_render_node);
+}
diff --git a/cmark/src/node.c b/cmark/src/node.c
new file mode 100644
index 0000000000..c1492545e4
--- /dev/null
+++ b/cmark/src/node.c
@@ -0,0 +1,888 @@
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "node.h"
+
+static void S_node_unlink(cmark_node *node);
+
+bool cmark_node_is_block(cmark_node *node) {
+  if (node == NULL) {
+    return false;
+  }
+  return node->type >= CMARK_NODE_FIRST_BLOCK &&
+         node->type <= CMARK_NODE_LAST_BLOCK;
+}
+
+bool cmark_node_is_inline(cmark_node *node) {
+  if (node == NULL) {
+    return false;
+  }
+  return node->type >= CMARK_NODE_FIRST_INLINE &&
+         node->type <= CMARK_NODE_LAST_INLINE;
+}
+
+bool cmark_node_is_leaf(cmark_node *node) {
+  if (node == NULL) {
+    return false;
+  }
+  switch (node->type) {
+    case CMARK_NODE_THEMATIC_BREAK: return true;
+    case CMARK_NODE_CODE_BLOCK : return true;
+    case CMARK_NODE_TEXT : return true;
+    case CMARK_NODE_SOFTBREAK : return true;
+    case CMARK_NODE_LINEBREAK : return true;
+    case CMARK_NODE_CODE : return true;
+    case CMARK_NODE_HTML_INLINE: return true;
+  }
+  return false;
+}
+
+static bool S_can_contain(cmark_node *node, cmark_node *child) {
+  if (node == NULL || child == NULL || node == child) {
+    return false;
+  }
+
+  // Verify that child is not an ancestor of node.
+  if (child->first_child != NULL) {
+    cmark_node *cur = node->parent;
+
+    while (cur != NULL) {
+      if (cur == child) {
+        return false;
+      }
+      cur = cur->parent;
+    }
+  }
+
+  if (child->type == CMARK_NODE_DOCUMENT) {
+    return false;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+  case CMARK_NODE_BLOCK_QUOTE:
+  case CMARK_NODE_ITEM:
+    return cmark_node_is_block(child) && child->type != CMARK_NODE_ITEM;
+
+  case CMARK_NODE_LIST:
+    return child->type == CMARK_NODE_ITEM;
+
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return true;
+
+  case CMARK_NODE_PARAGRAPH:
+  case CMARK_NODE_HEADING:
+  case CMARK_NODE_EMPH:
+  case CMARK_NODE_STRONG:
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+  case CMARK_NODE_CUSTOM_INLINE:
+    return cmark_node_is_inline(child);
+
+  default:
+    break;
+  }
+
+  return false;
+}
+
+cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) {
+  cmark_node *node = (cmark_node *)mem->calloc(1, sizeof(*node));
+  node->mem = mem;
+  node->type = (uint16_t)type;
+
+  switch (node->type) {
+  case CMARK_NODE_HEADING:
+    node->as.heading.level = 1;
+    break;
+
+  case CMARK_NODE_LIST: {
+    cmark_list *list = &node->as.list;
+    list->list_type = CMARK_BULLET_LIST;
+    list->start = 0;
+    list->tight = false;
+    break;
+  }
+
+  default:
+    break;
+  }
+
+  return node;
+}
+
+cmark_node *cmark_node_new(cmark_node_type type) {
+  extern cmark_mem DEFAULT_MEM_ALLOCATOR;
+  return cmark_node_new_with_mem(type, &DEFAULT_MEM_ALLOCATOR);
+}
+
+// Free a cmark_node list and any children.
+static void S_free_nodes(cmark_node *e) {
+  cmark_mem *mem = e->mem;
+  cmark_node *next;
+  while (e != NULL) {
+    switch (e->type) {
+    case CMARK_NODE_CODE_BLOCK:
+      mem->free(e->data);
+      mem->free(e->as.code.info);
+      break;
+    case CMARK_NODE_TEXT:
+    case CMARK_NODE_HTML_INLINE:
+    case CMARK_NODE_CODE:
+    case CMARK_NODE_HTML_BLOCK:
+      mem->free(e->data);
+      break;
+    case CMARK_NODE_LINK:
+    case CMARK_NODE_IMAGE:
+      mem->free(e->as.link.url);
+      mem->free(e->as.link.title);
+      break;
+    case CMARK_NODE_CUSTOM_BLOCK:
+    case CMARK_NODE_CUSTOM_INLINE:
+      mem->free(e->as.custom.on_enter);
+      mem->free(e->as.custom.on_exit);
+      break;
+    default:
+      break;
+    }
+    if (e->last_child) {
+      // Splice children into list
+      e->last_child->next = e->next;
+      e->next = e->first_child;
+    }
+    next = e->next;
+    mem->free(e);
+    e = next;
+  }
+}
+
+void cmark_node_free(cmark_node *node) {
+  S_node_unlink(node);
+  node->next = NULL;
+  S_free_nodes(node);
+}
+
+cmark_node_type cmark_node_get_type(cmark_node *node) {
+  if (node == NULL) {
+    return CMARK_NODE_NONE;
+  } else {
+    return (cmark_node_type)node->type;
+  }
+}
+
+const char *cmark_node_get_type_string(cmark_node *node) {
+  if (node == NULL) {
+    return "NONE";
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_NONE:
+    return "none";
+  case CMARK_NODE_DOCUMENT:
+    return "document";
+  case CMARK_NODE_BLOCK_QUOTE:
+    return "block_quote";
+  case CMARK_NODE_LIST:
+    return "list";
+  case CMARK_NODE_ITEM:
+    return "item";
+  case CMARK_NODE_CODE_BLOCK:
+    return "code_block";
+  case CMARK_NODE_HTML_BLOCK:
+    return "html_block";
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return "custom_block";
+  case CMARK_NODE_PARAGRAPH:
+    return "paragraph";
+  case CMARK_NODE_HEADING:
+    return "heading";
+  case CMARK_NODE_THEMATIC_BREAK:
+    return "thematic_break";
+  case CMARK_NODE_TEXT:
+    return "text";
+  case CMARK_NODE_SOFTBREAK:
+    return "softbreak";
+  case CMARK_NODE_LINEBREAK:
+    return "linebreak";
+  case CMARK_NODE_CODE:
+    return "code";
+  case CMARK_NODE_HTML_INLINE:
+    return "html_inline";
+  case CMARK_NODE_CUSTOM_INLINE:
+    return "custom_inline";
+  case CMARK_NODE_EMPH:
+    return "emph";
+  case CMARK_NODE_STRONG:
+    return "strong";
+  case CMARK_NODE_LINK:
+    return "link";
+  case CMARK_NODE_IMAGE:
+    return "image";
+  }
+
+  return "<unknown>";
+}
+
+cmark_node *cmark_node_next(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->next;
+  }
+}
+
+cmark_node *cmark_node_previous(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->prev;
+  }
+}
+
+cmark_node *cmark_node_parent(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->parent;
+  }
+}
+
+cmark_node *cmark_node_first_child(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->first_child;
+  }
+}
+
+cmark_node *cmark_node_last_child(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->last_child;
+  }
+}
+
+static bufsize_t cmark_set_cstr(cmark_mem *mem, unsigned char **dst,
+                                const char *src) {
+  unsigned char *old = *dst;
+  bufsize_t len;
+
+  if (src && src[0]) {
+      len = (bufsize_t)strlen(src);
+      *dst = (unsigned char *)mem->realloc(NULL, len + 1);
+      memcpy(*dst, src, len + 1);
+  } else {
+      len = 0;
+      *dst = NULL;
+  }
+  if (old) {
+    mem->free(old);
+  }
+
+  return len;
+}
+
+void *cmark_node_get_user_data(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->user_data;
+  }
+}
+
+int cmark_node_set_user_data(cmark_node *node, void *user_data) {
+  if (node == NULL) {
+    return 0;
+  }
+  node->user_data = user_data;
+  return 1;
+}
+
+const char *cmark_node_get_literal(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_HTML_BLOCK:
+  case CMARK_NODE_TEXT:
+  case CMARK_NODE_HTML_INLINE:
+  case CMARK_NODE_CODE:
+  case CMARK_NODE_CODE_BLOCK:
+    return node->data ? (char *)node->data : "";
+
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_literal(cmark_node *node, const char *content) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_HTML_BLOCK:
+  case CMARK_NODE_TEXT:
+  case CMARK_NODE_HTML_INLINE:
+  case CMARK_NODE_CODE:
+  case CMARK_NODE_CODE_BLOCK:
+    node->len = cmark_set_cstr(node->mem, &node->data, content);
+    return 1;
+
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+int cmark_node_get_heading_level(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_HEADING:
+    return node->as.heading.level;
+
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+int cmark_node_set_heading_level(cmark_node *node, int level) {
+  if (node == NULL || level < 1 || level > 6) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_HEADING:
+    node->as.heading.level = level;
+    return 1;
+
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+cmark_list_type cmark_node_get_list_type(cmark_node *node) {
+  if (node == NULL) {
+    return CMARK_NO_LIST;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    return (cmark_list_type)node->as.list.list_type;
+  } else {
+    return CMARK_NO_LIST;
+  }
+}
+
+int cmark_node_set_list_type(cmark_node *node, cmark_list_type type) {
+  if (!(type == CMARK_BULLET_LIST || type == CMARK_ORDERED_LIST)) {
+    return 0;
+  }
+
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    node->as.list.list_type = (unsigned char)type;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+cmark_delim_type cmark_node_get_list_delim(cmark_node *node) {
+  if (node == NULL) {
+    return CMARK_NO_DELIM;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    return (cmark_delim_type)node->as.list.delimiter;
+  } else {
+    return CMARK_NO_DELIM;
+  }
+}
+
+int cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim) {
+  if (!(delim == CMARK_PERIOD_DELIM || delim == CMARK_PAREN_DELIM)) {
+    return 0;
+  }
+
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    node->as.list.delimiter = (unsigned char)delim;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int cmark_node_get_list_start(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    return node->as.list.start;
+  } else {
+    return 0;
+  }
+}
+
+int cmark_node_set_list_start(cmark_node *node, int start) {
+  if (node == NULL || start < 0) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    node->as.list.start = start;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int cmark_node_get_list_tight(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    return node->as.list.tight;
+  } else {
+    return 0;
+  }
+}
+
+int cmark_node_set_list_tight(cmark_node *node, int tight) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    node->as.list.tight = tight == 1;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+const char *cmark_node_get_fence_info(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  if (node->type == CMARK_NODE_CODE_BLOCK) {
+    return node->as.code.info ? (char *)node->as.code.info : "";
+  } else {
+    return NULL;
+  }
+}
+
+int cmark_node_set_fence_info(cmark_node *node, const char *info) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_CODE_BLOCK) {
+    cmark_set_cstr(node->mem, &node->as.code.info, info);
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+const char *cmark_node_get_url(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+    return node->as.link.url ? (char *)node->as.link.url : "";
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_url(cmark_node *node, const char *url) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+    cmark_set_cstr(node->mem, &node->as.link.url, url);
+    return 1;
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+const char *cmark_node_get_title(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+    return node->as.link.title ? (char *)node->as.link.title : "";
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_title(cmark_node *node, const char *title) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+    cmark_set_cstr(node->mem, &node->as.link.title, title);
+    return 1;
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+const char *cmark_node_get_on_enter(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return node->as.custom.on_enter ? (char *)node->as.custom.on_enter : "";
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_on_enter(cmark_node *node, const char *on_enter) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    cmark_set_cstr(node->mem, &node->as.custom.on_enter, on_enter);
+    return 1;
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+const char *cmark_node_get_on_exit(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return node->as.custom.on_exit ? (char *)node->as.custom.on_exit : "";
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_on_exit(cmark_node *node, const char *on_exit) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    cmark_set_cstr(node->mem, &node->as.custom.on_exit, on_exit);
+    return 1;
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+int cmark_node_get_start_line(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+  return node->start_line;
+}
+
+int cmark_node_get_start_column(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+  return node->start_column;
+}
+
+int cmark_node_get_end_line(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+  return node->end_line;
+}
+
+int cmark_node_get_end_column(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+  return node->end_column;
+}
+
+// Unlink a node without adjusting its next, prev, and parent pointers.
+static void S_node_unlink(cmark_node *node) {
+  if (node == NULL) {
+    return;
+  }
+
+  if (node->prev) {
+    node->prev->next = node->next;
+  }
+  if (node->next) {
+    node->next->prev = node->prev;
+  }
+
+  // Adjust first_child and last_child of parent.
+  cmark_node *parent = node->parent;
+  if (parent) {
+    if (parent->first_child == node) {
+      parent->first_child = node->next;
+    }
+    if (parent->last_child == node) {
+      parent->last_child = node->prev;
+    }
+  }
+}
+
+void cmark_node_unlink(cmark_node *node) {
+  S_node_unlink(node);
+
+  node->next = NULL;
+  node->prev = NULL;
+  node->parent = NULL;
+}
+
+int cmark_node_insert_before(cmark_node *node, cmark_node *sibling) {
+  if (node == NULL || sibling == NULL) {
+    return 0;
+  }
+
+  if (!node->parent || !S_can_contain(node->parent, sibling)) {
+    return 0;
+  }
+
+  S_node_unlink(sibling);
+
+  cmark_node *old_prev = node->prev;
+
+  // Insert 'sibling' between 'old_prev' and 'node'.
+  if (old_prev) {
+    old_prev->next = sibling;
+  }
+  sibling->prev = old_prev;
+  sibling->next = node;
+  node->prev = sibling;
+
+  // Set new parent.
+  cmark_node *parent = node->parent;
+  sibling->parent = parent;
+
+  // Adjust first_child of parent if inserted as first child.
+  if (parent && !old_prev) {
+    parent->first_child = sibling;
+  }
+
+  return 1;
+}
+
+int cmark_node_insert_after(cmark_node *node, cmark_node *sibling) {
+  if (node == NULL || sibling == NULL) {
+    return 0;
+  }
+
+  if (!node->parent || !S_can_contain(node->parent, sibling)) {
+    return 0;
+  }
+
+  S_node_unlink(sibling);
+
+  cmark_node *old_next = node->next;
+
+  // Insert 'sibling' between 'node' and 'old_next'.
+  if (old_next) {
+    old_next->prev = sibling;
+  }
+  sibling->next = old_next;
+  sibling->prev = node;
+  node->next = sibling;
+
+  // Set new parent.
+  cmark_node *parent = node->parent;
+  sibling->parent = parent;
+
+  // Adjust last_child of parent if inserted as last child.
+  if (parent && !old_next) {
+    parent->last_child = sibling;
+  }
+
+  return 1;
+}
+
+int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode) {
+  if (!cmark_node_insert_before(oldnode, newnode)) {
+    return 0;
+  }
+  cmark_node_unlink(oldnode);
+  return 1;
+}
+
+int cmark_node_prepend_child(cmark_node *node, cmark_node *child) {
+  if (!S_can_contain(node, child)) {
+    return 0;
+  }
+
+  S_node_unlink(child);
+
+  cmark_node *old_first_child = node->first_child;
+
+  child->next = old_first_child;
+  child->prev = NULL;
+  child->parent = node;
+  node->first_child = child;
+
+  if (old_first_child) {
+    old_first_child->prev = child;
+  } else {
+    // Also set last_child if node previously had no children.
+    node->last_child = child;
+  }
+
+  return 1;
+}
+
+int cmark_node_append_child(cmark_node *node, cmark_node *child) {
+  if (!S_can_contain(node, child)) {
+    return 0;
+  }
+
+  S_node_unlink(child);
+
+  cmark_node *old_last_child = node->last_child;
+
+  child->next = NULL;
+  child->prev = old_last_child;
+  child->parent = node;
+  node->last_child = child;
+
+  if (old_last_child) {
+    old_last_child->next = child;
+  } else {
+    // Also set first_child if node previously had no children.
+    node->first_child = child;
+  }
+
+  return 1;
+}
+
+static void S_print_error(FILE *out, cmark_node *node, const char *elem) {
+  if (out == NULL) {
+    return;
+  }
+  fprintf(out, "Invalid '%s' in node type %s at %d:%d\n", elem,
+          cmark_node_get_type_string(node), node->start_line,
+          node->start_column);
+}
+
+int cmark_node_check(cmark_node *node, FILE *out) {
+  cmark_node *cur;
+  int errors = 0;
+
+  if (!node) {
+    return 0;
+  }
+
+  cur = node;
+  for (;;) {
+    if (cur->first_child) {
+      if (cur->first_child->prev != NULL) {
+        S_print_error(out, cur->first_child, "prev");
+        cur->first_child->prev = NULL;
+        ++errors;
+      }
+      if (cur->first_child->parent != cur) {
+        S_print_error(out, cur->first_child, "parent");
+        cur->first_child->parent = cur;
+        ++errors;
+      }
+      cur = cur->first_child;
+      continue;
+    }
+
+  next_sibling:
+    if (cur == node) {
+      break;
+    }
+    if (cur->next) {
+      if (cur->next->prev != cur) {
+        S_print_error(out, cur->next, "prev");
+        cur->next->prev = cur;
+        ++errors;
+      }
+      if (cur->next->parent != cur->parent) {
+        S_print_error(out, cur->next, "parent");
+        cur->next->parent = cur->parent;
+        ++errors;
+      }
+      cur = cur->next;
+      continue;
+    }
+
+    if (cur->parent->last_child != cur) {
+      S_print_error(out, cur->parent, "last_child");
+      cur->parent->last_child = cur;
+      ++errors;
+    }
+    cur = cur->parent;
+    goto next_sibling;
+  }
+
+  return errors;
+}
diff --git a/cmark/src/node.h b/cmark/src/node.h
new file mode 100644
index 0000000000..3d9ddcf54b
--- /dev/null
+++ b/cmark/src/node.h
@@ -0,0 +1,93 @@
+#ifndef CMARK_NODE_H
+#define CMARK_NODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "cmark.h"
+#include "buffer.h"
+
+typedef struct {
+  int marker_offset;
+  int padding;
+  int start;
+  unsigned char list_type;
+  unsigned char delimiter;
+  unsigned char bullet_char;
+  bool tight;
+} cmark_list;
+
+typedef struct {
+  unsigned char *info;
+  uint8_t fence_length;
+  uint8_t fence_offset;
+  unsigned char fence_char;
+  int8_t fenced;
+} cmark_code;
+
+typedef struct {
+  int internal_offset;
+  int8_t level;
+  bool setext;
+} cmark_heading;
+
+typedef struct {
+  unsigned char *url;
+  unsigned char *title;
+} cmark_link;
+
+typedef struct {
+  unsigned char *on_enter;
+  unsigned char *on_exit;
+} cmark_custom;
+
+enum cmark_node__internal_flags {
+  CMARK_NODE__OPEN = (1 << 0),
+  CMARK_NODE__LAST_LINE_BLANK = (1 << 1),
+  CMARK_NODE__LAST_LINE_CHECKED = (1 << 2),
+  CMARK_NODE__LIST_LAST_LINE_BLANK = (1 << 3),
+};
+
+struct cmark_node {
+  cmark_mem *mem;
+
+  struct cmark_node *next;
+  struct cmark_node *prev;
+  struct cmark_node *parent;
+  struct cmark_node *first_child;
+  struct cmark_node *last_child;
+
+  void *user_data;
+
+  unsigned char *data;
+  bufsize_t len;
+
+  int start_line;
+  int start_column;
+  int end_line;
+  int end_column;
+  uint16_t type;
+  uint16_t flags;
+
+  union {
+    cmark_list list;
+    cmark_code code;
+    cmark_heading heading;
+    cmark_link link;
+    cmark_custom custom;
+    int html_block_type;
+  } as;
+};
+
+CMARK_EXPORT int cmark_node_check(cmark_node *node, FILE *out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/parser.h b/cmark/src/parser.h
new file mode 100644
index 0000000000..f546ace11b
--- /dev/null
+++ b/cmark/src/parser.h
@@ -0,0 +1,42 @@
+#ifndef CMARK_AST_H
+#define CMARK_AST_H
+
+#include <stdio.h>
+#include "references.h"
+#include "node.h"
+#include "buffer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MAX_LINK_LABEL_LENGTH 1000
+
+struct cmark_parser {
+  struct cmark_mem *mem;
+  struct cmark_reference_map *refmap;
+  struct cmark_node *root;
+  struct cmark_node *current;
+  int line_number;
+  bufsize_t offset;
+  bufsize_t column;
+  bufsize_t first_nonspace;
+  bufsize_t first_nonspace_column;
+  bufsize_t thematic_break_kill_pos;
+  int indent;
+  bool blank;
+  bool partially_consumed_tab;
+  cmark_strbuf curline;
+  bufsize_t last_line_length;
+  cmark_strbuf linebuf;
+  cmark_strbuf content;
+  int options;
+  bool last_buffer_ended_with_cr;
+  unsigned int total_size;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/references.c b/cmark/src/references.c
new file mode 100644
index 0000000000..96d793b708
--- /dev/null
+++ b/cmark/src/references.c
@@ -0,0 +1,171 @@
+#include "cmark.h"
+#include "utf8.h"
+#include "parser.h"
+#include "references.h"
+#include "inlines.h"
+#include "chunk.h"
+
+static void reference_free(cmark_reference_map *map, cmark_reference *ref) {
+  cmark_mem *mem = map->mem;
+  if (ref != NULL) {
+    mem->free(ref->label);
+    mem->free(ref->url);
+    mem->free(ref->title);
+    mem->free(ref);
+  }
+}
+
+// normalize reference:  collapse internal whitespace to single space,
+// remove leading/trailing whitespace, case fold
+// Return NULL if the reference name is actually empty (i.e. composed
+// solely from whitespace)
+static unsigned char *normalize_reference(cmark_mem *mem, cmark_chunk *ref) {
+  cmark_strbuf normalized = CMARK_BUF_INIT(mem);
+  unsigned char *result;
+
+  if (ref == NULL)
+    return NULL;
+
+  if (ref->len == 0)
+    return NULL;
+
+  cmark_utf8proc_case_fold(&normalized, ref->data, ref->len);
+  cmark_strbuf_trim(&normalized);
+  cmark_strbuf_normalize_whitespace(&normalized);
+
+  result = cmark_strbuf_detach(&normalized);
+  assert(result);
+
+  if (result[0] == '\0') {
+    mem->free(result);
+    return NULL;
+  }
+
+  return result;
+}
+
+void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label,
+                            cmark_chunk *url, cmark_chunk *title) {
+  cmark_reference *ref;
+  unsigned char *reflabel = normalize_reference(map->mem, label);
+
+  /* empty reference name, or composed from only whitespace */
+  if (reflabel == NULL)
+    return;
+
+  assert(map->sorted == NULL);
+
+  ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref));
+  ref->label = reflabel;
+  ref->url = cmark_clean_url(map->mem, url);
+  ref->title = cmark_clean_title(map->mem, title);
+  ref->age = map->size;
+  ref->next = map->refs;
+
+  if (ref->url != NULL)
+    ref->size += (int)strlen((char*)ref->url);
+  if (ref->title != NULL)
+    ref->size += (int)strlen((char*)ref->title);
+
+  map->refs = ref;
+  map->size++;
+}
+
+static int
+labelcmp(const unsigned char *a, const unsigned char *b) {
+  return strcmp((const char *)a, (const char *)b);
+}
+
+static int
+refcmp(const void *p1, const void *p2) {
+  cmark_reference *r1 = *(cmark_reference **)p1;
+  cmark_reference *r2 = *(cmark_reference **)p2;
+  int res = labelcmp(r1->label, r2->label);
+  return res ? res : ((int)r1->age - (int)r2->age);
+}
+
+static int
+refsearch(const void *label, const void *p2) {
+  cmark_reference *ref = *(cmark_reference **)p2;
+  return labelcmp((const unsigned char *)label, ref->label);
+}
+
+static void sort_references(cmark_reference_map *map) {
+  unsigned int i = 0, last = 0, size = map->size;
+  cmark_reference *r = map->refs, **sorted = NULL;
+
+  sorted = (cmark_reference **)map->mem->calloc(size, sizeof(cmark_reference *));
+  while (r) {
+    sorted[i++] = r;
+    r = r->next;
+  }
+
+  qsort(sorted, size, sizeof(cmark_reference *), refcmp);
+
+  for (i = 1; i < size; i++) {
+    if (labelcmp(sorted[i]->label, sorted[last]->label) != 0)
+      sorted[++last] = sorted[i];
+  }
+  map->sorted = sorted;
+  map->size = last + 1;
+}
+
+// Returns reference if refmap contains a reference with matching
+// label, otherwise NULL.
+cmark_reference *cmark_reference_lookup(cmark_reference_map *map,
+                                        cmark_chunk *label) {
+  cmark_reference **ref = NULL;
+  cmark_reference *r = NULL;
+  unsigned char *norm;
+
+  if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH)
+    return NULL;
+
+  if (map == NULL || !map->size)
+    return NULL;
+
+  norm = normalize_reference(map->mem, label);
+  if (norm == NULL)
+    return NULL;
+
+  if (!map->sorted)
+    sort_references(map);
+
+  ref = (cmark_reference **)bsearch(norm, map->sorted, map->size, sizeof(cmark_reference *),
+                refsearch);
+  map->mem->free(norm);
+
+  if (ref != NULL) {
+    r = ref[0];
+    /* Check for expansion limit */
+    if (map->max_ref_size && r->size > map->max_ref_size - map->ref_size)
+      return NULL;
+    map->ref_size += r->size;
+  }
+
+  return r;
+}
+
+void cmark_reference_map_free(cmark_reference_map *map) {
+  cmark_reference *ref;
+
+  if (map == NULL)
+    return;
+
+  ref = map->refs;
+  while (ref) {
+    cmark_reference *next = ref->next;
+    reference_free(map, ref);
+    ref = next;
+  }
+
+  map->mem->free(map->sorted);
+  map->mem->free(map);
+}
+
+cmark_reference_map *cmark_reference_map_new(cmark_mem *mem) {
+  cmark_reference_map *map =
+      (cmark_reference_map *)mem->calloc(1, sizeof(cmark_reference_map));
+  map->mem = mem;
+  return map;
+}
diff --git a/cmark/src/references.h b/cmark/src/references.h
new file mode 100644
index 0000000000..27f15de2a4
--- /dev/null
+++ b/cmark/src/references.h
@@ -0,0 +1,43 @@
+#ifndef CMARK_REFERENCES_H
+#define CMARK_REFERENCES_H
+
+#include "chunk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct cmark_reference {
+  struct cmark_reference *next;
+  unsigned char *label;
+  unsigned char *url;
+  unsigned char *title;
+  unsigned int age;
+  unsigned int size;
+};
+
+typedef struct cmark_reference cmark_reference;
+
+struct cmark_reference_map {
+  cmark_mem *mem;
+  cmark_reference *refs;
+  cmark_reference **sorted;
+  unsigned int size;
+  unsigned int ref_size;
+  unsigned int max_ref_size;
+};
+
+typedef struct cmark_reference_map cmark_reference_map;
+
+cmark_reference_map *cmark_reference_map_new(cmark_mem *mem);
+void cmark_reference_map_free(cmark_reference_map *map);
+cmark_reference *cmark_reference_lookup(cmark_reference_map *map,
+                                        cmark_chunk *label);
+void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label,
+                            cmark_chunk *url, cmark_chunk *title);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/render.c b/cmark/src/render.c
new file mode 100644
index 0000000000..0404deba15
--- /dev/null
+++ b/cmark/src/render.c
@@ -0,0 +1,195 @@
+#include <stdlib.h>
+#include "buffer.h"
+#include "cmark.h"
+#include "utf8.h"
+#include "render.h"
+#include "node.h"
+#include "cmark_ctype.h"
+
+static inline void S_cr(cmark_renderer *renderer) {
+  if (renderer->need_cr < 1) {
+    renderer->need_cr = 1;
+  }
+}
+
+static inline void S_blankline(cmark_renderer *renderer) {
+  if (renderer->need_cr < 2) {
+    renderer->need_cr = 2;
+  }
+}
+
+static void S_out(cmark_renderer *renderer, const char *source, bool wrap,
+                  cmark_escaping escape) {
+  int length = (int)strlen(source);
+  unsigned char nextc;
+  int32_t c;
+  int i = 0;
+  int last_nonspace;
+  int len;
+  int k = renderer->buffer->size - 1;
+
+  wrap = wrap && !renderer->no_linebreaks;
+
+  if (renderer->in_tight_list_item && renderer->need_cr > 1) {
+    renderer->need_cr = 1;
+  }
+  while (renderer->need_cr) {
+    if (k < 0 || renderer->buffer->ptr[k] == '\n') {
+      k -= 1;
+    } else {
+      cmark_strbuf_putc(renderer->buffer, '\n');
+      if (renderer->need_cr > 1) {
+        cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+                         renderer->prefix->size);
+      }
+    }
+    renderer->column = 0;
+    renderer->last_breakable = 0;
+    renderer->begin_line = true;
+    renderer->begin_content = true;
+    renderer->need_cr -= 1;
+  }
+
+  while (i < length) {
+    if (renderer->begin_line) {
+      cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+                       renderer->prefix->size);
+      // note: this assumes prefix is ascii:
+      renderer->column = renderer->prefix->size;
+    }
+
+    len = cmark_utf8proc_iterate((const uint8_t *)source + i, length - i, &c);
+    if (len == -1) { // error condition
+      return;        // return without rendering rest of string
+    }
+    nextc = source[i + len];
+    if (c == 32 && wrap) {
+      if (!renderer->begin_line) {
+        last_nonspace = renderer->buffer->size;
+        cmark_strbuf_putc(renderer->buffer, ' ');
+        renderer->column += 1;
+        renderer->begin_line = false;
+        renderer->begin_content = false;
+        // skip following spaces
+        while (source[i + 1] == ' ') {
+          i++;
+        }
+        // We don't allow breaks that make a digit the first character
+        // because this causes problems with commonmark output.
+        if (!cmark_isdigit(source[i + 1])) {
+          renderer->last_breakable = last_nonspace;
+        }
+      }
+
+    } else if (escape == LITERAL) {
+      if (c == 10) {
+        cmark_strbuf_putc(renderer->buffer, '\n');
+        renderer->column = 0;
+        renderer->begin_line = true;
+        renderer->begin_content = true;
+        renderer->last_breakable = 0;
+      } else {
+        cmark_render_code_point(renderer, c);
+        renderer->begin_line = false;
+        // we don't set 'begin_content' to false til we've
+        // finished parsing a digit.  Reason:  in commonmark
+        // we need to escape a potential list marker after
+        // a digit:
+        renderer->begin_content =
+            renderer->begin_content && cmark_isdigit(c) == 1;
+      }
+    } else {
+      (renderer->outc)(renderer, escape, c, nextc);
+      renderer->begin_line = false;
+      renderer->begin_content =
+          renderer->begin_content && cmark_isdigit(c) == 1;
+    }
+
+    // If adding the character went beyond width, look for an
+    // earlier place where the line could be broken:
+    if (renderer->width > 0 && renderer->column > renderer->width &&
+        !renderer->begin_line && renderer->last_breakable > 0) {
+
+      // copy from last_breakable to remainder
+      unsigned char *src = renderer->buffer->ptr +
+                           renderer->last_breakable + 1;
+      bufsize_t remainder_len = renderer->buffer->size -
+                                renderer->last_breakable - 1;
+      unsigned char *remainder =
+          (unsigned char *)renderer->mem->realloc(NULL, remainder_len);
+      memcpy(remainder, src, remainder_len);
+      // truncate at last_breakable
+      cmark_strbuf_truncate(renderer->buffer, renderer->last_breakable);
+      // add newline, prefix, and remainder
+      cmark_strbuf_putc(renderer->buffer, '\n');
+      cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+                       renderer->prefix->size);
+      cmark_strbuf_put(renderer->buffer, remainder, remainder_len);
+      renderer->column = renderer->prefix->size + remainder_len;
+      renderer->mem->free(remainder);
+      renderer->last_breakable = 0;
+      renderer->begin_line = false;
+      renderer->begin_content = false;
+    }
+
+    i += len;
+  }
+}
+
+// Assumes no newlines, assumes ascii content:
+void cmark_render_ascii(cmark_renderer *renderer, const char *s) {
+  int origsize = renderer->buffer->size;
+  cmark_strbuf_puts(renderer->buffer, s);
+  renderer->column += renderer->buffer->size - origsize;
+}
+
+void cmark_render_code_point(cmark_renderer *renderer, uint32_t c) {
+  cmark_utf8proc_encode_char(c, renderer->buffer);
+  renderer->column += 1;
+}
+
+char *cmark_render(cmark_node *root, int options, int width,
+                   void (*outc)(cmark_renderer *, cmark_escaping, int32_t,
+                                unsigned char),
+                   int (*render_node)(cmark_renderer *renderer,
+                                      cmark_node *node,
+                                      cmark_event_type ev_type, int options)) {
+  cmark_mem *mem = root->mem;
+  cmark_strbuf pref = CMARK_BUF_INIT(mem);
+  cmark_strbuf buf = CMARK_BUF_INIT(mem);
+  cmark_node *cur;
+  cmark_event_type ev_type;
+  char *result;
+  cmark_iter *iter = cmark_iter_new(root);
+
+  cmark_renderer renderer = {options,
+                             mem,    &buf,    &pref,      0,      width,
+                             0,      0,       true,       true,   false,
+                             false,  NULL,
+                             outc,   S_cr,    S_blankline, S_out};
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    if (!render_node(&renderer, cur, ev_type, options)) {
+      // a false value causes us to skip processing
+      // the node's contents.  this is used for
+      // autolinks.
+      cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT);
+    }
+  }
+
+  // If the root node is a block type (i.e. not inline), ensure there's a final newline:
+  if (cmark_node_is_block(root)) {
+    if (renderer.buffer->size == 0 || renderer.buffer->ptr[renderer.buffer->size - 1] != '\n') {
+      cmark_strbuf_putc(renderer.buffer, '\n');
+    }
+  }
+
+  result = (char *)cmark_strbuf_detach(renderer.buffer);
+
+  cmark_iter_free(iter);
+  cmark_strbuf_free(renderer.prefix);
+  cmark_strbuf_free(renderer.buffer);
+
+  return result;
+}
diff --git a/cmark/src/render.h b/cmark/src/render.h
new file mode 100644
index 0000000000..6f71acbd4e
--- /dev/null
+++ b/cmark/src/render.h
@@ -0,0 +1,57 @@
+#ifndef CMARK_RENDER_H
+#define CMARK_RENDER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "buffer.h"
+
+typedef enum { LITERAL, NORMAL, TITLE, URL } cmark_escaping;
+
+struct block_number {
+  int number;
+  struct block_number *parent;
+};
+
+struct cmark_renderer {
+  int options;
+  cmark_mem *mem;
+  cmark_strbuf *buffer;
+  cmark_strbuf *prefix;
+  int column;
+  int width;
+  int need_cr;
+  bufsize_t last_breakable;
+  bool begin_line;
+  bool begin_content;
+  bool no_linebreaks;
+  bool in_tight_list_item;
+  struct block_number *block_number_in_list_item;
+  void (*outc)(struct cmark_renderer *, cmark_escaping, int32_t, unsigned char);
+  void (*cr)(struct cmark_renderer *);
+  void (*blankline)(struct cmark_renderer *);
+  void (*out)(struct cmark_renderer *, const char *, bool, cmark_escaping);
+};
+
+typedef struct cmark_renderer cmark_renderer;
+
+void cmark_render_ascii(cmark_renderer *renderer, const char *s);
+
+void cmark_render_code_point(cmark_renderer *renderer, uint32_t c);
+
+char *cmark_render(cmark_node *root, int options, int width,
+                   void (*outc)(cmark_renderer *, cmark_escaping, int32_t,
+                                unsigned char),
+                   int (*render_node)(cmark_renderer *renderer,
+                                      cmark_node *node,
+                                      cmark_event_type ev_type, int options));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/scanners.c b/cmark/src/scanners.c
new file mode 100644
index 0000000000..7338c75b76
--- /dev/null
+++ b/cmark/src/scanners.c
@@ -0,0 +1,9415 @@
+/* Generated by re2c 3.0 */
+#include <stdlib.h>
+#include "chunk.h"
+#include "scanners.h"
+
+bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c,
+                   bufsize_t offset) {
+  bufsize_t res;
+  unsigned char *ptr = (unsigned char *)c->data;
+
+  if (ptr == NULL || offset > c->len) {
+    return 0;
+  } else {
+    unsigned char lim = ptr[c->len];
+
+    ptr[c->len] = '\0';
+    res = scanner(ptr + offset);
+    ptr[c->len] = lim;
+  }
+
+  return res;
+}
+
+// Try to match a scheme including colon.
+bufsize_t _scan_scheme(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    yych = *p;
+    if (yych <= '@')
+      goto yy1;
+    if (yych <= 'Z')
+      goto yy3;
+    if (yych <= '`')
+      goto yy1;
+    if (yych <= 'z')
+      goto yy3;
+  yy1:
+    ++p;
+  yy2 : { return 0; }
+  yy3:
+    yych = *(marker = ++p);
+    if (yych <= '/') {
+      if (yych <= '+') {
+        if (yych <= '*')
+          goto yy2;
+      } else {
+        if (yych <= ',')
+          goto yy2;
+        if (yych >= '/')
+          goto yy2;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '9')
+          goto yy4;
+        if (yych <= '@')
+          goto yy2;
+      } else {
+        if (yych <= '`')
+          goto yy2;
+        if (yych >= '{')
+          goto yy2;
+      }
+    }
+  yy4:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych == '+')
+          goto yy6;
+      } else {
+        if (yych != '/')
+          goto yy6;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych >= 'A')
+          goto yy6;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych <= 'z')
+          goto yy6;
+      }
+    }
+  yy5:
+    p = marker;
+    goto yy2;
+  yy6:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych == '+')
+          goto yy8;
+        goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+        goto yy8;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+        goto yy8;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych <= 'z')
+          goto yy8;
+        goto yy5;
+      }
+    }
+  yy7:
+    ++p;
+    { return (bufsize_t)(p - start); }
+  yy8:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy5;
+      } else {
+        if (yych == '/')
+          goto yy5;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy7;
+        if (yych <= '@')
+          goto yy5;
+      } else {
+        if (yych <= '`')
+          goto yy5;
+        if (yych >= '{')
+          goto yy5;
+      }
+    }
+    yych = *++p;
+    if (yych == ':')
+      goto yy7;
+    goto yy5;
+  }
+}
+
+// Try to match URI autolink after first <, returning number of chars matched.
+bufsize_t _scan_autolink_uri(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 0,   128, 0,   128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128,
+    };
+    yych = *p;
+    if (yych <= '@')
+      goto yy10;
+    if (yych <= 'Z')
+      goto yy12;
+    if (yych <= '`')
+      goto yy10;
+    if (yych <= 'z')
+      goto yy12;
+  yy10:
+    ++p;
+  yy11 : { return 0; }
+  yy12:
+    yych = *(marker = ++p);
+    if (yych <= '/') {
+      if (yych <= '+') {
+        if (yych <= '*')
+          goto yy11;
+      } else {
+        if (yych <= ',')
+          goto yy11;
+        if (yych >= '/')
+          goto yy11;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '9')
+          goto yy13;
+        if (yych <= '@')
+          goto yy11;
+      } else {
+        if (yych <= '`')
+          goto yy11;
+        if (yych >= '{')
+          goto yy11;
+      }
+    }
+  yy13:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych == '+')
+          goto yy15;
+      } else {
+        if (yych != '/')
+          goto yy15;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych >= 'A')
+          goto yy15;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych <= 'z')
+          goto yy15;
+      }
+    }
+  yy14:
+    p = marker;
+    goto yy11;
+  yy15:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych == '+')
+          goto yy17;
+        goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+        goto yy17;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+        goto yy17;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych <= 'z')
+          goto yy17;
+        goto yy14;
+      }
+    }
+  yy16:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy16;
+    }
+    if (yych <= '<')
+      goto yy14;
+    goto yy18;
+  yy17:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych == '+')
+          goto yy19;
+        goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+        goto yy19;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+        goto yy19;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych <= 'z')
+          goto yy19;
+        goto yy14;
+      }
+    }
+  yy18:
+    ++p;
+    { return (bufsize_t)(p - start); }
+  yy19:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych <= ',') {
+        if (yych != '+')
+          goto yy14;
+      } else {
+        if (yych == '/')
+          goto yy14;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= ':')
+          goto yy16;
+        if (yych <= '@')
+          goto yy14;
+      } else {
+        if (yych <= '`')
+          goto yy14;
+        if (yych >= '{')
+          goto yy14;
+      }
+    }
+    yych = *++p;
+    if (yych == ':')
+      goto yy16;
+    goto yy14;
+  }
+}
+
+// Try to match email autolink after first <, returning num of chars matched.
+bufsize_t _scan_autolink_email(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   128, 0,   128, 128, 128, 128, 128, 0,   0,
+        128, 128, 0,   128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 0,   0,   0,   128, 0,   128, 0,   128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 0,   0,   0,   128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,
+    };
+    yych = *p;
+    if (yych <= '9') {
+      if (yych <= '\'') {
+        if (yych == '!')
+          goto yy23;
+        if (yych >= '#')
+          goto yy23;
+      } else {
+        if (yych <= ')')
+          goto yy21;
+        if (yych != ',')
+          goto yy23;
+      }
+    } else {
+      if (yych <= '?') {
+        if (yych == '=')
+          goto yy23;
+        if (yych >= '?')
+          goto yy23;
+      } else {
+        if (yych <= 'Z') {
+          if (yych >= 'A')
+            goto yy23;
+        } else {
+          if (yych <= ']')
+            goto yy21;
+          if (yych <= '~')
+            goto yy23;
+        }
+      }
+    }
+  yy21:
+    ++p;
+  yy22 : { return 0; }
+  yy23:
+    yych = *(marker = ++p);
+    if (yych <= ',') {
+      if (yych <= '"') {
+        if (yych == '!')
+          goto yy25;
+        goto yy22;
+      } else {
+        if (yych <= '\'')
+          goto yy25;
+        if (yych <= ')')
+          goto yy22;
+        if (yych <= '+')
+          goto yy25;
+        goto yy22;
+      }
+    } else {
+      if (yych <= '>') {
+        if (yych <= '9')
+          goto yy25;
+        if (yych == '=')
+          goto yy25;
+        goto yy22;
+      } else {
+        if (yych <= 'Z')
+          goto yy25;
+        if (yych <= ']')
+          goto yy22;
+        if (yych <= '~')
+          goto yy25;
+        goto yy22;
+      }
+    }
+  yy24:
+    yych = *++p;
+  yy25:
+    if (yybm[0 + yych] & 128) {
+      goto yy24;
+    }
+    if (yych <= '>')
+      goto yy26;
+    if (yych <= '@')
+      goto yy27;
+  yy26:
+    p = marker;
+    goto yy22;
+  yy27:
+    yych = *++p;
+    if (yych <= '@') {
+      if (yych <= '/')
+        goto yy26;
+      if (yych >= ':')
+        goto yy26;
+    } else {
+      if (yych <= 'Z')
+        goto yy28;
+      if (yych <= '`')
+        goto yy26;
+      if (yych >= '{')
+        goto yy26;
+    }
+  yy28:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy29;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy29;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy29;
+        goto yy26;
+      }
+    }
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy31;
+      if (yych <= '/')
+        goto yy26;
+      goto yy32;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy32;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy32;
+        goto yy26;
+      }
+    }
+  yy29:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych <= '-')
+          goto yy31;
+        goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy32;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy32;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy32;
+        goto yy26;
+      }
+    }
+  yy30:
+    ++p;
+    { return (bufsize_t)(p - start); }
+  yy31:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy33;
+      if (yych <= '/')
+        goto yy26;
+      goto yy34;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy34;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy34;
+        goto yy26;
+      }
+    }
+  yy32:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy34;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy34;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy34;
+        goto yy26;
+      }
+    }
+  yy33:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy35;
+      if (yych <= '/')
+        goto yy26;
+      goto yy36;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy36;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy36;
+        goto yy26;
+      }
+    }
+  yy34:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy36;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy36;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy36;
+        goto yy26;
+      }
+    }
+  yy35:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy37;
+      if (yych <= '/')
+        goto yy26;
+      goto yy38;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy38;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy38;
+        goto yy26;
+      }
+    }
+  yy36:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy38;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy38;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy38;
+        goto yy26;
+      }
+    }
+  yy37:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy39;
+      if (yych <= '/')
+        goto yy26;
+      goto yy40;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy40;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy40;
+        goto yy26;
+      }
+    }
+  yy38:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy40;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy40;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy40;
+        goto yy26;
+      }
+    }
+  yy39:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy41;
+      if (yych <= '/')
+        goto yy26;
+      goto yy42;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy42;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy42;
+        goto yy26;
+      }
+    }
+  yy40:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy42;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy42;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy42;
+        goto yy26;
+      }
+    }
+  yy41:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy43;
+      if (yych <= '/')
+        goto yy26;
+      goto yy44;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy44;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy44;
+        goto yy26;
+      }
+    }
+  yy42:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy44;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy44;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy44;
+        goto yy26;
+      }
+    }
+  yy43:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy45;
+      if (yych <= '/')
+        goto yy26;
+      goto yy46;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy46;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy46;
+        goto yy26;
+      }
+    }
+  yy44:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy46;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy46;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy46;
+        goto yy26;
+      }
+    }
+  yy45:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy47;
+      if (yych <= '/')
+        goto yy26;
+      goto yy48;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy48;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy48;
+        goto yy26;
+      }
+    }
+  yy46:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy48;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy48;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy48;
+        goto yy26;
+      }
+    }
+  yy47:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy49;
+      if (yych <= '/')
+        goto yy26;
+      goto yy50;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy50;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy50;
+        goto yy26;
+      }
+    }
+  yy48:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy50;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy50;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy50;
+        goto yy26;
+      }
+    }
+  yy49:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy51;
+      if (yych <= '/')
+        goto yy26;
+      goto yy52;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy52;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy52;
+        goto yy26;
+      }
+    }
+  yy50:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy52;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy52;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy52;
+        goto yy26;
+      }
+    }
+  yy51:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy53;
+      if (yych <= '/')
+        goto yy26;
+      goto yy54;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy54;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy54;
+        goto yy26;
+      }
+    }
+  yy52:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy54;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy54;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy54;
+        goto yy26;
+      }
+    }
+  yy53:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy55;
+      if (yych <= '/')
+        goto yy26;
+      goto yy56;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy56;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy56;
+        goto yy26;
+      }
+    }
+  yy54:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy56;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy56;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy56;
+        goto yy26;
+      }
+    }
+  yy55:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy57;
+      if (yych <= '/')
+        goto yy26;
+      goto yy58;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy58;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy58;
+        goto yy26;
+      }
+    }
+  yy56:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy58;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy58;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy58;
+        goto yy26;
+      }
+    }
+  yy57:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy59;
+      if (yych <= '/')
+        goto yy26;
+      goto yy60;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy60;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy60;
+        goto yy26;
+      }
+    }
+  yy58:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy60;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy60;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy60;
+        goto yy26;
+      }
+    }
+  yy59:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy61;
+      if (yych <= '/')
+        goto yy26;
+      goto yy62;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy62;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy62;
+        goto yy26;
+      }
+    }
+  yy60:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy62;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy62;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy62;
+        goto yy26;
+      }
+    }
+  yy61:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy63;
+      if (yych <= '/')
+        goto yy26;
+      goto yy64;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy64;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy64;
+        goto yy26;
+      }
+    }
+  yy62:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy64;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy64;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy64;
+        goto yy26;
+      }
+    }
+  yy63:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy65;
+      if (yych <= '/')
+        goto yy26;
+      goto yy66;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy66;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy66;
+        goto yy26;
+      }
+    }
+  yy64:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy66;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy66;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy66;
+        goto yy26;
+      }
+    }
+  yy65:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy67;
+      if (yych <= '/')
+        goto yy26;
+      goto yy68;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy68;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy68;
+        goto yy26;
+      }
+    }
+  yy66:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy68;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy68;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy68;
+        goto yy26;
+      }
+    }
+  yy67:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy69;
+      if (yych <= '/')
+        goto yy26;
+      goto yy70;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy70;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy70;
+        goto yy26;
+      }
+    }
+  yy68:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy70;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy70;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy70;
+        goto yy26;
+      }
+    }
+  yy69:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy71;
+      if (yych <= '/')
+        goto yy26;
+      goto yy72;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy72;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy72;
+        goto yy26;
+      }
+    }
+  yy70:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy72;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy72;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy72;
+        goto yy26;
+      }
+    }
+  yy71:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy73;
+      if (yych <= '/')
+        goto yy26;
+      goto yy74;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy74;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy74;
+        goto yy26;
+      }
+    }
+  yy72:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy74;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy74;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy74;
+        goto yy26;
+      }
+    }
+  yy73:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy75;
+      if (yych <= '/')
+        goto yy26;
+      goto yy76;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy76;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy76;
+        goto yy26;
+      }
+    }
+  yy74:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy76;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy76;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy76;
+        goto yy26;
+      }
+    }
+  yy75:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy77;
+      if (yych <= '/')
+        goto yy26;
+      goto yy78;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy78;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy78;
+        goto yy26;
+      }
+    }
+  yy76:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy78;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy78;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy78;
+        goto yy26;
+      }
+    }
+  yy77:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy79;
+      if (yych <= '/')
+        goto yy26;
+      goto yy80;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy80;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy80;
+        goto yy26;
+      }
+    }
+  yy78:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy80;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy80;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy80;
+        goto yy26;
+      }
+    }
+  yy79:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy81;
+      if (yych <= '/')
+        goto yy26;
+      goto yy82;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy82;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy82;
+        goto yy26;
+      }
+    }
+  yy80:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy82;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy82;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy82;
+        goto yy26;
+      }
+    }
+  yy81:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy83;
+      if (yych <= '/')
+        goto yy26;
+      goto yy84;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy84;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy84;
+        goto yy26;
+      }
+    }
+  yy82:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy84;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy84;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy84;
+        goto yy26;
+      }
+    }
+  yy83:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy85;
+      if (yych <= '/')
+        goto yy26;
+      goto yy86;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy86;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy86;
+        goto yy26;
+      }
+    }
+  yy84:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy86;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy86;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy86;
+        goto yy26;
+      }
+    }
+  yy85:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy87;
+      if (yych <= '/')
+        goto yy26;
+      goto yy88;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy88;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy88;
+        goto yy26;
+      }
+    }
+  yy86:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy88;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy88;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy88;
+        goto yy26;
+      }
+    }
+  yy87:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy89;
+      if (yych <= '/')
+        goto yy26;
+      goto yy90;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy90;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy90;
+        goto yy26;
+      }
+    }
+  yy88:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy90;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy90;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy90;
+        goto yy26;
+      }
+    }
+  yy89:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy91;
+      if (yych <= '/')
+        goto yy26;
+      goto yy92;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy92;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy92;
+        goto yy26;
+      }
+    }
+  yy90:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy92;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy92;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy92;
+        goto yy26;
+      }
+    }
+  yy91:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy93;
+      if (yych <= '/')
+        goto yy26;
+      goto yy94;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy94;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy94;
+        goto yy26;
+      }
+    }
+  yy92:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy94;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy94;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy94;
+        goto yy26;
+      }
+    }
+  yy93:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy95;
+      if (yych <= '/')
+        goto yy26;
+      goto yy96;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy96;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy96;
+        goto yy26;
+      }
+    }
+  yy94:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy96;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy96;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy96;
+        goto yy26;
+      }
+    }
+  yy95:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy97;
+      if (yych <= '/')
+        goto yy26;
+      goto yy98;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy98;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy98;
+        goto yy26;
+      }
+    }
+  yy96:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy98;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy98;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy98;
+        goto yy26;
+      }
+    }
+  yy97:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy99;
+      if (yych <= '/')
+        goto yy26;
+      goto yy100;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy100;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy100;
+        goto yy26;
+      }
+    }
+  yy98:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy100;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy100;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy100;
+        goto yy26;
+      }
+    }
+  yy99:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy101;
+      if (yych <= '/')
+        goto yy26;
+      goto yy102;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy102;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy102;
+        goto yy26;
+      }
+    }
+  yy100:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy102;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy102;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy102;
+        goto yy26;
+      }
+    }
+  yy101:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy103;
+      if (yych <= '/')
+        goto yy26;
+      goto yy104;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy104;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy104;
+        goto yy26;
+      }
+    }
+  yy102:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy104;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy104;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy104;
+        goto yy26;
+      }
+    }
+  yy103:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy105;
+      if (yych <= '/')
+        goto yy26;
+      goto yy106;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy106;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy106;
+        goto yy26;
+      }
+    }
+  yy104:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy106;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy106;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy106;
+        goto yy26;
+      }
+    }
+  yy105:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy107;
+      if (yych <= '/')
+        goto yy26;
+      goto yy108;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy108;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy108;
+        goto yy26;
+      }
+    }
+  yy106:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy108;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy108;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy108;
+        goto yy26;
+      }
+    }
+  yy107:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy109;
+      if (yych <= '/')
+        goto yy26;
+      goto yy110;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy110;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy110;
+        goto yy26;
+      }
+    }
+  yy108:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy110;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy110;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy110;
+        goto yy26;
+      }
+    }
+  yy109:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy111;
+      if (yych <= '/')
+        goto yy26;
+      goto yy112;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy112;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy112;
+        goto yy26;
+      }
+    }
+  yy110:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy112;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy112;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy112;
+        goto yy26;
+      }
+    }
+  yy111:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy113;
+      if (yych <= '/')
+        goto yy26;
+      goto yy114;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy114;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy114;
+        goto yy26;
+      }
+    }
+  yy112:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy114;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy114;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy114;
+        goto yy26;
+      }
+    }
+  yy113:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy115;
+      if (yych <= '/')
+        goto yy26;
+      goto yy116;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy116;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy116;
+        goto yy26;
+      }
+    }
+  yy114:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy116;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy116;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy116;
+        goto yy26;
+      }
+    }
+  yy115:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy117;
+      if (yych <= '/')
+        goto yy26;
+      goto yy118;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy118;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy118;
+        goto yy26;
+      }
+    }
+  yy116:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy118;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy118;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy118;
+        goto yy26;
+      }
+    }
+  yy117:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy119;
+      if (yych <= '/')
+        goto yy26;
+      goto yy120;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy120;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy120;
+        goto yy26;
+      }
+    }
+  yy118:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy120;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy120;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy120;
+        goto yy26;
+      }
+    }
+  yy119:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy121;
+      if (yych <= '/')
+        goto yy26;
+      goto yy122;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy122;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy122;
+        goto yy26;
+      }
+    }
+  yy120:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy122;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy122;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy122;
+        goto yy26;
+      }
+    }
+  yy121:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy123;
+      if (yych <= '/')
+        goto yy26;
+      goto yy124;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy124;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy124;
+        goto yy26;
+      }
+    }
+  yy122:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy124;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy124;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy124;
+        goto yy26;
+      }
+    }
+  yy123:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy125;
+      if (yych <= '/')
+        goto yy26;
+      goto yy126;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy126;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy126;
+        goto yy26;
+      }
+    }
+  yy124:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy126;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy126;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy126;
+        goto yy26;
+      }
+    }
+  yy125:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy127;
+      if (yych <= '/')
+        goto yy26;
+      goto yy128;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy128;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy128;
+        goto yy26;
+      }
+    }
+  yy126:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy128;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy128;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy128;
+        goto yy26;
+      }
+    }
+  yy127:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy129;
+      if (yych <= '/')
+        goto yy26;
+      goto yy130;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy130;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy130;
+        goto yy26;
+      }
+    }
+  yy128:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy130;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy130;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy130;
+        goto yy26;
+      }
+    }
+  yy129:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy131;
+      if (yych <= '/')
+        goto yy26;
+      goto yy132;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy132;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy132;
+        goto yy26;
+      }
+    }
+  yy130:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy132;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy132;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy132;
+        goto yy26;
+      }
+    }
+  yy131:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy133;
+      if (yych <= '/')
+        goto yy26;
+      goto yy134;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy134;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy134;
+        goto yy26;
+      }
+    }
+  yy132:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy134;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy134;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy134;
+        goto yy26;
+      }
+    }
+  yy133:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy135;
+      if (yych <= '/')
+        goto yy26;
+      goto yy136;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy136;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy136;
+        goto yy26;
+      }
+    }
+  yy134:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy136;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy136;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy136;
+        goto yy26;
+      }
+    }
+  yy135:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy137;
+      if (yych <= '/')
+        goto yy26;
+      goto yy138;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy138;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy138;
+        goto yy26;
+      }
+    }
+  yy136:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy138;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy138;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy138;
+        goto yy26;
+      }
+    }
+  yy137:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy139;
+      if (yych <= '/')
+        goto yy26;
+      goto yy140;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy140;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy140;
+        goto yy26;
+      }
+    }
+  yy138:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy140;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy140;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy140;
+        goto yy26;
+      }
+    }
+  yy139:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy141;
+      if (yych <= '/')
+        goto yy26;
+      goto yy142;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy142;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy142;
+        goto yy26;
+      }
+    }
+  yy140:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy142;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy142;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy142;
+        goto yy26;
+      }
+    }
+  yy141:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy143;
+      if (yych <= '/')
+        goto yy26;
+      goto yy144;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy144;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy144;
+        goto yy26;
+      }
+    }
+  yy142:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy144;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy144;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy144;
+        goto yy26;
+      }
+    }
+  yy143:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy145;
+      if (yych <= '/')
+        goto yy26;
+      goto yy146;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy146;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy146;
+        goto yy26;
+      }
+    }
+  yy144:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy146;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy146;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy146;
+        goto yy26;
+      }
+    }
+  yy145:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy147;
+      if (yych <= '/')
+        goto yy26;
+      goto yy148;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy148;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy148;
+        goto yy26;
+      }
+    }
+  yy146:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy148;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy148;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy148;
+        goto yy26;
+      }
+    }
+  yy147:
+    yych = *++p;
+    if (yych <= '9') {
+      if (yych == '-')
+        goto yy149;
+      if (yych <= '/')
+        goto yy26;
+      goto yy150;
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '@')
+          goto yy26;
+        goto yy150;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy150;
+        goto yy26;
+      }
+    }
+  yy148:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= ',')
+          goto yy26;
+        if (yych >= '.')
+          goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych <= '9')
+          goto yy150;
+        goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+        goto yy150;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych <= 'z')
+          goto yy150;
+        goto yy26;
+      }
+    }
+  yy149:
+    yych = *++p;
+    if (yych <= '@') {
+      if (yych <= '/')
+        goto yy26;
+      if (yych <= '9')
+        goto yy151;
+      goto yy26;
+    } else {
+      if (yych <= 'Z')
+        goto yy151;
+      if (yych <= '`')
+        goto yy26;
+      if (yych <= 'z')
+        goto yy151;
+      goto yy26;
+    }
+  yy150:
+    yych = *++p;
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych <= '-')
+          goto yy26;
+        goto yy27;
+      } else {
+        if (yych <= '/')
+          goto yy26;
+        if (yych >= ':')
+          goto yy26;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy30;
+        if (yych <= '@')
+          goto yy26;
+      } else {
+        if (yych <= '`')
+          goto yy26;
+        if (yych >= '{')
+          goto yy26;
+      }
+    }
+  yy151:
+    yych = *++p;
+    if (yych == '.')
+      goto yy27;
+    if (yych == '>')
+      goto yy30;
+    goto yy26;
+  }
+}
+
+// Try to match an HTML tag after first <, returning num of chars matched.
+bufsize_t _scan_html_tag(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0,   224, 224, 224, 224, 224, 224, 224, 224, 200, 200, 200, 200, 200,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 200, 224, 128, 224, 224, 224, 224, 64,  224, 224,
+        224, 224, 224, 244, 240, 224, 244, 244, 244, 244, 244, 244, 244, 244,
+        244, 244, 240, 224, 192, 192, 192, 224, 224, 244, 244, 244, 244, 244,
+        244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244,
+        244, 244, 244, 244, 244, 244, 244, 224, 224, 224, 224, 240, 192, 244,
+        244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244,
+        244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224,
+    };
+    yych = *p;
+    if (yych <= '@') {
+      if (yych == '/')
+        goto yy155;
+    } else {
+      if (yych <= 'Z')
+        goto yy156;
+      if (yych <= '`')
+        goto yy153;
+      if (yych <= 'z')
+        goto yy156;
+    }
+  yy153:
+    ++p;
+  yy154 : { return 0; }
+  yy155:
+    yych = *(marker = ++p);
+    if (yych <= '@')
+      goto yy154;
+    if (yych <= 'Z')
+      goto yy157;
+    if (yych <= '`')
+      goto yy154;
+    if (yych <= 'z')
+      goto yy157;
+    goto yy154;
+  yy156:
+    yych = *(marker = ++p);
+    if (yych <= '.') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy154;
+        if (yych <= '\r')
+          goto yy161;
+        goto yy154;
+      } else {
+        if (yych <= ' ')
+          goto yy161;
+        if (yych == '-')
+          goto yy161;
+        goto yy154;
+      }
+    } else {
+      if (yych <= '@') {
+        if (yych <= '9')
+          goto yy161;
+        if (yych == '>')
+          goto yy161;
+        goto yy154;
+      } else {
+        if (yych <= 'Z')
+          goto yy161;
+        if (yych <= '`')
+          goto yy154;
+        if (yych <= 'z')
+          goto yy161;
+        goto yy154;
+      }
+    }
+  yy157:
+    yych = *++p;
+    if (yybm[0 + yych] & 4) {
+      goto yy157;
+    }
+    if (yych <= 0x1F) {
+      if (yych <= 0x08)
+        goto yy158;
+      if (yych <= '\r')
+        goto yy164;
+    } else {
+      if (yych <= ' ')
+        goto yy164;
+      if (yych == '>')
+        goto yy163;
+    }
+  yy158:
+    p = marker;
+    goto yy154;
+  yy159:
+    yych = *++p;
+    if (yybm[0 + yych] & 8) {
+      goto yy159;
+    }
+    if (yych <= '>') {
+      if (yych <= '9') {
+        if (yych == '/')
+          goto yy162;
+        goto yy158;
+      } else {
+        if (yych <= ':')
+          goto yy165;
+        if (yych <= '=')
+          goto yy158;
+        goto yy163;
+      }
+    } else {
+      if (yych <= '^') {
+        if (yych <= '@')
+          goto yy158;
+        if (yych <= 'Z')
+          goto yy165;
+        goto yy158;
+      } else {
+        if (yych == '`')
+          goto yy158;
+        if (yych <= 'z')
+          goto yy165;
+        goto yy158;
+      }
+    }
+  yy160:
+    yych = *++p;
+  yy161:
+    if (yybm[0 + yych] & 8) {
+      goto yy159;
+    }
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych == '-')
+          goto yy160;
+        goto yy158;
+      } else {
+        if (yych <= '/')
+          goto yy162;
+        if (yych <= '9')
+          goto yy160;
+        goto yy158;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy163;
+        if (yych <= '@')
+          goto yy158;
+        goto yy160;
+      } else {
+        if (yych <= '`')
+          goto yy158;
+        if (yych <= 'z')
+          goto yy160;
+        goto yy158;
+      }
+    }
+  yy162:
+    yych = *++p;
+    if (yych != '>')
+      goto yy158;
+  yy163:
+    ++p;
+    { return (bufsize_t)(p - start); }
+  yy164:
+    yych = *++p;
+    if (yych <= 0x1F) {
+      if (yych <= 0x08)
+        goto yy158;
+      if (yych <= '\r')
+        goto yy164;
+      goto yy158;
+    } else {
+      if (yych <= ' ')
+        goto yy164;
+      if (yych == '>')
+        goto yy163;
+      goto yy158;
+    }
+  yy165:
+    yych = *++p;
+    if (yybm[0 + yych] & 16) {
+      goto yy165;
+    }
+    if (yych <= ',') {
+      if (yych <= '\r') {
+        if (yych <= 0x08)
+          goto yy158;
+      } else {
+        if (yych != ' ')
+          goto yy158;
+      }
+    } else {
+      if (yych <= '<') {
+        if (yych <= '/')
+          goto yy162;
+        goto yy158;
+      } else {
+        if (yych <= '=')
+          goto yy167;
+        if (yych <= '>')
+          goto yy163;
+        goto yy158;
+      }
+    }
+  yy166:
+    yych = *++p;
+    if (yych <= '<') {
+      if (yych <= ' ') {
+        if (yych <= 0x08)
+          goto yy158;
+        if (yych <= '\r')
+          goto yy166;
+        if (yych <= 0x1F)
+          goto yy158;
+        goto yy166;
+      } else {
+        if (yych <= '/') {
+          if (yych <= '.')
+            goto yy158;
+          goto yy162;
+        } else {
+          if (yych == ':')
+            goto yy165;
+          goto yy158;
+        }
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '=')
+          goto yy167;
+        if (yych <= '>')
+          goto yy163;
+        if (yych <= '@')
+          goto yy158;
+        goto yy165;
+      } else {
+        if (yych <= '_') {
+          if (yych <= '^')
+            goto yy158;
+          goto yy165;
+        } else {
+          if (yych <= '`')
+            goto yy158;
+          if (yych <= 'z')
+            goto yy165;
+          goto yy158;
+        }
+      }
+    }
+  yy167:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy168;
+    }
+    if (yych <= 0x00)
+      goto yy158;
+    if (yych <= ' ')
+      goto yy167;
+    if (yych <= '"')
+      goto yy169;
+    if (yych <= '\'')
+      goto yy170;
+    goto yy158;
+  yy168:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy168;
+    }
+    if (yych <= 0x00)
+      goto yy158;
+    if (yych <= ' ')
+      goto yy159;
+    if (yych == '>')
+      goto yy163;
+    goto yy158;
+  yy169:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy169;
+    }
+    if (yych <= 0x00)
+      goto yy158;
+    goto yy171;
+  yy170:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy170;
+    }
+    if (yych <= 0x00)
+      goto yy158;
+  yy171:
+    yych = *++p;
+    if (yybm[0 + yych] & 8) {
+      goto yy159;
+    }
+    if (yych == '/')
+      goto yy162;
+    if (yych == '>')
+      goto yy163;
+    goto yy158;
+  }
+}
+
+bufsize_t _scan_html_comment(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0,   128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 0,   128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128,
+    };
+    yych = *p;
+    if (yych == '-')
+      goto yy174;
+    ++p;
+  yy173 : { return 0; }
+  yy174:
+    yych = *(marker = ++p);
+    if (yych != '-')
+      goto yy173;
+  yy175:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy175;
+    }
+    if (yych >= 0x01)
+      goto yy177;
+  yy176:
+    p = marker;
+    goto yy173;
+  yy177:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy175;
+    }
+    if (yych <= 0x00)
+      goto yy176;
+    yych = *++p;
+    if (yych <= 0x00)
+      goto yy176;
+    if (yych != '>')
+      goto yy175;
+    ++p;
+    { return (bufsize_t)(p - start); }
+  }
+}
+
+bufsize_t _scan_html_pi(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0,   128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 0,   128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128,
+    };
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy180;
+    }
+    if (yych >= 0x01)
+      goto yy182;
+    ++p;
+  yy179 : { return 0; }
+  yy180:
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 128) {
+      goto yy180;
+    }
+    if (yych >= 0x01)
+      goto yy183;
+  yy181 : { return (bufsize_t)(p - start); }
+  yy182:
+    yych = *++p;
+    if (yych <= 0x00)
+      goto yy179;
+    if (yych == '>')
+      goto yy179;
+    goto yy180;
+  yy183:
+    yych = *++p;
+    if (yych <= 0x00)
+      goto yy184;
+    if (yych != '>')
+      goto yy180;
+  yy184:
+    p = marker;
+    goto yy181;
+  }
+}
+
+bufsize_t _scan_html_declaration(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+  (void)marker;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0,   128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 0,   128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128,
+    };
+    yych = *p;
+    if (yych <= '@')
+      goto yy186;
+    if (yych <= 'Z')
+      goto yy187;
+    if (yych <= '`')
+      goto yy186;
+    if (yych <= 'z')
+      goto yy187;
+  yy186:
+    ++p;
+    { return 0; }
+  yy187:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy187;
+    }
+    { return (bufsize_t)(p - start); }
+  }
+}
+
+bufsize_t _scan_html_cdata(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,   128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 0,   128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128,
+    };
+    yych = *p;
+    if (yych == 'C')
+      goto yy190;
+    if (yych == 'c')
+      goto yy190;
+    ++p;
+  yy189 : { return 0; }
+  yy190:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych == 'D')
+      goto yy191;
+    if (yych != 'd')
+      goto yy189;
+  yy191:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy193;
+    if (yych == 'a')
+      goto yy193;
+  yy192:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy189;
+    } else {
+      goto yy197;
+    }
+  yy193:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy194;
+    if (yych != 't')
+      goto yy192;
+  yy194:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy195;
+    if (yych != 'a')
+      goto yy192;
+  yy195:
+    yych = *++p;
+    if (yych != '[')
+      goto yy192;
+  yy196:
+    yyaccept = 1;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 128) {
+      goto yy196;
+    }
+    if (yych >= 0x01)
+      goto yy198;
+  yy197 : { return (bufsize_t)(p - start); }
+  yy198:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy196;
+    }
+    if (yych <= 0x00)
+      goto yy192;
+    yych = *++p;
+    if (yych <= 0x00)
+      goto yy192;
+    if (yych == '>')
+      goto yy192;
+    goto yy196;
+  }
+}
+
+// Try to match an HTML block tag start line, returning
+// an integer code for the type of block (1-6, matching the spec).
+// #7 is handled by a separate function, below.
+bufsize_t _scan_html_block_start(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+
+  {
+    unsigned char yych;
+    yych = *p;
+    if (yych == '<')
+      goto yy201;
+    ++p;
+  yy200 : { return 0; }
+  yy201:
+    yych = *(marker = ++p);
+    switch (yych) {
+    case '!':
+      goto yy202;
+    case '/':
+      goto yy204;
+    case '?':
+      goto yy205;
+    case 'A':
+    case 'a':
+      goto yy206;
+    case 'B':
+    case 'b':
+      goto yy207;
+    case 'C':
+    case 'c':
+      goto yy208;
+    case 'D':
+    case 'd':
+      goto yy209;
+    case 'F':
+    case 'f':
+      goto yy210;
+    case 'H':
+    case 'h':
+      goto yy211;
+    case 'I':
+    case 'i':
+      goto yy212;
+    case 'L':
+    case 'l':
+      goto yy213;
+    case 'M':
+    case 'm':
+      goto yy214;
+    case 'N':
+    case 'n':
+      goto yy215;
+    case 'O':
+    case 'o':
+      goto yy216;
+    case 'P':
+    case 'p':
+      goto yy217;
+    case 'S':
+    case 's':
+      goto yy218;
+    case 'T':
+    case 't':
+      goto yy219;
+    case 'U':
+    case 'u':
+      goto yy220;
+    default:
+      goto yy200;
+    }
+  yy202:
+    yych = *++p;
+    if (yych <= 'Z') {
+      if (yych == '-')
+        goto yy221;
+      if (yych >= 'A')
+        goto yy222;
+    } else {
+      if (yych <= '[')
+        goto yy223;
+      if (yych <= '`')
+        goto yy203;
+      if (yych <= 'z')
+        goto yy222;
+    }
+  yy203:
+    p = marker;
+    goto yy200;
+  yy204:
+    yych = *++p;
+    switch (yych) {
+    case 'A':
+    case 'a':
+      goto yy206;
+    case 'B':
+    case 'b':
+      goto yy207;
+    case 'C':
+    case 'c':
+      goto yy208;
+    case 'D':
+    case 'd':
+      goto yy209;
+    case 'F':
+    case 'f':
+      goto yy210;
+    case 'H':
+    case 'h':
+      goto yy211;
+    case 'I':
+    case 'i':
+      goto yy212;
+    case 'L':
+    case 'l':
+      goto yy213;
+    case 'M':
+    case 'm':
+      goto yy214;
+    case 'N':
+    case 'n':
+      goto yy215;
+    case 'O':
+    case 'o':
+      goto yy216;
+    case 'P':
+    case 'p':
+      goto yy224;
+    case 'S':
+    case 's':
+      goto yy225;
+    case 'T':
+    case 't':
+      goto yy226;
+    case 'U':
+    case 'u':
+      goto yy220;
+    default:
+      goto yy203;
+    }
+  yy205:
+    ++p;
+    { return 3; }
+  yy206:
+    yych = *++p;
+    if (yych <= 'S') {
+      if (yych <= 'D') {
+        if (yych <= 'C')
+          goto yy203;
+        goto yy227;
+      } else {
+        if (yych <= 'Q')
+          goto yy203;
+        if (yych <= 'R')
+          goto yy228;
+        goto yy229;
+      }
+    } else {
+      if (yych <= 'q') {
+        if (yych == 'd')
+          goto yy227;
+        goto yy203;
+      } else {
+        if (yych <= 'r')
+          goto yy228;
+        if (yych <= 's')
+          goto yy229;
+        goto yy203;
+      }
+    }
+  yy207:
+    yych = *++p;
+    if (yych <= 'O') {
+      if (yych <= 'K') {
+        if (yych == 'A')
+          goto yy230;
+        goto yy203;
+      } else {
+        if (yych <= 'L')
+          goto yy231;
+        if (yych <= 'N')
+          goto yy203;
+        goto yy232;
+      }
+    } else {
+      if (yych <= 'k') {
+        if (yych == 'a')
+          goto yy230;
+        goto yy203;
+      } else {
+        if (yych <= 'l')
+          goto yy231;
+        if (yych == 'o')
+          goto yy232;
+        goto yy203;
+      }
+    }
+  yy208:
+    yych = *++p;
+    if (yych <= 'O') {
+      if (yych <= 'D') {
+        if (yych == 'A')
+          goto yy233;
+        goto yy203;
+      } else {
+        if (yych <= 'E')
+          goto yy234;
+        if (yych <= 'N')
+          goto yy203;
+        goto yy235;
+      }
+    } else {
+      if (yych <= 'd') {
+        if (yych == 'a')
+          goto yy233;
+        goto yy203;
+      } else {
+        if (yych <= 'e')
+          goto yy234;
+        if (yych == 'o')
+          goto yy235;
+        goto yy203;
+      }
+    }
+  yy209:
+    yych = *++p;
+    switch (yych) {
+    case 'D':
+    case 'L':
+    case 'T':
+    case 'd':
+    case 'l':
+    case 't':
+      goto yy236;
+    case 'E':
+    case 'e':
+      goto yy237;
+    case 'I':
+    case 'i':
+      goto yy238;
+    default:
+      goto yy203;
+    }
+  yy210:
+    yych = *++p;
+    if (yych <= 'R') {
+      if (yych <= 'N') {
+        if (yych == 'I')
+          goto yy239;
+        goto yy203;
+      } else {
+        if (yych <= 'O')
+          goto yy240;
+        if (yych <= 'Q')
+          goto yy203;
+        goto yy241;
+      }
+    } else {
+      if (yych <= 'n') {
+        if (yych == 'i')
+          goto yy239;
+        goto yy203;
+      } else {
+        if (yych <= 'o')
+          goto yy240;
+        if (yych == 'r')
+          goto yy241;
+        goto yy203;
+      }
+    }
+  yy211:
+    yych = *++p;
+    if (yych <= 'S') {
+      if (yych <= 'D') {
+        if (yych <= '0')
+          goto yy203;
+        if (yych <= '6')
+          goto yy236;
+        goto yy203;
+      } else {
+        if (yych <= 'E')
+          goto yy242;
+        if (yych == 'R')
+          goto yy236;
+        goto yy203;
+      }
+    } else {
+      if (yych <= 'q') {
+        if (yych <= 'T')
+          goto yy243;
+        if (yych == 'e')
+          goto yy242;
+        goto yy203;
+      } else {
+        if (yych <= 'r')
+          goto yy236;
+        if (yych == 't')
+          goto yy243;
+        goto yy203;
+      }
+    }
+  yy212:
+    yych = *++p;
+    if (yych == 'F')
+      goto yy244;
+    if (yych == 'f')
+      goto yy244;
+    goto yy203;
+  yy213:
+    yych = *++p;
+    if (yych <= 'I') {
+      if (yych == 'E')
+        goto yy245;
+      if (yych <= 'H')
+        goto yy203;
+      goto yy246;
+    } else {
+      if (yych <= 'e') {
+        if (yych <= 'd')
+          goto yy203;
+        goto yy245;
+      } else {
+        if (yych == 'i')
+          goto yy246;
+        goto yy203;
+      }
+    }
+  yy214:
+    yych = *++p;
+    if (yych <= 'E') {
+      if (yych == 'A')
+        goto yy247;
+      if (yych <= 'D')
+        goto yy203;
+      goto yy248;
+    } else {
+      if (yych <= 'a') {
+        if (yych <= '`')
+          goto yy203;
+        goto yy247;
+      } else {
+        if (yych == 'e')
+          goto yy248;
+        goto yy203;
+      }
+    }
+  yy215:
+    yych = *++p;
+    if (yych <= 'O') {
+      if (yych == 'A')
+        goto yy249;
+      if (yych <= 'N')
+        goto yy203;
+      goto yy250;
+    } else {
+      if (yych <= 'a') {
+        if (yych <= '`')
+          goto yy203;
+        goto yy249;
+      } else {
+        if (yych == 'o')
+          goto yy250;
+        goto yy203;
+      }
+    }
+  yy216:
+    yych = *++p;
+    if (yych <= 'P') {
+      if (yych == 'L')
+        goto yy236;
+      if (yych <= 'O')
+        goto yy203;
+      goto yy251;
+    } else {
+      if (yych <= 'l') {
+        if (yych <= 'k')
+          goto yy203;
+        goto yy236;
+      } else {
+        if (yych == 'p')
+          goto yy251;
+        goto yy203;
+      }
+    }
+  yy217:
+    yych = *++p;
+    if (yych <= '>') {
+      if (yych <= ' ') {
+        if (yych <= 0x08)
+          goto yy203;
+        if (yych <= '\r')
+          goto yy252;
+        if (yych <= 0x1F)
+          goto yy203;
+        goto yy252;
+      } else {
+        if (yych == '/')
+          goto yy253;
+        if (yych <= '=')
+          goto yy203;
+        goto yy252;
+      }
+    } else {
+      if (yych <= 'R') {
+        if (yych == 'A')
+          goto yy254;
+        if (yych <= 'Q')
+          goto yy203;
+        goto yy255;
+      } else {
+        if (yych <= 'a') {
+          if (yych <= '`')
+            goto yy203;
+          goto yy254;
+        } else {
+          if (yych == 'r')
+            goto yy255;
+          goto yy203;
+        }
+      }
+    }
+  yy218:
+    yych = *++p;
+    if (yych <= 'U') {
+      if (yych <= 'D') {
+        if (yych == 'C')
+          goto yy256;
+        goto yy203;
+      } else {
+        if (yych <= 'E')
+          goto yy257;
+        if (yych <= 'S')
+          goto yy203;
+        if (yych <= 'T')
+          goto yy258;
+        goto yy259;
+      }
+    } else {
+      if (yych <= 'e') {
+        if (yych == 'c')
+          goto yy256;
+        if (yych <= 'd')
+          goto yy203;
+        goto yy257;
+      } else {
+        if (yych <= 's')
+          goto yy203;
+        if (yych <= 't')
+          goto yy258;
+        if (yych <= 'u')
+          goto yy259;
+        goto yy203;
+      }
+    }
+  yy219:
+    yych = *++p;
+    switch (yych) {
+    case 'A':
+    case 'a':
+      goto yy260;
+    case 'B':
+    case 'b':
+      goto yy261;
+    case 'D':
+    case 'd':
+      goto yy236;
+    case 'E':
+    case 'e':
+      goto yy262;
+    case 'F':
+    case 'f':
+      goto yy263;
+    case 'H':
+    case 'h':
+      goto yy264;
+    case 'I':
+    case 'i':
+      goto yy265;
+    case 'R':
+    case 'r':
+      goto yy266;
+    default:
+      goto yy203;
+    }
+  yy220:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy236;
+    if (yych == 'l')
+      goto yy236;
+    goto yy203;
+  yy221:
+    yych = *++p;
+    if (yych == '-')
+      goto yy267;
+    goto yy203;
+  yy222:
+    ++p;
+    { return 4; }
+  yy223:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy268;
+    if (yych == 'c')
+      goto yy268;
+    goto yy203;
+  yy224:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy203;
+        if (yych <= '\r')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= ' ')
+          goto yy252;
+        if (yych <= '.')
+          goto yy203;
+        goto yy253;
+      }
+    } else {
+      if (yych <= '@') {
+        if (yych == '>')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= 'A')
+          goto yy254;
+        if (yych == 'a')
+          goto yy254;
+        goto yy203;
+      }
+    }
+  yy225:
+    yych = *++p;
+    if (yych <= 'U') {
+      if (yych == 'E')
+        goto yy257;
+      if (yych <= 'T')
+        goto yy203;
+      goto yy259;
+    } else {
+      if (yych <= 'e') {
+        if (yych <= 'd')
+          goto yy203;
+        goto yy257;
+      } else {
+        if (yych == 'u')
+          goto yy259;
+        goto yy203;
+      }
+    }
+  yy226:
+    yych = *++p;
+    switch (yych) {
+    case 'A':
+    case 'a':
+      goto yy260;
+    case 'B':
+    case 'b':
+      goto yy261;
+    case 'D':
+    case 'd':
+      goto yy236;
+    case 'F':
+    case 'f':
+      goto yy263;
+    case 'H':
+    case 'h':
+      goto yy264;
+    case 'I':
+    case 'i':
+      goto yy265;
+    case 'R':
+    case 'r':
+      goto yy266;
+    default:
+      goto yy203;
+    }
+  yy227:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy269;
+    if (yych == 'd')
+      goto yy269;
+    goto yy203;
+  yy228:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy270;
+    if (yych == 't')
+      goto yy270;
+    goto yy203;
+  yy229:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy271;
+    if (yych == 'i')
+      goto yy271;
+    goto yy203;
+  yy230:
+    yych = *++p;
+    if (yych == 'S')
+      goto yy272;
+    if (yych == 's')
+      goto yy272;
+    goto yy203;
+  yy231:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy273;
+    if (yych == 'o')
+      goto yy273;
+    goto yy203;
+  yy232:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy274;
+    if (yych == 'd')
+      goto yy274;
+    goto yy203;
+  yy233:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy275;
+    if (yych == 'p')
+      goto yy275;
+    goto yy203;
+  yy234:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy276;
+    if (yych == 'n')
+      goto yy276;
+    goto yy203;
+  yy235:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy277;
+    if (yych == 'l')
+      goto yy277;
+    goto yy203;
+  yy236:
+    yych = *++p;
+    if (yych <= ' ') {
+      if (yych <= 0x08)
+        goto yy203;
+      if (yych <= '\r')
+        goto yy252;
+      if (yych <= 0x1F)
+        goto yy203;
+      goto yy252;
+    } else {
+      if (yych <= '/') {
+        if (yych <= '.')
+          goto yy203;
+        goto yy253;
+      } else {
+        if (yych == '>')
+          goto yy252;
+        goto yy203;
+      }
+    }
+  yy237:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy278;
+    if (yych == 't')
+      goto yy278;
+    goto yy203;
+  yy238:
+    yych = *++p;
+    if (yych <= 'V') {
+      if (yych <= 'Q') {
+        if (yych == 'A')
+          goto yy279;
+        goto yy203;
+      } else {
+        if (yych <= 'R')
+          goto yy236;
+        if (yych <= 'U')
+          goto yy203;
+        goto yy236;
+      }
+    } else {
+      if (yych <= 'q') {
+        if (yych == 'a')
+          goto yy279;
+        goto yy203;
+      } else {
+        if (yych <= 'r')
+          goto yy236;
+        if (yych == 'v')
+          goto yy236;
+        goto yy203;
+      }
+    }
+  yy239:
+    yych = *++p;
+    if (yych <= 'G') {
+      if (yych == 'E')
+        goto yy280;
+      if (yych <= 'F')
+        goto yy203;
+      goto yy281;
+    } else {
+      if (yych <= 'e') {
+        if (yych <= 'd')
+          goto yy203;
+        goto yy280;
+      } else {
+        if (yych == 'g')
+          goto yy281;
+        goto yy203;
+      }
+    }
+  yy240:
+    yych = *++p;
+    if (yych <= 'R') {
+      if (yych == 'O')
+        goto yy276;
+      if (yych <= 'Q')
+        goto yy203;
+      goto yy282;
+    } else {
+      if (yych <= 'o') {
+        if (yych <= 'n')
+          goto yy203;
+        goto yy276;
+      } else {
+        if (yych == 'r')
+          goto yy282;
+        goto yy203;
+      }
+    }
+  yy241:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy283;
+    if (yych == 'a')
+      goto yy283;
+    goto yy203;
+  yy242:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy284;
+    if (yych == 'a')
+      goto yy284;
+    goto yy203;
+  yy243:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy220;
+    if (yych == 'm')
+      goto yy220;
+    goto yy203;
+  yy244:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy285;
+    if (yych == 'r')
+      goto yy285;
+    goto yy203;
+  yy245:
+    yych = *++p;
+    if (yych == 'G')
+      goto yy286;
+    if (yych == 'g')
+      goto yy286;
+    goto yy203;
+  yy246:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy203;
+        if (yych <= '\r')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= ' ')
+          goto yy252;
+        if (yych <= '.')
+          goto yy203;
+        goto yy253;
+      }
+    } else {
+      if (yych <= 'M') {
+        if (yych == '>')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= 'N')
+          goto yy287;
+        if (yych == 'n')
+          goto yy287;
+        goto yy203;
+      }
+    }
+  yy247:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy288;
+    if (yych == 'i')
+      goto yy288;
+    goto yy203;
+  yy248:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy289;
+    if (yych == 'n')
+      goto yy289;
+    goto yy203;
+  yy249:
+    yych = *++p;
+    if (yych == 'V')
+      goto yy236;
+    if (yych == 'v')
+      goto yy236;
+    goto yy203;
+  yy250:
+    yych = *++p;
+    if (yych == 'F')
+      goto yy290;
+    if (yych == 'f')
+      goto yy290;
+    goto yy203;
+  yy251:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy291;
+    if (yych == 't')
+      goto yy291;
+    goto yy203;
+  yy252:
+    ++p;
+    { return 6; }
+  yy253:
+    yych = *++p;
+    if (yych == '>')
+      goto yy252;
+    goto yy203;
+  yy254:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy292;
+    if (yych == 'r')
+      goto yy292;
+    goto yy203;
+  yy255:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy293;
+    if (yych == 'e')
+      goto yy293;
+    goto yy203;
+  yy256:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy294;
+    if (yych == 'r')
+      goto yy294;
+    goto yy203;
+  yy257:
+    yych = *++p;
+    if (yych <= 'C') {
+      if (yych == 'A')
+        goto yy295;
+      if (yych <= 'B')
+        goto yy203;
+      goto yy275;
+    } else {
+      if (yych <= 'a') {
+        if (yych <= '`')
+          goto yy203;
+        goto yy295;
+      } else {
+        if (yych == 'c')
+          goto yy275;
+        goto yy203;
+      }
+    }
+  yy258:
+    yych = *++p;
+    if (yych == 'Y')
+      goto yy296;
+    if (yych == 'y')
+      goto yy296;
+    goto yy203;
+  yy259:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy297;
+    if (yych == 'm')
+      goto yy297;
+    goto yy203;
+  yy260:
+    yych = *++p;
+    if (yych == 'B')
+      goto yy298;
+    if (yych == 'b')
+      goto yy298;
+    goto yy203;
+  yy261:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy232;
+    if (yych == 'o')
+      goto yy232;
+    goto yy203;
+  yy262:
+    yych = *++p;
+    if (yych == 'X')
+      goto yy299;
+    if (yych == 'x')
+      goto yy299;
+    goto yy203;
+  yy263:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy300;
+    if (yych == 'o')
+      goto yy300;
+    goto yy203;
+  yy264:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy203;
+        if (yych <= '\r')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= ' ')
+          goto yy252;
+        if (yych <= '.')
+          goto yy203;
+        goto yy253;
+      }
+    } else {
+      if (yych <= 'D') {
+        if (yych == '>')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= 'E')
+          goto yy301;
+        if (yych == 'e')
+          goto yy301;
+        goto yy203;
+      }
+    }
+  yy265:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy298;
+    if (yych == 't')
+      goto yy298;
+    goto yy203;
+  yy266:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy203;
+        if (yych <= '\r')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= ' ')
+          goto yy252;
+        if (yych <= '.')
+          goto yy203;
+        goto yy253;
+      }
+    } else {
+      if (yych <= '@') {
+        if (yych == '>')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= 'A')
+          goto yy302;
+        if (yych == 'a')
+          goto yy302;
+        goto yy203;
+      }
+    }
+  yy267:
+    ++p;
+    { return 2; }
+  yy268:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy303;
+    if (yych == 'd')
+      goto yy303;
+    goto yy203;
+  yy269:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy304;
+    if (yych == 'r')
+      goto yy304;
+    goto yy203;
+  yy270:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy305;
+    if (yych == 'i')
+      goto yy305;
+    goto yy203;
+  yy271:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy306;
+    if (yych == 'd')
+      goto yy306;
+    goto yy203;
+  yy272:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy307;
+    if (yych == 'e')
+      goto yy307;
+    goto yy203;
+  yy273:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy308;
+    if (yych == 'c')
+      goto yy308;
+    goto yy203;
+  yy274:
+    yych = *++p;
+    if (yych == 'Y')
+      goto yy236;
+    if (yych == 'y')
+      goto yy236;
+    goto yy203;
+  yy275:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy309;
+    if (yych == 't')
+      goto yy309;
+    goto yy203;
+  yy276:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy310;
+    if (yych == 't')
+      goto yy310;
+    goto yy203;
+  yy277:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy203;
+        if (yych <= '\r')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= ' ')
+          goto yy252;
+        if (yych <= '.')
+          goto yy203;
+        goto yy253;
+      }
+    } else {
+      if (yych <= 'F') {
+        if (yych == '>')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= 'G')
+          goto yy311;
+        if (yych == 'g')
+          goto yy311;
+        goto yy203;
+      }
+    }
+  yy278:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy312;
+    if (yych == 'a')
+      goto yy312;
+    goto yy203;
+  yy279:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy313;
+    if (yych == 'l')
+      goto yy313;
+    goto yy203;
+  yy280:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy314;
+    if (yych == 'l')
+      goto yy314;
+    goto yy203;
+  yy281:
+    yych = *++p;
+    if (yych <= 'U') {
+      if (yych == 'C')
+        goto yy315;
+      if (yych <= 'T')
+        goto yy203;
+      goto yy316;
+    } else {
+      if (yych <= 'c') {
+        if (yych <= 'b')
+          goto yy203;
+        goto yy315;
+      } else {
+        if (yych == 'u')
+          goto yy316;
+        goto yy203;
+      }
+    }
+  yy282:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy236;
+    if (yych == 'm')
+      goto yy236;
+    goto yy203;
+  yy283:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy317;
+    if (yych == 'm')
+      goto yy317;
+    goto yy203;
+  yy284:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy318;
+    if (yych == 'd')
+      goto yy318;
+    goto yy203;
+  yy285:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy319;
+    if (yych == 'a')
+      goto yy319;
+    goto yy203;
+  yy286:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy320;
+    if (yych == 'e')
+      goto yy320;
+    goto yy203;
+  yy287:
+    yych = *++p;
+    if (yych == 'K')
+      goto yy236;
+    if (yych == 'k')
+      goto yy236;
+    goto yy203;
+  yy288:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy236;
+    if (yych == 'n')
+      goto yy236;
+    goto yy203;
+  yy289:
+    yych = *++p;
+    if (yych == 'U')
+      goto yy321;
+    if (yych == 'u')
+      goto yy321;
+    goto yy203;
+  yy290:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy322;
+    if (yych == 'r')
+      goto yy322;
+    goto yy203;
+  yy291:
+    yych = *++p;
+    if (yych <= 'I') {
+      if (yych == 'G')
+        goto yy311;
+      if (yych <= 'H')
+        goto yy203;
+      goto yy323;
+    } else {
+      if (yych <= 'g') {
+        if (yych <= 'f')
+          goto yy203;
+        goto yy311;
+      } else {
+        if (yych == 'i')
+          goto yy323;
+        goto yy203;
+      }
+    }
+  yy292:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy282;
+    if (yych == 'a')
+      goto yy282;
+    goto yy203;
+  yy293:
+    yych = *++p;
+    if (yych <= 0x1F) {
+      if (yych <= 0x08)
+        goto yy203;
+      if (yych <= '\r')
+        goto yy324;
+      goto yy203;
+    } else {
+      if (yych <= ' ')
+        goto yy324;
+      if (yych == '>')
+        goto yy324;
+      goto yy203;
+    }
+  yy294:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy325;
+    if (yych == 'i')
+      goto yy325;
+    goto yy203;
+  yy295:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy326;
+    if (yych == 'r')
+      goto yy326;
+    goto yy203;
+  yy296:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy255;
+    if (yych == 'l')
+      goto yy255;
+    goto yy203;
+  yy297:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy327;
+    if (yych == 'm')
+      goto yy327;
+    goto yy203;
+  yy298:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy306;
+    if (yych == 'l')
+      goto yy306;
+    goto yy203;
+  yy299:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy328;
+    if (yych == 't')
+      goto yy328;
+    goto yy203;
+  yy300:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy329;
+    if (yych == 'o')
+      goto yy329;
+    goto yy203;
+  yy301:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy330;
+    if (yych == 'a')
+      goto yy330;
+    goto yy203;
+  yy302:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy287;
+    if (yych == 'c')
+      goto yy287;
+    goto yy203;
+  yy303:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy331;
+    if (yych == 'a')
+      goto yy331;
+    goto yy203;
+  yy304:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy332;
+    if (yych == 'e')
+      goto yy332;
+    goto yy203;
+  yy305:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy298;
+    if (yych == 'c')
+      goto yy298;
+    goto yy203;
+  yy306:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy236;
+    if (yych == 'e')
+      goto yy236;
+    goto yy203;
+  yy307:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy203;
+        if (yych <= '\r')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= ' ')
+          goto yy252;
+        if (yych <= '.')
+          goto yy203;
+        goto yy253;
+      }
+    } else {
+      if (yych <= 'E') {
+        if (yych == '>')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= 'F')
+          goto yy333;
+        if (yych == 'f')
+          goto yy333;
+        goto yy203;
+      }
+    }
+  yy308:
+    yych = *++p;
+    if (yych == 'K')
+      goto yy334;
+    if (yych == 'k')
+      goto yy334;
+    goto yy203;
+  yy309:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy323;
+    if (yych == 'i')
+      goto yy323;
+    goto yy203;
+  yy310:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy335;
+    if (yych == 'e')
+      goto yy335;
+    goto yy203;
+  yy311:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy336;
+    if (yych == 'r')
+      goto yy336;
+    goto yy203;
+  yy312:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy337;
+    if (yych == 'i')
+      goto yy337;
+    goto yy203;
+  yy313:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy338;
+    if (yych == 'o')
+      goto yy338;
+    goto yy203;
+  yy314:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy339;
+    if (yych == 'd')
+      goto yy339;
+    goto yy203;
+  yy315:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy233;
+    if (yych == 'a')
+      goto yy233;
+    goto yy203;
+  yy316:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy306;
+    if (yych == 'r')
+      goto yy306;
+    goto yy203;
+  yy317:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy340;
+    if (yych == 'e')
+      goto yy340;
+    goto yy203;
+  yy318:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy203;
+        if (yych <= '\r')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= ' ')
+          goto yy252;
+        if (yych <= '.')
+          goto yy203;
+        goto yy253;
+      }
+    } else {
+      if (yych <= 'D') {
+        if (yych == '>')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= 'E')
+          goto yy335;
+        if (yych == 'e')
+          goto yy335;
+        goto yy203;
+      }
+    }
+  yy319:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy306;
+    if (yych == 'm')
+      goto yy306;
+    goto yy203;
+  yy320:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy330;
+    if (yych == 'n')
+      goto yy330;
+    goto yy203;
+  yy321:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy203;
+        if (yych <= '\r')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= ' ')
+          goto yy252;
+        if (yych <= '.')
+          goto yy203;
+        goto yy253;
+      }
+    } else {
+      if (yych <= 'H') {
+        if (yych == '>')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= 'I')
+          goto yy341;
+        if (yych == 'i')
+          goto yy341;
+        goto yy203;
+      }
+    }
+  yy322:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy342;
+    if (yych == 'a')
+      goto yy342;
+    goto yy203;
+  yy323:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy288;
+    if (yych == 'o')
+      goto yy288;
+    goto yy203;
+  yy324:
+    ++p;
+    { return 1; }
+  yy325:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy343;
+    if (yych == 'p')
+      goto yy343;
+    goto yy203;
+  yy326:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy344;
+    if (yych == 'c')
+      goto yy344;
+    goto yy203;
+  yy327:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy345;
+    if (yych == 'a')
+      goto yy345;
+    goto yy203;
+  yy328:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy346;
+    if (yych == 'a')
+      goto yy346;
+    goto yy203;
+  yy329:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy236;
+    if (yych == 't')
+      goto yy236;
+    goto yy203;
+  yy330:
+    yych = *++p;
+    if (yych == 'D')
+      goto yy236;
+    if (yych == 'd')
+      goto yy236;
+    goto yy203;
+  yy331:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy347;
+    if (yych == 't')
+      goto yy347;
+    goto yy203;
+  yy332:
+    yych = *++p;
+    if (yych == 'S')
+      goto yy348;
+    if (yych == 's')
+      goto yy348;
+    goto yy203;
+  yy333:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy349;
+    if (yych == 'o')
+      goto yy349;
+    goto yy203;
+  yy334:
+    yych = *++p;
+    if (yych == 'Q')
+      goto yy350;
+    if (yych == 'q')
+      goto yy350;
+    goto yy203;
+  yy335:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy236;
+    if (yych == 'r')
+      goto yy236;
+    goto yy203;
+  yy336:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy351;
+    if (yych == 'o')
+      goto yy351;
+    goto yy203;
+  yy337:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy348;
+    if (yych == 'l')
+      goto yy348;
+    goto yy203;
+  yy338:
+    yych = *++p;
+    if (yych == 'G')
+      goto yy236;
+    if (yych == 'g')
+      goto yy236;
+    goto yy203;
+  yy339:
+    yych = *++p;
+    if (yych == 'S')
+      goto yy352;
+    if (yych == 's')
+      goto yy352;
+    goto yy203;
+  yy340:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy203;
+        if (yych <= '\r')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= ' ')
+          goto yy252;
+        if (yych <= '.')
+          goto yy203;
+        goto yy253;
+      }
+    } else {
+      if (yych <= 'R') {
+        if (yych == '>')
+          goto yy252;
+        goto yy203;
+      } else {
+        if (yych <= 'S')
+          goto yy352;
+        if (yych == 's')
+          goto yy352;
+        goto yy203;
+      }
+    }
+  yy341:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy353;
+    if (yych == 't')
+      goto yy353;
+    goto yy203;
+  yy342:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy354;
+    if (yych == 'm')
+      goto yy354;
+    goto yy203;
+  yy343:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy293;
+    if (yych == 't')
+      goto yy293;
+    goto yy203;
+  yy344:
+    yych = *++p;
+    if (yych == 'H')
+      goto yy236;
+    if (yych == 'h')
+      goto yy236;
+    goto yy203;
+  yy345:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy274;
+    if (yych == 'r')
+      goto yy274;
+    goto yy203;
+  yy346:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy355;
+    if (yych == 'r')
+      goto yy355;
+    goto yy203;
+  yy347:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy356;
+    if (yych == 'a')
+      goto yy356;
+    goto yy203;
+  yy348:
+    yych = *++p;
+    if (yych == 'S')
+      goto yy236;
+    if (yych == 's')
+      goto yy236;
+    goto yy203;
+  yy349:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy329;
+    if (yych == 'n')
+      goto yy329;
+    goto yy203;
+  yy350:
+    yych = *++p;
+    if (yych == 'U')
+      goto yy357;
+    if (yych == 'u')
+      goto yy357;
+    goto yy203;
+  yy351:
+    yych = *++p;
+    if (yych == 'U')
+      goto yy358;
+    if (yych == 'u')
+      goto yy358;
+    goto yy203;
+  yy352:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy329;
+    if (yych == 'e')
+      goto yy329;
+    goto yy203;
+  yy353:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy282;
+    if (yych == 'e')
+      goto yy282;
+    goto yy203;
+  yy354:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy348;
+    if (yych == 'e')
+      goto yy348;
+    goto yy203;
+  yy355:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy359;
+    if (yych == 'e')
+      goto yy359;
+    goto yy203;
+  yy356:
+    yych = *++p;
+    if (yych == '[')
+      goto yy360;
+    goto yy203;
+  yy357:
+    yych = *++p;
+    if (yych == 'O')
+      goto yy361;
+    if (yych == 'o')
+      goto yy361;
+    goto yy203;
+  yy358:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy236;
+    if (yych == 'p')
+      goto yy236;
+    goto yy203;
+  yy359:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy293;
+    if (yych == 'a')
+      goto yy293;
+    goto yy203;
+  yy360:
+    ++p;
+    { return 5; }
+  yy361:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy306;
+    if (yych == 't')
+      goto yy306;
+    goto yy203;
+  }
+}
+
+// Try to match an HTML block tag start line of type 7, returning
+// 7 if successful, 0 if not.
+bufsize_t _scan_html_block_start_7(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,   224, 224, 224, 224, 224, 224, 224, 224, 198, 210, 194, 198, 194,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 198, 224, 128, 224, 224, 224, 224, 64,  224, 224,
+        224, 224, 224, 233, 232, 224, 233, 233, 233, 233, 233, 233, 233, 233,
+        233, 233, 232, 224, 192, 192, 192, 224, 224, 233, 233, 233, 233, 233,
+        233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
+        233, 233, 233, 233, 233, 233, 233, 224, 224, 224, 224, 232, 192, 233,
+        233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
+        233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+        224, 224, 224, 224,
+    };
+    yych = *p;
+    if (yych == '<')
+      goto yy364;
+    ++p;
+  yy363 : { return 0; }
+  yy364:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '@') {
+      if (yych != '/')
+        goto yy363;
+    } else {
+      if (yych <= 'Z')
+        goto yy366;
+      if (yych <= '`')
+        goto yy363;
+      if (yych <= 'z')
+        goto yy366;
+      goto yy363;
+    }
+    yych = *++p;
+    if (yych <= '@')
+      goto yy365;
+    if (yych <= 'Z')
+      goto yy367;
+    if (yych <= '`')
+      goto yy365;
+    if (yych <= 'z')
+      goto yy367;
+  yy365:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy363;
+    } else {
+      goto yy374;
+    }
+  yy366:
+    yych = *++p;
+    if (yybm[0 + yych] & 2) {
+      goto yy368;
+    }
+    if (yych <= '=') {
+      if (yych <= '.') {
+        if (yych == '-')
+          goto yy366;
+        goto yy365;
+      } else {
+        if (yych <= '/')
+          goto yy369;
+        if (yych <= '9')
+          goto yy366;
+        goto yy365;
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '>')
+          goto yy370;
+        if (yych <= '@')
+          goto yy365;
+        goto yy366;
+      } else {
+        if (yych <= '`')
+          goto yy365;
+        if (yych <= 'z')
+          goto yy366;
+        goto yy365;
+      }
+    }
+  yy367:
+    yych = *++p;
+    if (yych <= '/') {
+      if (yych <= 0x1F) {
+        if (yych <= 0x08)
+          goto yy365;
+        if (yych <= '\r')
+          goto yy371;
+        goto yy365;
+      } else {
+        if (yych <= ' ')
+          goto yy371;
+        if (yych == '-')
+          goto yy367;
+        goto yy365;
+      }
+    } else {
+      if (yych <= '@') {
+        if (yych <= '9')
+          goto yy367;
+        if (yych == '>')
+          goto yy370;
+        goto yy365;
+      } else {
+        if (yych <= 'Z')
+          goto yy367;
+        if (yych <= '`')
+          goto yy365;
+        if (yych <= 'z')
+          goto yy367;
+        goto yy365;
+      }
+    }
+  yy368:
+    yych = *++p;
+    if (yybm[0 + yych] & 2) {
+      goto yy368;
+    }
+    if (yych <= '>') {
+      if (yych <= '9') {
+        if (yych != '/')
+          goto yy365;
+      } else {
+        if (yych <= ':')
+          goto yy372;
+        if (yych <= '=')
+          goto yy365;
+        goto yy370;
+      }
+    } else {
+      if (yych <= '^') {
+        if (yych <= '@')
+          goto yy365;
+        if (yych <= 'Z')
+          goto yy372;
+        goto yy365;
+      } else {
+        if (yych == '`')
+          goto yy365;
+        if (yych <= 'z')
+          goto yy372;
+        goto yy365;
+      }
+    }
+  yy369:
+    yych = *++p;
+    if (yych != '>')
+      goto yy365;
+  yy370:
+    yych = *++p;
+    if (yybm[0 + yych] & 4) {
+      goto yy370;
+    }
+    if (yych <= 0x08)
+      goto yy365;
+    if (yych <= '\n')
+      goto yy373;
+    if (yych <= '\v')
+      goto yy365;
+    if (yych <= '\r')
+      goto yy375;
+    goto yy365;
+  yy371:
+    yych = *++p;
+    if (yych <= 0x1F) {
+      if (yych <= 0x08)
+        goto yy365;
+      if (yych <= '\r')
+        goto yy371;
+      goto yy365;
+    } else {
+      if (yych <= ' ')
+        goto yy371;
+      if (yych == '>')
+        goto yy370;
+      goto yy365;
+    }
+  yy372:
+    yych = *++p;
+    if (yybm[0 + yych] & 8) {
+      goto yy372;
+    }
+    if (yych <= ',') {
+      if (yych <= '\r') {
+        if (yych <= 0x08)
+          goto yy365;
+        goto yy376;
+      } else {
+        if (yych == ' ')
+          goto yy376;
+        goto yy365;
+      }
+    } else {
+      if (yych <= '<') {
+        if (yych <= '/')
+          goto yy369;
+        goto yy365;
+      } else {
+        if (yych <= '=')
+          goto yy377;
+        if (yych <= '>')
+          goto yy370;
+        goto yy365;
+      }
+    }
+  yy373:
+    yyaccept = 1;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 4) {
+      goto yy370;
+    }
+    if (yych <= 0x08)
+      goto yy374;
+    if (yych <= '\n')
+      goto yy373;
+    if (yych <= '\v')
+      goto yy374;
+    if (yych <= '\r')
+      goto yy375;
+  yy374 : { return 7; }
+  yy375:
+    ++p;
+    goto yy374;
+  yy376:
+    yych = *++p;
+    if (yych <= '<') {
+      if (yych <= ' ') {
+        if (yych <= 0x08)
+          goto yy365;
+        if (yych <= '\r')
+          goto yy376;
+        if (yych <= 0x1F)
+          goto yy365;
+        goto yy376;
+      } else {
+        if (yych <= '/') {
+          if (yych <= '.')
+            goto yy365;
+          goto yy369;
+        } else {
+          if (yych == ':')
+            goto yy372;
+          goto yy365;
+        }
+      }
+    } else {
+      if (yych <= 'Z') {
+        if (yych <= '=')
+          goto yy377;
+        if (yych <= '>')
+          goto yy370;
+        if (yych <= '@')
+          goto yy365;
+        goto yy372;
+      } else {
+        if (yych <= '_') {
+          if (yych <= '^')
+            goto yy365;
+          goto yy372;
+        } else {
+          if (yych <= '`')
+            goto yy365;
+          if (yych <= 'z')
+            goto yy372;
+          goto yy365;
+        }
+      }
+    }
+  yy377:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy378;
+    }
+    if (yych <= 0x00)
+      goto yy365;
+    if (yych <= ' ')
+      goto yy377;
+    if (yych <= '"')
+      goto yy379;
+    if (yych <= '\'')
+      goto yy380;
+    goto yy365;
+  yy378:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy378;
+    }
+    if (yych <= 0x00)
+      goto yy365;
+    if (yych <= ' ')
+      goto yy368;
+    if (yych == '>')
+      goto yy370;
+    goto yy365;
+  yy379:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy379;
+    }
+    if (yych <= 0x00)
+      goto yy365;
+    goto yy381;
+  yy380:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy380;
+    }
+    if (yych <= 0x00)
+      goto yy365;
+  yy381:
+    yych = *++p;
+    if (yybm[0 + yych] & 2) {
+      goto yy368;
+    }
+    if (yych == '/')
+      goto yy369;
+    if (yych == '>')
+      goto yy370;
+    goto yy365;
+  }
+}
+
+// Try to match an HTML block end line of type 1
+bufsize_t _scan_html_block_end_1(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,  64, 64, 64, 64, 64, 64,  64, 64, 64, 0,  64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,
+    };
+    yych = *p;
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy383;
+      if (yych <= '\t')
+        goto yy385;
+    } else {
+      if (yych == '<')
+        goto yy386;
+      goto yy385;
+    }
+  yy383:
+    ++p;
+  yy384 : { return 0; }
+  yy385:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy384;
+    if (yych == '\n')
+      goto yy384;
+    goto yy388;
+  yy386:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy384;
+      if (yych <= '\t')
+        goto yy388;
+      goto yy384;
+    } else {
+      if (yych == '/')
+        goto yy391;
+      goto yy388;
+    }
+  yy387:
+    yych = *++p;
+  yy388:
+    if (yybm[0 + yych] & 64) {
+      goto yy387;
+    }
+    if (yych >= '\v')
+      goto yy390;
+  yy389:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy384;
+    } else {
+      goto yy404;
+    }
+  yy390:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych <= '\t')
+        goto yy387;
+      goto yy389;
+    } else {
+      if (yych != '/')
+        goto yy387;
+    }
+  yy391:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'S') {
+      if (yych <= '\n') {
+        if (yych <= 0x00)
+          goto yy389;
+        if (yych <= '\t')
+          goto yy387;
+        goto yy389;
+      } else {
+        if (yych == 'P')
+          goto yy392;
+        if (yych <= 'R')
+          goto yy387;
+        goto yy393;
+      }
+    } else {
+      if (yych <= 'p') {
+        if (yych <= 'T')
+          goto yy394;
+        if (yych <= 'o')
+          goto yy387;
+      } else {
+        if (yych <= 'r')
+          goto yy387;
+        if (yych <= 's')
+          goto yy393;
+        if (yych <= 't')
+          goto yy394;
+        goto yy387;
+      }
+    }
+  yy392:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'Q') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'R')
+        goto yy395;
+      if (yych == 'r')
+        goto yy395;
+      goto yy387;
+    }
+  yy393:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'S') {
+      if (yych <= '\n') {
+        if (yych <= 0x00)
+          goto yy389;
+        if (yych <= '\t')
+          goto yy387;
+        goto yy389;
+      } else {
+        if (yych == 'C')
+          goto yy396;
+        goto yy387;
+      }
+    } else {
+      if (yych <= 'c') {
+        if (yych <= 'T')
+          goto yy397;
+        if (yych <= 'b')
+          goto yy387;
+        goto yy396;
+      } else {
+        if (yych == 't')
+          goto yy397;
+        goto yy387;
+      }
+    }
+  yy394:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'D') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'E')
+        goto yy398;
+      if (yych == 'e')
+        goto yy398;
+      goto yy387;
+    }
+  yy395:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'D') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'E')
+        goto yy399;
+      if (yych == 'e')
+        goto yy399;
+      goto yy387;
+    }
+  yy396:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'Q') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'R')
+        goto yy400;
+      if (yych == 'r')
+        goto yy400;
+      goto yy387;
+    }
+  yy397:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'X') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'Y')
+        goto yy401;
+      if (yych == 'y')
+        goto yy401;
+      goto yy387;
+    }
+  yy398:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'W') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'X')
+        goto yy402;
+      if (yych == 'x')
+        goto yy402;
+      goto yy387;
+    }
+  yy399:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych <= '\t')
+        goto yy387;
+      goto yy389;
+    } else {
+      if (yych == '>')
+        goto yy403;
+      goto yy387;
+    }
+  yy400:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'H') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'I')
+        goto yy405;
+      if (yych == 'i')
+        goto yy405;
+      goto yy387;
+    }
+  yy401:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'K') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'L')
+        goto yy395;
+      if (yych == 'l')
+        goto yy395;
+      goto yy387;
+    }
+  yy402:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'S') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'T')
+        goto yy406;
+      if (yych == 't')
+        goto yy406;
+      goto yy387;
+    }
+  yy403:
+    yyaccept = 1;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 64) {
+      goto yy387;
+    }
+    if (yych >= '\v')
+      goto yy390;
+  yy404 : { return (bufsize_t)(p - start); }
+  yy405:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'O') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'P')
+        goto yy407;
+      if (yych == 'p')
+        goto yy407;
+      goto yy387;
+    }
+  yy406:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= '@') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'A')
+        goto yy408;
+      if (yych == 'a')
+        goto yy408;
+      goto yy387;
+    }
+  yy407:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'S') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'T')
+        goto yy399;
+      if (yych == 't')
+        goto yy399;
+      goto yy387;
+    }
+  yy408:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'Q') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'R')
+        goto yy409;
+      if (yych != 'r')
+        goto yy387;
+    }
+  yy409:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= 'D') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'E')
+        goto yy410;
+      if (yych != 'e')
+        goto yy387;
+    }
+  yy410:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy390;
+    }
+    if (yych <= '@') {
+      if (yych <= 0x00)
+        goto yy389;
+      if (yych == '\n')
+        goto yy389;
+      goto yy387;
+    } else {
+      if (yych <= 'A')
+        goto yy399;
+      if (yych == 'a')
+        goto yy399;
+      goto yy387;
+    }
+  }
+}
+
+// Try to match an HTML block end line of type 2
+bufsize_t _scan_html_block_end_2(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,  64, 64, 64, 64, 64, 64, 64, 64, 64,  0,  64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,
+    };
+    yych = *p;
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy412;
+      if (yych <= '\t')
+        goto yy414;
+    } else {
+      if (yych == '-')
+        goto yy415;
+      goto yy414;
+    }
+  yy412:
+    ++p;
+  yy413 : { return 0; }
+  yy414:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy413;
+    if (yych == '\n')
+      goto yy413;
+    goto yy417;
+  yy415:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 64) {
+      goto yy416;
+    }
+    if (yych <= '\n')
+      goto yy413;
+    goto yy420;
+  yy416:
+    yych = *++p;
+  yy417:
+    if (yybm[0 + yych] & 64) {
+      goto yy416;
+    }
+    if (yych >= '\v')
+      goto yy419;
+  yy418:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy413;
+    } else {
+      goto yy421;
+    }
+  yy419:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy416;
+    }
+    if (yych <= '\n')
+      goto yy418;
+  yy420:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy420;
+    }
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy418;
+      if (yych <= '\t')
+        goto yy416;
+      goto yy418;
+    } else {
+      if (yych != '>')
+        goto yy416;
+    }
+    yyaccept = 1;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 64) {
+      goto yy416;
+    }
+    if (yych >= '\v')
+      goto yy419;
+  yy421 : { return (bufsize_t)(p - start); }
+  }
+}
+
+// Try to match an HTML block end line of type 3
+bufsize_t _scan_html_block_end_3(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,  64, 64, 64, 64, 64, 64, 64, 64, 64,  0,  64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,
+    };
+    yych = *p;
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy423;
+      if (yych <= '\t')
+        goto yy425;
+    } else {
+      if (yych == '?')
+        goto yy426;
+      goto yy425;
+    }
+  yy423:
+    ++p;
+  yy424 : { return 0; }
+  yy425:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy424;
+    if (yych == '\n')
+      goto yy424;
+    goto yy428;
+  yy426:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy424;
+      if (yych <= '\t')
+        goto yy428;
+      goto yy424;
+    } else {
+      if (yych == '>')
+        goto yy431;
+      goto yy428;
+    }
+  yy427:
+    yych = *++p;
+  yy428:
+    if (yybm[0 + yych] & 64) {
+      goto yy427;
+    }
+    if (yych >= '\v')
+      goto yy430;
+  yy429:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy424;
+    } else {
+      goto yy432;
+    }
+  yy430:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy430;
+    }
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy429;
+      if (yych <= '\t')
+        goto yy427;
+      goto yy429;
+    } else {
+      if (yych != '>')
+        goto yy427;
+    }
+  yy431:
+    yyaccept = 1;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 64) {
+      goto yy427;
+    }
+    if (yych >= '\v')
+      goto yy430;
+  yy432 : { return (bufsize_t)(p - start); }
+  }
+}
+
+// Try to match an HTML block end line of type 4
+bufsize_t _scan_html_block_end_4(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,   128, 128, 128, 128, 128, 128, 128, 128, 128, 0,   128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 64,  128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128,
+    };
+    yych = *p;
+    if (yybm[0 + yych] & 64) {
+      goto yy437;
+    }
+    if (yych <= 0x00)
+      goto yy434;
+    if (yych != '\n')
+      goto yy436;
+  yy434:
+    ++p;
+  yy435 : { return 0; }
+  yy436:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy435;
+    if (yych == '\n')
+      goto yy435;
+    goto yy440;
+  yy437:
+    yyaccept = 1;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 128) {
+      goto yy439;
+    }
+    if (yych >= '\v')
+      goto yy437;
+  yy438 : { return (bufsize_t)(p - start); }
+  yy439:
+    yych = *++p;
+  yy440:
+    if (yybm[0 + yych] & 128) {
+      goto yy439;
+    }
+    if (yych >= '\v')
+      goto yy437;
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy435;
+    } else {
+      goto yy438;
+    }
+  }
+}
+
+// Try to match an HTML block end line of type 5
+bufsize_t _scan_html_block_end_5(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,  64, 64, 64,  64, 64, 64, 64, 64, 64, 0,  64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64,
+    };
+    yych = *p;
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy442;
+      if (yych <= '\t')
+        goto yy444;
+    } else {
+      if (yych == ']')
+        goto yy445;
+      goto yy444;
+    }
+  yy442:
+    ++p;
+  yy443 : { return 0; }
+  yy444:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy443;
+    if (yych == '\n')
+      goto yy443;
+    goto yy447;
+  yy445:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 64) {
+      goto yy446;
+    }
+    if (yych <= '\n')
+      goto yy443;
+    goto yy450;
+  yy446:
+    yych = *++p;
+  yy447:
+    if (yybm[0 + yych] & 64) {
+      goto yy446;
+    }
+    if (yych >= '\v')
+      goto yy449;
+  yy448:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy443;
+    } else {
+      goto yy451;
+    }
+  yy449:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy446;
+    }
+    if (yych <= '\n')
+      goto yy448;
+  yy450:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy450;
+    }
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy448;
+      if (yych <= '\t')
+        goto yy446;
+      goto yy448;
+    } else {
+      if (yych != '>')
+        goto yy446;
+    }
+    yyaccept = 1;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 64) {
+      goto yy446;
+    }
+    if (yych >= '\v')
+      goto yy449;
+  yy451 : { return (bufsize_t)(p - start); }
+  }
+}
+
+// Try to match a link title (in single quotes, in double quotes, or
+// in parentheses), returning number of chars matched.  Allow one
+// level of internal nesting (quotes within quotes).
+bufsize_t _scan_link_title(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    static const unsigned char yybm[] = {
+        0,   208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 192, 208, 208, 208, 208, 144, 80,  80,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 32,  208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+        208, 208, 208, 208,
+    };
+    yych = *p;
+    if (yych <= '&') {
+      if (yych == '"')
+        goto yy454;
+    } else {
+      if (yych <= '\'')
+        goto yy455;
+      if (yych <= '(')
+        goto yy456;
+    }
+    ++p;
+  yy453 : { return 0; }
+  yy454:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy453;
+    goto yy458;
+  yy455:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy453;
+    goto yy464;
+  yy456:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych <= 0x00)
+      goto yy453;
+    if (yych == '(')
+      goto yy453;
+    goto yy469;
+  yy457:
+    yych = *++p;
+  yy458:
+    if (yybm[0 + yych] & 16) {
+      goto yy457;
+    }
+    if (yych <= 0x00)
+      goto yy459;
+    if (yych <= '"')
+      goto yy460;
+    goto yy462;
+  yy459:
+    p = marker;
+    if (yyaccept <= 1) {
+      if (yyaccept == 0) {
+        goto yy453;
+      } else {
+        goto yy461;
+      }
+    } else {
+      if (yyaccept == 2) {
+        goto yy466;
+      } else {
+        goto yy471;
+      }
+    }
+  yy460:
+    ++p;
+  yy461 : { return (bufsize_t)(p - start); }
+  yy462:
+    yych = *++p;
+    if (yybm[0 + yych] & 16) {
+      goto yy457;
+    }
+    if (yych <= 0x00)
+      goto yy459;
+    if (yych <= '"')
+      goto yy473;
+    goto yy462;
+  yy463:
+    yych = *++p;
+  yy464:
+    if (yybm[0 + yych] & 64) {
+      goto yy463;
+    }
+    if (yych <= 0x00)
+      goto yy459;
+    if (yych >= '(')
+      goto yy467;
+  yy465:
+    ++p;
+  yy466 : { return (bufsize_t)(p - start); }
+  yy467:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy463;
+    }
+    if (yych <= 0x00)
+      goto yy459;
+    if (yych <= '\'')
+      goto yy474;
+    goto yy467;
+  yy468:
+    yych = *++p;
+  yy469:
+    if (yybm[0 + yych] & 128) {
+      goto yy468;
+    }
+    if (yych <= '(')
+      goto yy459;
+    if (yych >= '*')
+      goto yy472;
+  yy470:
+    ++p;
+  yy471 : { return (bufsize_t)(p - start); }
+  yy472:
+    yych = *++p;
+    if (yych <= ')') {
+      if (yych <= 0x00)
+        goto yy459;
+      if (yych <= '(')
+        goto yy468;
+      goto yy475;
+    } else {
+      if (yych == '\\')
+        goto yy472;
+      goto yy468;
+    }
+  yy473:
+    yyaccept = 1;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 16) {
+      goto yy457;
+    }
+    if (yych <= 0x00)
+      goto yy461;
+    if (yych <= '"')
+      goto yy460;
+    goto yy462;
+  yy474:
+    yyaccept = 2;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 64) {
+      goto yy463;
+    }
+    if (yych <= 0x00)
+      goto yy466;
+    if (yych <= '\'')
+      goto yy465;
+    goto yy467;
+  yy475:
+    yyaccept = 3;
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 128) {
+      goto yy468;
+    }
+    if (yych <= '(')
+      goto yy471;
+    if (yych <= ')')
+      goto yy470;
+    goto yy472;
+  }
+}
+
+// Match space characters, including newlines.
+bufsize_t _scan_spacechars(const unsigned char *p) {
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   128, 0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0,
+    };
+    yych = *p;
+    if (yybm[0 + yych] & 128) {
+      goto yy477;
+    }
+    ++p;
+    { return 0; }
+  yy477:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy477;
+    }
+    { return (bufsize_t)(p - start); }
+  }
+}
+
+// Match ATX heading start.
+bufsize_t _scan_atx_heading_start(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,
+    };
+    yych = *p;
+    if (yych == '#')
+      goto yy480;
+    ++p;
+  yy479 : { return 0; }
+  yy480:
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 128) {
+      goto yy481;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy479;
+      if (yych <= '\n')
+        goto yy483;
+      goto yy479;
+    } else {
+      if (yych <= '\r')
+        goto yy483;
+      if (yych == '#')
+        goto yy484;
+      goto yy479;
+    }
+  yy481:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy481;
+    }
+  yy482 : { return (bufsize_t)(p - start); }
+  yy483:
+    ++p;
+    goto yy482;
+  yy484:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy481;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy485;
+      if (yych <= '\n')
+        goto yy483;
+    } else {
+      if (yych <= '\r')
+        goto yy483;
+      if (yych == '#')
+        goto yy486;
+    }
+  yy485:
+    p = marker;
+    goto yy479;
+  yy486:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy481;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy485;
+      if (yych <= '\n')
+        goto yy483;
+      goto yy485;
+    } else {
+      if (yych <= '\r')
+        goto yy483;
+      if (yych != '#')
+        goto yy485;
+    }
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy481;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy485;
+      if (yych <= '\n')
+        goto yy483;
+      goto yy485;
+    } else {
+      if (yych <= '\r')
+        goto yy483;
+      if (yych != '#')
+        goto yy485;
+    }
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy481;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy485;
+      if (yych <= '\n')
+        goto yy483;
+      goto yy485;
+    } else {
+      if (yych <= '\r')
+        goto yy483;
+      if (yych != '#')
+        goto yy485;
+    }
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy481;
+    }
+    if (yych <= 0x08)
+      goto yy485;
+    if (yych <= '\n')
+      goto yy483;
+    if (yych == '\r')
+      goto yy483;
+    goto yy485;
+  }
+}
+
+// Match setext heading line.  Return 1 for level-1 heading,
+// 2 for level-2, 0 for no match.
+bufsize_t _scan_setext_heading_line(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 32, 0,  0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0,
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  32, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0,
+        0, 64, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0,
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0,
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0,
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0,
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0,
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0,
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0,
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0,
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0,
+        0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0,
+    };
+    yych = *p;
+    if (yych == '-')
+      goto yy489;
+    if (yych == '=')
+      goto yy490;
+    ++p;
+  yy488 : { return 0; }
+  yy489:
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 64) {
+      goto yy495;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy488;
+      if (yych <= '\n')
+        goto yy492;
+      goto yy488;
+    } else {
+      if (yych <= '\r')
+        goto yy492;
+      if (yych == ' ')
+        goto yy492;
+      goto yy488;
+    }
+  yy490:
+    yych = *(marker = ++p);
+    if (yybm[0 + yych] & 128) {
+      goto yy499;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy488;
+      if (yych <= '\n')
+        goto yy497;
+      goto yy488;
+    } else {
+      if (yych <= '\r')
+        goto yy497;
+      if (yych == ' ')
+        goto yy497;
+      goto yy488;
+    }
+  yy491:
+    yych = *++p;
+  yy492:
+    if (yybm[0 + yych] & 32) {
+      goto yy491;
+    }
+    if (yych <= 0x08)
+      goto yy493;
+    if (yych <= '\n')
+      goto yy494;
+    if (yych == '\r')
+      goto yy494;
+  yy493:
+    p = marker;
+    goto yy488;
+  yy494:
+    ++p;
+    { return 2; }
+  yy495:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy491;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy493;
+      if (yych <= '\n')
+        goto yy494;
+      goto yy493;
+    } else {
+      if (yych <= '\r')
+        goto yy494;
+      if (yych == '-')
+        goto yy495;
+      goto yy493;
+    }
+  yy496:
+    yych = *++p;
+  yy497:
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy493;
+      if (yych <= '\t')
+        goto yy496;
+      if (yych >= '\v')
+        goto yy493;
+    } else {
+      if (yych <= '\r')
+        goto yy498;
+      if (yych == ' ')
+        goto yy496;
+      goto yy493;
+    }
+  yy498:
+    ++p;
+    { return 1; }
+  yy499:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy499;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy493;
+      if (yych <= '\t')
+        goto yy496;
+      if (yych <= '\n')
+        goto yy498;
+      goto yy493;
+    } else {
+      if (yych <= '\r')
+        goto yy498;
+      if (yych == ' ')
+        goto yy496;
+      goto yy493;
+    }
+  }
+}
+
+// Scan an opening code fence.
+bufsize_t _scan_open_code_fence(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0,   192, 192, 192, 192, 192, 192, 192, 192, 192, 0,   192, 192, 0,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 144, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        224, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+        192, 192, 192, 192,
+    };
+    yych = *p;
+    if (yych == '`')
+      goto yy502;
+    if (yych == '~')
+      goto yy503;
+    ++p;
+  yy501 : { return 0; }
+  yy502:
+    yych = *(marker = ++p);
+    if (yych == '`')
+      goto yy504;
+    goto yy501;
+  yy503:
+    yych = *(marker = ++p);
+    if (yych == '~')
+      goto yy506;
+    goto yy501;
+  yy504:
+    yych = *++p;
+    if (yybm[0 + yych] & 16) {
+      goto yy507;
+    }
+  yy505:
+    p = marker;
+    goto yy501;
+  yy506:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy508;
+    }
+    goto yy505;
+  yy507:
+    yych = *++p;
+    if (yybm[0 + yych] & 16) {
+      goto yy507;
+    }
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy505;
+      if (yych <= '\t') {
+        marker = p;
+        goto yy509;
+      }
+      marker = p;
+      goto yy510;
+    } else {
+      if (yych == '\r') {
+        marker = p;
+        goto yy510;
+      }
+      marker = p;
+      goto yy509;
+    }
+  yy508:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy508;
+    }
+    if (yych <= '\n') {
+      if (yych <= 0x00)
+        goto yy505;
+      if (yych <= '\t') {
+        marker = p;
+        goto yy511;
+      }
+      marker = p;
+      goto yy512;
+    } else {
+      if (yych == '\r') {
+        marker = p;
+        goto yy512;
+      }
+      marker = p;
+      goto yy511;
+    }
+  yy509:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy509;
+    }
+    if (yych <= 0x00)
+      goto yy505;
+    if (yych >= 0x0E)
+      goto yy505;
+  yy510:
+    ++p;
+    p = marker;
+    { return (bufsize_t)(p - start); }
+  yy511:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy511;
+    }
+    if (yych <= 0x00)
+      goto yy505;
+  yy512:
+    ++p;
+    p = marker;
+    { return (bufsize_t)(p - start); }
+  }
+}
+
+// Scan a closing code fence with length at least len.
+bufsize_t _scan_close_code_fence(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  128, 0,   0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  0,   128, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  0,   0,   0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  0,   0,   0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 32, 0,   0,   0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  0,   0,   0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  0,   0,   0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  0,   0,   0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  0,   0,   0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  0,   0,   0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  0,   0,   0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,  0,   0,   0, 0, 0,
+    };
+    yych = *p;
+    if (yych == '`')
+      goto yy515;
+    if (yych == '~')
+      goto yy516;
+    ++p;
+  yy514 : { return 0; }
+  yy515:
+    yych = *(marker = ++p);
+    if (yych == '`')
+      goto yy517;
+    goto yy514;
+  yy516:
+    yych = *(marker = ++p);
+    if (yych == '~')
+      goto yy519;
+    goto yy514;
+  yy517:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy520;
+    }
+  yy518:
+    p = marker;
+    goto yy514;
+  yy519:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy521;
+    }
+    goto yy518;
+  yy520:
+    yych = *++p;
+    if (yybm[0 + yych] & 32) {
+      goto yy520;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy518;
+      if (yych <= '\t') {
+        marker = p;
+        goto yy522;
+      }
+      if (yych <= '\n') {
+        marker = p;
+        goto yy523;
+      }
+      goto yy518;
+    } else {
+      if (yych <= '\r') {
+        marker = p;
+        goto yy523;
+      }
+      if (yych == ' ') {
+        marker = p;
+        goto yy522;
+      }
+      goto yy518;
+    }
+  yy521:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy521;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy518;
+      if (yych <= '\t') {
+        marker = p;
+        goto yy524;
+      }
+      if (yych <= '\n') {
+        marker = p;
+        goto yy525;
+      }
+      goto yy518;
+    } else {
+      if (yych <= '\r') {
+        marker = p;
+        goto yy525;
+      }
+      if (yych == ' ') {
+        marker = p;
+        goto yy524;
+      }
+      goto yy518;
+    }
+  yy522:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy522;
+    }
+    if (yych <= 0x08)
+      goto yy518;
+    if (yych <= '\n')
+      goto yy523;
+    if (yych != '\r')
+      goto yy518;
+  yy523:
+    ++p;
+    p = marker;
+    { return (bufsize_t)(p - start); }
+  yy524:
+    yych = *++p;
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy518;
+      if (yych <= '\t')
+        goto yy524;
+      if (yych >= '\v')
+        goto yy518;
+    } else {
+      if (yych <= '\r')
+        goto yy525;
+      if (yych == ' ')
+        goto yy524;
+      goto yy518;
+    }
+  yy525:
+    ++p;
+    p = marker;
+    { return (bufsize_t)(p - start); }
+  }
+}
+
+// Returns positive value if a URL begins in a way that is potentially
+// dangerous, with javascript:, vbscript:, file:, or data:, otherwise 0.
+bufsize_t _scan_dangerous_url(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    unsigned int yyaccept = 0;
+    yych = *p;
+    if (yych <= 'V') {
+      if (yych <= 'F') {
+        if (yych == 'D')
+          goto yy528;
+        if (yych >= 'F')
+          goto yy529;
+      } else {
+        if (yych == 'J')
+          goto yy530;
+        if (yych >= 'V')
+          goto yy531;
+      }
+    } else {
+      if (yych <= 'f') {
+        if (yych == 'd')
+          goto yy528;
+        if (yych >= 'f')
+          goto yy529;
+      } else {
+        if (yych <= 'j') {
+          if (yych >= 'j')
+            goto yy530;
+        } else {
+          if (yych == 'v')
+            goto yy531;
+        }
+      }
+    }
+    ++p;
+  yy527 : { return 0; }
+  yy528:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych == 'A')
+      goto yy532;
+    if (yych == 'a')
+      goto yy532;
+    goto yy527;
+  yy529:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych == 'I')
+      goto yy534;
+    if (yych == 'i')
+      goto yy534;
+    goto yy527;
+  yy530:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych == 'A')
+      goto yy535;
+    if (yych == 'a')
+      goto yy535;
+    goto yy527;
+  yy531:
+    yyaccept = 0;
+    yych = *(marker = ++p);
+    if (yych == 'B')
+      goto yy536;
+    if (yych == 'b')
+      goto yy536;
+    goto yy527;
+  yy532:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy537;
+    if (yych == 't')
+      goto yy537;
+  yy533:
+    p = marker;
+    if (yyaccept == 0) {
+      goto yy527;
+    } else {
+      goto yy545;
+    }
+  yy534:
+    yych = *++p;
+    if (yych == 'L')
+      goto yy538;
+    if (yych == 'l')
+      goto yy538;
+    goto yy533;
+  yy535:
+    yych = *++p;
+    if (yych == 'V')
+      goto yy539;
+    if (yych == 'v')
+      goto yy539;
+    goto yy533;
+  yy536:
+    yych = *++p;
+    if (yych == 'S')
+      goto yy540;
+    if (yych == 's')
+      goto yy540;
+    goto yy533;
+  yy537:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy541;
+    if (yych == 'a')
+      goto yy541;
+    goto yy533;
+  yy538:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy542;
+    if (yych == 'e')
+      goto yy542;
+    goto yy533;
+  yy539:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy536;
+    if (yych == 'a')
+      goto yy536;
+    goto yy533;
+  yy540:
+    yych = *++p;
+    if (yych == 'C')
+      goto yy543;
+    if (yych == 'c')
+      goto yy543;
+    goto yy533;
+  yy541:
+    yych = *++p;
+    if (yych == ':')
+      goto yy544;
+    goto yy533;
+  yy542:
+    yych = *++p;
+    if (yych == ':')
+      goto yy546;
+    goto yy533;
+  yy543:
+    yych = *++p;
+    if (yych == 'R')
+      goto yy547;
+    if (yych == 'r')
+      goto yy547;
+    goto yy533;
+  yy544:
+    yyaccept = 1;
+    yych = *(marker = ++p);
+    if (yych == 'I')
+      goto yy548;
+    if (yych == 'i')
+      goto yy548;
+  yy545 : { return (bufsize_t)(p - start); }
+  yy546:
+    ++p;
+    goto yy545;
+  yy547:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy549;
+    if (yych == 'i')
+      goto yy549;
+    goto yy533;
+  yy548:
+    yych = *++p;
+    if (yych == 'M')
+      goto yy550;
+    if (yych == 'm')
+      goto yy550;
+    goto yy533;
+  yy549:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy551;
+    if (yych == 'p')
+      goto yy551;
+    goto yy533;
+  yy550:
+    yych = *++p;
+    if (yych == 'A')
+      goto yy552;
+    if (yych == 'a')
+      goto yy552;
+    goto yy533;
+  yy551:
+    yych = *++p;
+    if (yych == 'T')
+      goto yy542;
+    if (yych == 't')
+      goto yy542;
+    goto yy533;
+  yy552:
+    yych = *++p;
+    if (yych == 'G')
+      goto yy553;
+    if (yych != 'g')
+      goto yy533;
+  yy553:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy554;
+    if (yych != 'e')
+      goto yy533;
+  yy554:
+    yych = *++p;
+    if (yych != '/')
+      goto yy533;
+    yych = *++p;
+    if (yych <= 'W') {
+      if (yych <= 'J') {
+        if (yych == 'G')
+          goto yy555;
+        if (yych <= 'I')
+          goto yy533;
+        goto yy556;
+      } else {
+        if (yych == 'P')
+          goto yy557;
+        if (yych <= 'V')
+          goto yy533;
+        goto yy558;
+      }
+    } else {
+      if (yych <= 'j') {
+        if (yych == 'g')
+          goto yy555;
+        if (yych <= 'i')
+          goto yy533;
+        goto yy556;
+      } else {
+        if (yych <= 'p') {
+          if (yych <= 'o')
+            goto yy533;
+          goto yy557;
+        } else {
+          if (yych == 'w')
+            goto yy558;
+          goto yy533;
+        }
+      }
+    }
+  yy555:
+    yych = *++p;
+    if (yych == 'I')
+      goto yy559;
+    if (yych == 'i')
+      goto yy559;
+    goto yy533;
+  yy556:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy560;
+    if (yych == 'p')
+      goto yy560;
+    goto yy533;
+  yy557:
+    yych = *++p;
+    if (yych == 'N')
+      goto yy561;
+    if (yych == 'n')
+      goto yy561;
+    goto yy533;
+  yy558:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy562;
+    if (yych == 'e')
+      goto yy562;
+    goto yy533;
+  yy559:
+    yych = *++p;
+    if (yych == 'F')
+      goto yy563;
+    if (yych == 'f')
+      goto yy563;
+    goto yy533;
+  yy560:
+    yych = *++p;
+    if (yych == 'E')
+      goto yy561;
+    if (yych != 'e')
+      goto yy533;
+  yy561:
+    yych = *++p;
+    if (yych == 'G')
+      goto yy563;
+    if (yych == 'g')
+      goto yy563;
+    goto yy533;
+  yy562:
+    yych = *++p;
+    if (yych == 'B')
+      goto yy564;
+    if (yych == 'b')
+      goto yy564;
+    goto yy533;
+  yy563:
+    ++p;
+    { return 0; }
+  yy564:
+    yych = *++p;
+    if (yych == 'P')
+      goto yy563;
+    if (yych == 'p')
+      goto yy563;
+    goto yy533;
+  }
+}
diff --git a/cmark/src/scanners.h b/cmark/src/scanners.h
new file mode 100644
index 0000000000..27f927342a
--- /dev/null
+++ b/cmark/src/scanners.h
@@ -0,0 +1,59 @@
+#include "cmark.h"
+#include "chunk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c,
+                   bufsize_t offset);
+bufsize_t _scan_scheme(const unsigned char *p);
+bufsize_t _scan_autolink_uri(const unsigned char *p);
+bufsize_t _scan_autolink_email(const unsigned char *p);
+bufsize_t _scan_html_tag(const unsigned char *p);
+bufsize_t _scan_html_comment(const unsigned char *p);
+bufsize_t _scan_html_pi(const unsigned char *p);
+bufsize_t _scan_html_declaration(const unsigned char *p);
+bufsize_t _scan_html_cdata(const unsigned char *p);
+bufsize_t _scan_html_block_start(const unsigned char *p);
+bufsize_t _scan_html_block_start_7(const unsigned char *p);
+bufsize_t _scan_html_block_end_1(const unsigned char *p);
+bufsize_t _scan_html_block_end_2(const unsigned char *p);
+bufsize_t _scan_html_block_end_3(const unsigned char *p);
+bufsize_t _scan_html_block_end_4(const unsigned char *p);
+bufsize_t _scan_html_block_end_5(const unsigned char *p);
+bufsize_t _scan_link_title(const unsigned char *p);
+bufsize_t _scan_spacechars(const unsigned char *p);
+bufsize_t _scan_atx_heading_start(const unsigned char *p);
+bufsize_t _scan_setext_heading_line(const unsigned char *p);
+bufsize_t _scan_open_code_fence(const unsigned char *p);
+bufsize_t _scan_close_code_fence(const unsigned char *p);
+bufsize_t _scan_dangerous_url(const unsigned char *p);
+
+#define scan_scheme(c, n) _scan_at(&_scan_scheme, c, n)
+#define scan_autolink_uri(c, n) _scan_at(&_scan_autolink_uri, c, n)
+#define scan_autolink_email(c, n) _scan_at(&_scan_autolink_email, c, n)
+#define scan_html_tag(c, n) _scan_at(&_scan_html_tag, c, n)
+#define scan_html_comment(c, n) _scan_at(&_scan_html_comment, c, n)
+#define scan_html_pi(c, n) _scan_at(&_scan_html_pi, c, n)
+#define scan_html_declaration(c, n) _scan_at(&_scan_html_declaration, c, n)
+#define scan_html_cdata(c, n) _scan_at(&_scan_html_cdata, c, n)
+#define scan_html_block_start(c, n) _scan_at(&_scan_html_block_start, c, n)
+#define scan_html_block_start_7(c, n) _scan_at(&_scan_html_block_start_7, c, n)
+#define scan_html_block_end_1(c, n) _scan_at(&_scan_html_block_end_1, c, n)
+#define scan_html_block_end_2(c, n) _scan_at(&_scan_html_block_end_2, c, n)
+#define scan_html_block_end_3(c, n) _scan_at(&_scan_html_block_end_3, c, n)
+#define scan_html_block_end_4(c, n) _scan_at(&_scan_html_block_end_4, c, n)
+#define scan_html_block_end_5(c, n) _scan_at(&_scan_html_block_end_5, c, n)
+#define scan_link_title(c, n) _scan_at(&_scan_link_title, c, n)
+#define scan_spacechars(c, n) _scan_at(&_scan_spacechars, c, n)
+#define scan_atx_heading_start(c, n) _scan_at(&_scan_atx_heading_start, c, n)
+#define scan_setext_heading_line(c, n)                                         \
+  _scan_at(&_scan_setext_heading_line, c, n)
+#define scan_open_code_fence(c, n) _scan_at(&_scan_open_code_fence, c, n)
+#define scan_close_code_fence(c, n) _scan_at(&_scan_close_code_fence, c, n)
+#define scan_dangerous_url(c, n) _scan_at(&_scan_dangerous_url, c, n)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/cmark/src/scanners.re b/cmark/src/scanners.re
new file mode 100644
index 0000000000..16238b7745
--- /dev/null
+++ b/cmark/src/scanners.re
@@ -0,0 +1,330 @@
+#include <stdlib.h>
+#include "chunk.h"
+#include "scanners.h"
+
+bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, bufsize_t offset)
+{
+	bufsize_t res;
+	unsigned char *ptr = (unsigned char *)c->data;
+
+        if (ptr == NULL || offset > c->len) {
+          return 0;
+        } else {
+	  unsigned char lim = ptr[c->len];
+
+	  ptr[c->len] = '\0';
+	  res = scanner(ptr + offset);
+	  ptr[c->len] = lim;
+        }
+
+	return res;
+}
+
+/*!re2c
+  re2c:define:YYCTYPE  = "unsigned char";
+  re2c:define:YYCURSOR = p;
+  re2c:define:YYMARKER = marker;
+  re2c:define:YYCTXMARKER = marker;
+  re2c:yyfill:enable = 0;
+
+  spacechar = [ \t\v\f\r\n];
+
+  reg_char     = [^\\()\x00-\x20];
+
+  escaped_char = [\\][!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~-];
+
+  tagname = [A-Za-z][A-Za-z0-9-]*;
+
+  blocktagname = 'address'|'article'|'aside'|'base'|'basefont'|'blockquote'|'body'|'caption'|'center'|'col'|'colgroup'|'dd'|'details'|'dialog'|'dir'|'div'|'dl'|'dt'|'fieldset'|'figcaption'|'figure'|'footer'|'form'|'frame'|'frameset'|'h1'|'h2'|'h3'|'h4'|'h5'|'h6'|'head'|'header'|'hr'|'html'|'iframe'|'legend'|'li'|'link'|'main'|'menu'|'menuitem'|'nav'|'noframes'|'ol'|'optgroup'|'option'|'p'|'param'|'section'|'search'|'title'|'summary'|'table'|'tbody'|'td'|'tfoot'|'th'|'thead'|'title'|'tr'|'track'|'ul';
+
+  attributename = [a-zA-Z_:][a-zA-Z0-9:._-]*;
+
+  unquotedvalue = [^ \t\r\n\v\f"'=<>`\x00]+;
+  singlequotedvalue = ['][^'\x00]*['];
+  doublequotedvalue = ["][^"\x00]*["];
+
+  attributevalue = unquotedvalue | singlequotedvalue | doublequotedvalue;
+
+  attributevaluespec = spacechar* [=] spacechar* attributevalue;
+
+  attribute = spacechar+ attributename attributevaluespec?;
+
+  opentag = tagname attribute* spacechar* [/]? [>];
+  closetag = [/] tagname spacechar* [>];
+
+  htmlcomment = "--" ([^\x00-]+ | "-" [^\x00-] | "--" [^\x00>])* "-->";
+
+  processinginstruction = ([^?>\x00]+ | [?][^>\x00] | [>])+;
+
+  declaration = [A-Za-z]+ [^>\x00]*;
+
+  cdata = "CDATA[" ([^\]\x00]+ | "]" [^\]\x00] | "]]" [^>\x00])*;
+
+  htmltag = opentag | closetag;
+
+  in_parens_nosp   = [(] (reg_char|escaped_char|[\\])* [)];
+
+  in_double_quotes = ["] (escaped_char|[^"\x00])* ["];
+  in_single_quotes = ['] (escaped_char|[^'\x00])* ['];
+  in_parens        = [(] (escaped_char|[^)\x00])* [)];
+
+  scheme           = [A-Za-z][A-Za-z0-9.+-]{1,31};
+*/
+
+// Try to match a scheme including colon.
+bufsize_t _scan_scheme(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  scheme [:] { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match URI autolink after first <, returning number of chars matched.
+bufsize_t _scan_autolink_uri(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  scheme [:][^\x00-\x20<>]*[>]  { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match email autolink after first <, returning num of chars matched.
+bufsize_t _scan_autolink_email(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+
+    [@]
+    [a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?
+    ([.][a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*
+    [>] { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML tag after first <, returning num of chars matched.
+bufsize_t _scan_html_tag(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  htmltag { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+bufsize_t _scan_html_comment(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  htmlcomment { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+bufsize_t _scan_html_pi(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  processinginstruction { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+bufsize_t _scan_html_declaration(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+  (void) marker;
+/*!re2c
+  declaration { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+bufsize_t _scan_html_cdata(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  cdata { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block tag start line, returning
+// an integer code for the type of block (1-6, matching the spec).
+// #7 is handled by a separate function, below.
+bufsize_t _scan_html_block_start(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+/*!re2c
+  [<] ('script'|'pre'|'textarea'|'style') (spacechar | [>]) { return 1; }
+  '<!--' { return 2; }
+  '<?' { return 3; }
+  '<!' [A-Za-z] { return 4; }
+  '<![CDATA[' { return 5; }
+  [<] [/]? blocktagname (spacechar | [/]? [>])  { return 6; }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block tag start line of type 7, returning
+// 7 if successful, 0 if not.
+bufsize_t _scan_html_block_start_7(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+/*!re2c
+  [<] (opentag | closetag) [\t\n\f ]* [\r\n] { return 7; }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block end line of type 1
+bufsize_t _scan_html_block_end_1(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [^\n\x00]* [<] [/] ('script'|'pre'|'textarea'|'style') [>] { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block end line of type 2
+bufsize_t _scan_html_block_end_2(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [^\n\x00]* '-->' { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block end line of type 3
+bufsize_t _scan_html_block_end_3(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [^\n\x00]* '?>' { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block end line of type 4
+bufsize_t _scan_html_block_end_4(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [^\n\x00]* '>' { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block end line of type 5
+bufsize_t _scan_html_block_end_5(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [^\n\x00]* ']]>' { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match a link title (in single quotes, in double quotes, or
+// in parentheses), returning number of chars matched.  Allow one
+// level of internal nesting (quotes within quotes).
+bufsize_t _scan_link_title(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  ["] (escaped_char|[^"\x00])* ["]   { return (bufsize_t)(p - start); }
+  ['] (escaped_char|[^'\x00])* ['] { return (bufsize_t)(p - start); }
+  [(] (escaped_char|[^()\x00])* [)]  { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Match space characters, including newlines.
+bufsize_t _scan_spacechars(const unsigned char *p)
+{
+  const unsigned char *start = p; \
+/*!re2c
+  [ \t\v\f\r\n]+ { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Match ATX heading start.
+bufsize_t _scan_atx_heading_start(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [#]{1,6} ([ \t]+|[\r\n])  { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Match setext heading line.  Return 1 for level-1 heading,
+// 2 for level-2, 0 for no match.
+bufsize_t _scan_setext_heading_line(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+/*!re2c
+  [=]+ [ \t]* [\r\n] { return 1; }
+  [-]+ [ \t]* [\r\n] { return 2; }
+  * { return 0; }
+*/
+}
+
+// Scan an opening code fence.
+bufsize_t _scan_open_code_fence(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [`]{3,} / [^`\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); }
+  [~]{3,} / [^\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Scan a closing code fence with length at least len.
+bufsize_t _scan_close_code_fence(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [`]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); }
+  [~]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Returns positive value if a URL begins in a way that is potentially
+// dangerous, with javascript:, vbscript:, file:, or data:, otherwise 0.
+bufsize_t _scan_dangerous_url(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  'data:image/' ('png'|'gif'|'jpeg'|'webp') { return 0; }
+  'javascript:' | 'vbscript:' | 'file:' | 'data:' { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
diff --git a/cmark/src/utf8.c b/cmark/src/utf8.c
new file mode 100644
index 0000000000..48697c77d7
--- /dev/null
+++ b/cmark/src/utf8.c
@@ -0,0 +1,428 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <assert.h>
+
+#include "cmark_ctype.h"
+#include "utf8.h"
+
+static const int8_t utf8proc_utf8class[256] = {
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0};
+
+static void encode_unknown(cmark_strbuf *buf) {
+  static const uint8_t repl[] = {239, 191, 189};
+  cmark_strbuf_put(buf, repl, 3);
+}
+
+static int utf8proc_charlen(const uint8_t *str, bufsize_t str_len) {
+  int length, i;
+
+  if (!str_len)
+    return 0;
+
+  length = utf8proc_utf8class[str[0]];
+
+  if (!length)
+    return -1;
+
+  if (str_len >= 0 && (bufsize_t)length > str_len)
+    return -str_len;
+
+  for (i = 1; i < length; i++) {
+    if ((str[i] & 0xC0) != 0x80)
+      return -i;
+  }
+
+  return length;
+}
+
+// Validate a single UTF-8 character according to RFC 3629.
+static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) {
+  int length = utf8proc_utf8class[str[0]];
+
+  if (!length)
+    return -1;
+
+  if ((bufsize_t)length > str_len)
+    return -str_len;
+
+  switch (length) {
+  case 2:
+    if ((str[1] & 0xC0) != 0x80)
+      return -1;
+    if (str[0] < 0xC2) {
+      // Overlong
+      return -length;
+    }
+    break;
+
+  case 3:
+    if ((str[1] & 0xC0) != 0x80)
+      return -1;
+    if ((str[2] & 0xC0) != 0x80)
+      return -2;
+    if (str[0] == 0xE0) {
+      if (str[1] < 0xA0) {
+        // Overlong
+        return -length;
+      }
+    } else if (str[0] == 0xED) {
+      if (str[1] >= 0xA0) {
+        // Surrogate
+        return -length;
+      }
+    }
+    break;
+
+  case 4:
+    if ((str[1] & 0xC0) != 0x80)
+      return -1;
+    if ((str[2] & 0xC0) != 0x80)
+      return -2;
+    if ((str[3] & 0xC0) != 0x80)
+      return -3;
+    if (str[0] == 0xF0) {
+      if (str[1] < 0x90) {
+        // Overlong
+        return -length;
+      }
+    } else if (str[0] >= 0xF4) {
+      if (str[0] > 0xF4 || str[1] >= 0x90) {
+        // Above 0x10FFFF
+        return -length;
+      }
+    }
+    break;
+  }
+
+  return length;
+}
+
+void cmark_utf8proc_check(cmark_strbuf *ob, const uint8_t *line,
+                          bufsize_t size) {
+  bufsize_t i = 0;
+
+  while (i < size) {
+    bufsize_t org = i;
+    int charlen = 0;
+
+    while (i < size) {
+      if (line[i] < 0x80 && line[i] != 0) {
+        i++;
+      } else if (line[i] >= 0x80) {
+        charlen = utf8proc_valid(line + i, size - i);
+        if (charlen < 0) {
+          charlen = -charlen;
+          break;
+        }
+        i += charlen;
+      } else if (line[i] == 0) {
+        // ASCII NUL is technically valid but rejected
+        // for security reasons.
+        charlen = 1;
+        break;
+      }
+    }
+
+    if (i > org) {
+      cmark_strbuf_put(ob, line + org, i - org);
+    }
+
+    if (i >= size) {
+      break;
+    } else {
+      // Invalid UTF-8
+      encode_unknown(ob);
+      i += charlen;
+    }
+  }
+}
+
+int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len,
+                           int32_t *dst) {
+  int length;
+  int32_t uc = -1;
+
+  *dst = -1;
+  length = utf8proc_charlen(str, str_len);
+  if (length < 0)
+    return -1;
+
+  switch (length) {
+  case 1:
+    uc = str[0];
+    break;
+  case 2:
+    uc = ((str[0] & 0x1F) << 6) + (str[1] & 0x3F);
+    if (uc < 0x80)
+      uc = -1;
+    break;
+  case 3:
+    uc = ((str[0] & 0x0F) << 12) + ((str[1] & 0x3F) << 6) + (str[2] & 0x3F);
+    if (uc < 0x800 || (uc >= 0xD800 && uc < 0xE000))
+      uc = -1;
+    break;
+  case 4:
+    uc = ((str[0] & 0x07) << 18) + ((str[1] & 0x3F) << 12) +
+         ((str[2] & 0x3F) << 6) + (str[3] & 0x3F);
+    if (uc < 0x10000 || uc >= 0x110000)
+      uc = -1;
+    break;
+  }
+
+  if (uc < 0)
+    return -1;
+
+  *dst = uc;
+  return length;
+}
+
+void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) {
+  uint8_t dst[4];
+  bufsize_t len = 0;
+
+  assert(uc >= 0);
+
+  if (uc < 0x80) {
+    dst[0] = (uint8_t)(uc);
+    len = 1;
+  } else if (uc < 0x800) {
+    dst[0] = (uint8_t)(0xC0 + (uc >> 6));
+    dst[1] = 0x80 + (uc & 0x3F);
+    len = 2;
+  } else if (uc < 0x10000) {
+    dst[0] = (uint8_t)(0xE0 + (uc >> 12));
+    dst[1] = 0x80 + ((uc >> 6) & 0x3F);
+    dst[2] = 0x80 + (uc & 0x3F);
+    len = 3;
+  } else if (uc < 0x110000) {
+    dst[0] = (uint8_t)(0xF0 + (uc >> 18));
+    dst[1] = 0x80 + ((uc >> 12) & 0x3F);
+    dst[2] = 0x80 + ((uc >> 6) & 0x3F);
+    dst[3] = 0x80 + (uc & 0x3F);
+    len = 4;
+  } else {
+    encode_unknown(buf);
+    return;
+  }
+
+  cmark_strbuf_put(buf, dst, len);
+}
+
+#include "case_fold.inc"
+
+int cf_compare(const void *v1, const void *v2) {
+  uint32_t entry1 = *(uint32_t *) v1;
+  uint32_t entry2 = *(uint32_t *) v2;
+
+  return (int32_t) CF_CODE_POINT(entry1) - (int32_t) CF_CODE_POINT(entry2);
+}
+
+void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str,
+                              bufsize_t len) {
+  int32_t c;
+
+  while (len > 0) {
+    bufsize_t char_len = cmark_utf8proc_iterate(str, len, &c);
+
+    if (char_len == 1) {
+      if (c >= 'A' && c <= 'Z')
+        c += 'a' - 'A';
+      cmark_strbuf_putc(dest, c);
+    } else if (c >= CF_MAX) {
+        cmark_strbuf_put(dest, str, char_len);
+    } else if (char_len >= 0) {
+      uint32_t key = c;
+      uint32_t *entry = bsearch(&key, cf_table,
+                                CF_TABLE_SIZE, sizeof(uint32_t),
+                                cf_compare);
+      if (entry == NULL) {
+        cmark_strbuf_put(dest, str, char_len);
+      } else {
+        cmark_strbuf_put(dest, cf_repl + CF_REPL_IDX(*entry),
+                         CF_REPL_SIZE(*entry));
+      }
+    } else {
+      encode_unknown(dest);
+      char_len = -char_len;
+    }
+
+    str += char_len;
+    len -= char_len;
+  }
+}
+
+// matches anything in the Zs class, plus LF, CR, TAB, FF.
+int cmark_utf8proc_is_space(int32_t uc) {
+  return (uc == 9 || uc == 10 || uc == 12 || uc == 13 || uc == 32 ||
+          uc == 160 || uc == 5760 || (uc >= 8192 && uc <= 8202) || uc == 8239 ||
+          uc == 8287 || uc == 12288);
+}
+
+// matches anything in the P or S classes.
+int cmark_utf8proc_is_punctuation_or_symbol(int32_t uc) {
+  if (uc < 128) {
+    return cmark_ispunct((char)uc);
+  } else {
+    return (
+        uc > 128 &&
+        ((uc >= 161 && uc <= 169) || (uc >= 171 && uc <= 172) ||
+         (uc >= 174 && uc <= 177) || (uc == 180) || (uc >= 182 && uc <= 184) ||
+         (uc == 187) || (uc == 191) || (uc == 215) || (uc == 247) ||
+         (uc >= 706 && uc <= 709) || (uc >= 722 && uc <= 735) ||
+         (uc >= 741 && uc <= 747) || (uc == 749) || (uc >= 751 && uc <= 767) ||
+         (uc == 885) || (uc == 894) || (uc >= 900 && uc <= 901) ||
+         (uc == 903) || (uc == 1014) || (uc == 1154) ||
+         (uc >= 1370 && uc <= 1375) || (uc >= 1417 && uc <= 1418) ||
+         (uc >= 1421 && uc <= 1423) || (uc == 1470) || (uc == 1472) ||
+         (uc == 1475) || (uc == 1478) || (uc >= 1523 && uc <= 1524) ||
+         (uc >= 1542 && uc <= 1551) || (uc == 1563) ||
+         (uc >= 1565 && uc <= 1567) || (uc >= 1642 && uc <= 1645) ||
+         (uc == 1748) || (uc == 1758) || (uc == 1769) ||
+         (uc >= 1789 && uc <= 1790) || (uc >= 1792 && uc <= 1805) ||
+         (uc >= 2038 && uc <= 2041) || (uc >= 2046 && uc <= 2047) ||
+         (uc >= 2096 && uc <= 2110) || (uc == 2142) || (uc == 2184) ||
+         (uc >= 2404 && uc <= 2405) || (uc == 2416) ||
+         (uc >= 2546 && uc <= 2547) || (uc >= 2554 && uc <= 2555) ||
+         (uc == 2557) || (uc == 2678) || (uc >= 2800 && uc <= 2801) ||
+         (uc == 2928) || (uc >= 3059 && uc <= 3066) || (uc == 3191) ||
+         (uc == 3199) || (uc == 3204) || (uc == 3407) || (uc == 3449) ||
+         (uc == 3572) || (uc == 3647) || (uc == 3663) ||
+         (uc >= 3674 && uc <= 3675) || (uc >= 3841 && uc <= 3863) ||
+         (uc >= 3866 && uc <= 3871) || (uc == 3892) || (uc == 3894) ||
+         (uc == 3896) || (uc >= 3898 && uc <= 3901) || (uc == 3973) ||
+         (uc >= 4030 && uc <= 4037) || (uc >= 4039 && uc <= 4044) ||
+         (uc >= 4046 && uc <= 4058) || (uc >= 4170 && uc <= 4175) ||
+         (uc >= 4254 && uc <= 4255) || (uc == 4347) ||
+         (uc >= 4960 && uc <= 4968) || (uc >= 5008 && uc <= 5017) ||
+         (uc == 5120) || (uc >= 5741 && uc <= 5742) ||
+         (uc >= 5787 && uc <= 5788) || (uc >= 5867 && uc <= 5869) ||
+         (uc >= 5941 && uc <= 5942) || (uc >= 6100 && uc <= 6102) ||
+         (uc >= 6104 && uc <= 6107) || (uc >= 6144 && uc <= 6154) ||
+         (uc == 6464) || (uc >= 6468 && uc <= 6469) ||
+         (uc >= 6622 && uc <= 6655) || (uc >= 6686 && uc <= 6687) ||
+         (uc >= 6816 && uc <= 6822) || (uc >= 6824 && uc <= 6829) ||
+         (uc >= 7002 && uc <= 7018) || (uc >= 7028 && uc <= 7038) ||
+         (uc >= 7164 && uc <= 7167) || (uc >= 7227 && uc <= 7231) ||
+         (uc >= 7294 && uc <= 7295) || (uc >= 7360 && uc <= 7367) ||
+         (uc == 7379) || (uc == 8125) || (uc >= 8127 && uc <= 8129) ||
+         (uc >= 8141 && uc <= 8143) || (uc >= 8157 && uc <= 8159) ||
+         (uc >= 8173 && uc <= 8175) || (uc >= 8189 && uc <= 8190) ||
+         (uc >= 8208 && uc <= 8231) || (uc >= 8240 && uc <= 8286) ||
+         (uc >= 8314 && uc <= 8318) || (uc >= 8330 && uc <= 8334) ||
+         (uc >= 8352 && uc <= 8384) || (uc >= 8448 && uc <= 8449) ||
+         (uc >= 8451 && uc <= 8454) || (uc >= 8456 && uc <= 8457) ||
+         (uc == 8468) || (uc >= 8470 && uc <= 8472) ||
+         (uc >= 8478 && uc <= 8483) || (uc == 8485) || (uc == 8487) ||
+         (uc == 8489) || (uc == 8494) || (uc >= 8506 && uc <= 8507) ||
+         (uc >= 8512 && uc <= 8516) || (uc >= 8522 && uc <= 8525) ||
+         (uc == 8527) || (uc >= 8586 && uc <= 8587) ||
+         (uc >= 8592 && uc <= 9254) || (uc >= 9280 && uc <= 9290) ||
+         (uc >= 9372 && uc <= 9449) || (uc >= 9472 && uc <= 10101) ||
+         (uc >= 10132 && uc <= 11123) || (uc >= 11126 && uc <= 11157) ||
+         (uc >= 11159 && uc <= 11263) || (uc >= 11493 && uc <= 11498) ||
+         (uc >= 11513 && uc <= 11516) || (uc >= 11518 && uc <= 11519) ||
+         (uc == 11632) || (uc >= 11776 && uc <= 11822) ||
+         (uc >= 11824 && uc <= 11869) || (uc >= 11904 && uc <= 11929) ||
+         (uc >= 11931 && uc <= 12019) || (uc >= 12032 && uc <= 12245) ||
+         (uc >= 12272 && uc <= 12283) || (uc >= 12289 && uc <= 12292) ||
+         (uc >= 12296 && uc <= 12320) || (uc == 12336) ||
+         (uc >= 12342 && uc <= 12343) || (uc >= 12349 && uc <= 12351) ||
+         (uc >= 12443 && uc <= 12444) || (uc == 12448) || (uc == 12539) ||
+         (uc >= 12688 && uc <= 12689) || (uc >= 12694 && uc <= 12703) ||
+         (uc >= 12736 && uc <= 12771) || (uc >= 12800 && uc <= 12830) ||
+         (uc >= 12842 && uc <= 12871) || (uc == 12880) ||
+         (uc >= 12896 && uc <= 12927) || (uc >= 12938 && uc <= 12976) ||
+         (uc >= 12992 && uc <= 13311) || (uc >= 19904 && uc <= 19967) ||
+         (uc >= 42128 && uc <= 42182) || (uc >= 42238 && uc <= 42239) ||
+         (uc >= 42509 && uc <= 42511) || (uc == 42611) || (uc == 42622) ||
+         (uc >= 42738 && uc <= 42743) || (uc >= 42752 && uc <= 42774) ||
+         (uc >= 42784 && uc <= 42785) || (uc >= 42889 && uc <= 42890) ||
+         (uc >= 43048 && uc <= 43051) || (uc >= 43062 && uc <= 43065) ||
+         (uc >= 43124 && uc <= 43127) || (uc >= 43214 && uc <= 43215) ||
+         (uc >= 43256 && uc <= 43258) || (uc == 43260) ||
+         (uc >= 43310 && uc <= 43311) || (uc == 43359) ||
+         (uc >= 43457 && uc <= 43469) || (uc >= 43486 && uc <= 43487) ||
+         (uc >= 43612 && uc <= 43615) || (uc >= 43639 && uc <= 43641) ||
+         (uc >= 43742 && uc <= 43743) || (uc >= 43760 && uc <= 43761) ||
+         (uc == 43867) || (uc >= 43882 && uc <= 43883) || (uc == 44011) ||
+         (uc == 64297) || (uc >= 64434 && uc <= 64450) ||
+         (uc >= 64830 && uc <= 64847) || (uc == 64975) ||
+         (uc >= 65020 && uc <= 65023) || (uc >= 65040 && uc <= 65049) ||
+         (uc >= 65072 && uc <= 65106) || (uc >= 65108 && uc <= 65126) ||
+         (uc >= 65128 && uc <= 65131) || (uc >= 65281 && uc <= 65295) ||
+         (uc >= 65306 && uc <= 65312) || (uc >= 65339 && uc <= 65344) ||
+         (uc >= 65371 && uc <= 65381) || (uc >= 65504 && uc <= 65510) ||
+         (uc >= 65512 && uc <= 65518) || (uc >= 65532 && uc <= 65533) ||
+         (uc >= 65792 && uc <= 65794) || (uc >= 65847 && uc <= 65855) ||
+         (uc >= 65913 && uc <= 65929) || (uc >= 65932 && uc <= 65934) ||
+         (uc >= 65936 && uc <= 65948) || (uc == 65952) ||
+         (uc >= 66000 && uc <= 66044) || (uc == 66463) || (uc == 66512) ||
+         (uc == 66927) || (uc == 67671) || (uc >= 67703 && uc <= 67704) ||
+         (uc == 67871) || (uc == 67903) || (uc >= 68176 && uc <= 68184) ||
+         (uc == 68223) || (uc == 68296) || (uc >= 68336 && uc <= 68342) ||
+         (uc >= 68409 && uc <= 68415) || (uc >= 68505 && uc <= 68508) ||
+         (uc == 69293) || (uc >= 69461 && uc <= 69465) ||
+         (uc >= 69510 && uc <= 69513) || (uc >= 69703 && uc <= 69709) ||
+         (uc >= 69819 && uc <= 69820) || (uc >= 69822 && uc <= 69825) ||
+         (uc >= 69952 && uc <= 69955) || (uc >= 70004 && uc <= 70005) ||
+         (uc >= 70085 && uc <= 70088) || (uc == 70093) || (uc == 70107) ||
+         (uc >= 70109 && uc <= 70111) || (uc >= 70200 && uc <= 70205) ||
+         (uc == 70313) || (uc >= 70731 && uc <= 70735) ||
+         (uc >= 70746 && uc <= 70747) || (uc == 70749) || (uc == 70854) ||
+         (uc >= 71105 && uc <= 71127) || (uc >= 71233 && uc <= 71235) ||
+         (uc >= 71264 && uc <= 71276) || (uc == 71353) ||
+         (uc >= 71484 && uc <= 71487) || (uc == 71739) ||
+         (uc >= 72004 && uc <= 72006) || (uc == 72162) ||
+         (uc >= 72255 && uc <= 72262) || (uc >= 72346 && uc <= 72348) ||
+         (uc >= 72350 && uc <= 72354) || (uc >= 72448 && uc <= 72457) ||
+         (uc >= 72769 && uc <= 72773) || (uc >= 72816 && uc <= 72817) ||
+         (uc >= 73463 && uc <= 73464) || (uc >= 73539 && uc <= 73551) ||
+         (uc >= 73685 && uc <= 73713) || (uc == 73727) ||
+         (uc >= 74864 && uc <= 74868) || (uc >= 77809 && uc <= 77810) ||
+         (uc >= 92782 && uc <= 92783) || (uc == 92917) ||
+         (uc >= 92983 && uc <= 92991) || (uc >= 92996 && uc <= 92997) ||
+         (uc >= 93847 && uc <= 93850) || (uc == 94178) || (uc == 113820) ||
+         (uc == 113823) || (uc >= 118608 && uc <= 118723) ||
+         (uc >= 118784 && uc <= 119029) || (uc >= 119040 && uc <= 119078) ||
+         (uc >= 119081 && uc <= 119140) || (uc >= 119146 && uc <= 119148) ||
+         (uc >= 119171 && uc <= 119172) || (uc >= 119180 && uc <= 119209) ||
+         (uc >= 119214 && uc <= 119274) || (uc >= 119296 && uc <= 119361) ||
+         (uc == 119365) || (uc >= 119552 && uc <= 119638) || (uc == 120513) ||
+         (uc == 120539) || (uc == 120571) || (uc == 120597) || (uc == 120629) ||
+         (uc == 120655) || (uc == 120687) || (uc == 120713) || (uc == 120745) ||
+         (uc == 120771) || (uc >= 120832 && uc <= 121343) ||
+         (uc >= 121399 && uc <= 121402) || (uc >= 121453 && uc <= 121460) ||
+         (uc >= 121462 && uc <= 121475) || (uc >= 121477 && uc <= 121483) ||
+         (uc == 123215) || (uc == 123647) || (uc >= 125278 && uc <= 125279) ||
+         (uc == 126124) || (uc == 126128) || (uc == 126254) ||
+         (uc >= 126704 && uc <= 126705) || (uc >= 126976 && uc <= 127019) ||
+         (uc >= 127024 && uc <= 127123) || (uc >= 127136 && uc <= 127150) ||
+         (uc >= 127153 && uc <= 127167) || (uc >= 127169 && uc <= 127183) ||
+         (uc >= 127185 && uc <= 127221) || (uc >= 127245 && uc <= 127405) ||
+         (uc >= 127462 && uc <= 127490) || (uc >= 127504 && uc <= 127547) ||
+         (uc >= 127552 && uc <= 127560) || (uc >= 127568 && uc <= 127569) ||
+         (uc >= 127584 && uc <= 127589) || (uc >= 127744 && uc <= 128727) ||
+         (uc >= 128732 && uc <= 128748) || (uc >= 128752 && uc <= 128764) ||
+         (uc >= 128768 && uc <= 128886) || (uc >= 128891 && uc <= 128985) ||
+         (uc >= 128992 && uc <= 129003) || (uc == 129008) ||
+         (uc >= 129024 && uc <= 129035) || (uc >= 129040 && uc <= 129095) ||
+         (uc >= 129104 && uc <= 129113) || (uc >= 129120 && uc <= 129159) ||
+         (uc >= 129168 && uc <= 129197) || (uc >= 129200 && uc <= 129201) ||
+         (uc >= 129280 && uc <= 129619) || (uc >= 129632 && uc <= 129645) ||
+         (uc >= 129648 && uc <= 129660) || (uc >= 129664 && uc <= 129672) ||
+         (uc >= 129680 && uc <= 129725) || (uc >= 129727 && uc <= 129733) ||
+         (uc >= 129742 && uc <= 129755) || (uc >= 129760 && uc <= 129768) ||
+         (uc >= 129776 && uc <= 129784) || (uc >= 129792 && uc <= 129938) ||
+         (uc >= 129940 && uc <= 129994)));
+  }
+}
diff --git a/cmark/src/utf8.h b/cmark/src/utf8.h
new file mode 100644
index 0000000000..4b84c19c8d
--- /dev/null
+++ b/cmark/src/utf8.h
@@ -0,0 +1,24 @@
+#ifndef CMARK_UTF8_H
+#define CMARK_UTF8_H
+
+#include <stdint.h>
+#include "buffer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str,
+                              bufsize_t len);
+void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf);
+int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst);
+void cmark_utf8proc_check(cmark_strbuf *dest, const uint8_t *line,
+                          bufsize_t size);
+int cmark_utf8proc_is_space(int32_t uc);
+int cmark_utf8proc_is_punctuation_or_symbol(int32_t uc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cmark/src/xml.c b/cmark/src/xml.c
new file mode 100644
index 0000000000..2ca2de82ce
--- /dev/null
+++ b/cmark/src/xml.c
@@ -0,0 +1,229 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+
+#define BUFFER_SIZE 100
+#define MAX_INDENT 40
+
+// Functions to convert cmark_nodes to XML strings.
+
+// C0 control characters, U+FFFE and U+FFF aren't allowed in XML.
+static const char XML_ESCAPE_TABLE[256] = {
+    /* 0x00 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1,
+    /* 0x10 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    /* 0x20 */ 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0,
+    /* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x80 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x90 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0xA0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0xB0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9,
+    /* 0xC0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0xD0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0xE0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0xF0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+// U+FFFD Replacement Character encoded in UTF-8
+#define UTF8_REPL "\xEF\xBF\xBD"
+
+static const char *XML_ESCAPES[] = {
+  "", UTF8_REPL, "&quot;", "&amp;", "&lt;", "&gt;"
+};
+
+static void escape_xml(cmark_strbuf *ob, const unsigned char *src,
+                       bufsize_t size) {
+  bufsize_t i = 0, org, esc = 0;
+
+  while (i < size) {
+    org = i;
+    while (i < size && (esc = XML_ESCAPE_TABLE[src[i]]) == 0)
+      i++;
+
+    if (i > org)
+      cmark_strbuf_put(ob, src + org, i - org);
+
+    if (i >= size)
+      break;
+
+    if (esc == 9) {
+      // To replace U+FFFE and U+FFFF with U+FFFD, only the last byte has to
+      // be changed.
+      // We know that src[i] is 0xBE or 0xBF.
+      if (i >= 2 && src[i-2] == 0xEF && src[i-1] == 0xBF) {
+        cmark_strbuf_putc(ob, 0xBD);
+      } else {
+        cmark_strbuf_putc(ob, src[i]);
+      }
+    } else {
+      cmark_strbuf_puts(ob, XML_ESCAPES[esc]);
+    }
+
+    i++;
+  }
+}
+
+static void escape_xml_str(cmark_strbuf *dest, const unsigned char *source) {
+  if (source)
+    escape_xml(dest, source, (bufsize_t)strlen((char *)source));
+}
+
+struct render_state {
+  cmark_strbuf *xml;
+  int indent;
+};
+
+static inline void indent(struct render_state *state) {
+  int i;
+  for (i = 0; i < state->indent && i < MAX_INDENT; i++) {
+    cmark_strbuf_putc(state->xml, ' ');
+  }
+}
+
+static int S_render_node(cmark_node *node, cmark_event_type ev_type,
+                         struct render_state *state, int options) {
+  cmark_strbuf *xml = state->xml;
+  bool literal = false;
+  cmark_delim_type delim;
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  char buffer[BUFFER_SIZE];
+
+  if (entering) {
+    indent(state);
+    cmark_strbuf_putc(xml, '<');
+    cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
+
+    if (options & CMARK_OPT_SOURCEPOS && node->start_line != 0) {
+      snprintf(buffer, BUFFER_SIZE, " sourcepos=\"%d:%d-%d:%d\"",
+               node->start_line, node->start_column, node->end_line,
+               node->end_column);
+      cmark_strbuf_puts(xml, buffer);
+    }
+
+    literal = false;
+
+    switch (node->type) {
+    case CMARK_NODE_DOCUMENT:
+      cmark_strbuf_puts(xml, " xmlns=\"http://commonmark.org/xml/1.0\"");
+      break;
+    case CMARK_NODE_TEXT:
+    case CMARK_NODE_CODE:
+    case CMARK_NODE_HTML_BLOCK:
+    case CMARK_NODE_HTML_INLINE:
+      cmark_strbuf_puts(xml, " xml:space=\"preserve\">");
+      escape_xml(xml, node->data, node->len);
+      cmark_strbuf_puts(xml, "</");
+      cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
+      literal = true;
+      break;
+    case CMARK_NODE_LIST:
+      switch (cmark_node_get_list_type(node)) {
+      case CMARK_ORDERED_LIST:
+        cmark_strbuf_puts(xml, " type=\"ordered\"");
+        snprintf(buffer, BUFFER_SIZE, " start=\"%d\"",
+                 cmark_node_get_list_start(node));
+        cmark_strbuf_puts(xml, buffer);
+        delim = cmark_node_get_list_delim(node);
+        if (delim == CMARK_PAREN_DELIM) {
+          cmark_strbuf_puts(xml, " delimiter=\"paren\"");
+        } else if (delim == CMARK_PERIOD_DELIM) {
+          cmark_strbuf_puts(xml, " delimiter=\"period\"");
+        }
+        break;
+      case CMARK_BULLET_LIST:
+        cmark_strbuf_puts(xml, " type=\"bullet\"");
+        break;
+      default:
+        break;
+      }
+      snprintf(buffer, BUFFER_SIZE, " tight=\"%s\"",
+               (cmark_node_get_list_tight(node) ? "true" : "false"));
+      cmark_strbuf_puts(xml, buffer);
+      break;
+    case CMARK_NODE_HEADING:
+      snprintf(buffer, BUFFER_SIZE, " level=\"%d\"", node->as.heading.level);
+      cmark_strbuf_puts(xml, buffer);
+      break;
+    case CMARK_NODE_CODE_BLOCK:
+      if (node->as.code.info) {
+        cmark_strbuf_puts(xml, " info=\"");
+        escape_xml_str(xml, node->as.code.info);
+        cmark_strbuf_putc(xml, '"');
+      }
+      cmark_strbuf_puts(xml, " xml:space=\"preserve\">");
+      escape_xml(xml, node->data, node->len);
+      cmark_strbuf_puts(xml, "</");
+      cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
+      literal = true;
+      break;
+    case CMARK_NODE_CUSTOM_BLOCK:
+    case CMARK_NODE_CUSTOM_INLINE:
+      cmark_strbuf_puts(xml, " on_enter=\"");
+      escape_xml_str(xml, node->as.custom.on_enter);
+      cmark_strbuf_putc(xml, '"');
+      cmark_strbuf_puts(xml, " on_exit=\"");
+      escape_xml_str(xml, node->as.custom.on_exit);
+      cmark_strbuf_putc(xml, '"');
+      break;
+    case CMARK_NODE_LINK:
+    case CMARK_NODE_IMAGE:
+      cmark_strbuf_puts(xml, " destination=\"");
+      escape_xml_str(xml, node->as.link.url);
+      cmark_strbuf_putc(xml, '"');
+      if (node->as.link.title) {
+        cmark_strbuf_puts(xml, " title=\"");
+        escape_xml_str(xml, node->as.link.title);
+        cmark_strbuf_putc(xml, '"');
+      }
+      break;
+    default:
+      break;
+    }
+    if (node->first_child) {
+      state->indent += 2;
+    } else if (!literal) {
+      cmark_strbuf_puts(xml, " /");
+    }
+    cmark_strbuf_puts(xml, ">\n");
+
+  } else if (node->first_child) {
+    state->indent -= 2;
+    indent(state);
+    cmark_strbuf_puts(xml, "</");
+    cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
+    cmark_strbuf_puts(xml, ">\n");
+  }
+
+  return 1;
+}
+
+char *cmark_render_xml(cmark_node *root, int options) {
+  char *result;
+  cmark_strbuf xml = CMARK_BUF_INIT(root->mem);
+  cmark_event_type ev_type;
+  cmark_node *cur;
+  struct render_state state = {&xml, 0};
+
+  cmark_iter *iter = cmark_iter_new(root);
+
+  cmark_strbuf_puts(state.xml, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+  cmark_strbuf_puts(state.xml,
+                    "<!DOCTYPE document SYSTEM \"CommonMark.dtd\">\n");
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    S_render_node(cur, ev_type, &state, options);
+  }
+  result = (char *)cmark_strbuf_detach(&xml);
+
+  cmark_iter_free(iter);
+  return result;
+}