diff --git a/CMarkGFM.hsc b/CMarkGFM.hsc
--- a/CMarkGFM.hsc
+++ b/CMarkGFM.hsc
@@ -49,16 +49,16 @@
 import Data.Text.Encoding (encodeUtf8)
 import Control.Applicative ((<$>), (<*>))
 
-#include <cmark.h>
-#include <core-extensions.h>
+#include <cmark-gfm.h>
+#include <cmark-gfm-core-extensions.h>
 
 -- | Ensure core extensions are registered.
 ensurePluginsRegistered :: IO ()
-ensurePluginsRegistered = c_core_extensions_ensure_registered
+ensurePluginsRegistered = c_cmark_gfm_core_extensions_ensure_registered
 
 -- | Frees a cmark linked list, produced by extsToLlist.
 freeLlist :: LlistPtr a -> IO ()
-freeLlist = c_cmark_llist_free c_CMARK_DEFAULT_MEM_ALLOCATOR
+freeLlist = c_cmark_llist_free c_cmark_mem
 
 -- | Converts a list of resolved extension pointers to a single cmark
 -- linked list, which can be passed to functions requiring a list of
@@ -67,7 +67,7 @@
 extsToLlist [] = return nullPtr
 extsToLlist (h:t) = do
   t' <- extsToLlist t
-  c_cmark_llist_append c_CMARK_DEFAULT_MEM_ALLOCATOR t' (castPtr h)
+  c_cmark_llist_append c_cmark_mem t' (castPtr h)
 
 -- | Resolves CMarkExtensions to pointers.
 resolveExts :: [CMarkExtension] -> IO [ExtensionPtr]
@@ -377,8 +377,8 @@
         title     = c_cmark_node_get_title ptr >>= totext
         info      = c_cmark_node_get_fence_info ptr >>= totext
         alignments = do
-          ncols <- c_cmarkextensions_get_table_columns ptr
-          cols <- c_cmarkextensions_get_table_alignments ptr
+          ncols <- c_cmark_gfm_extensions_get_table_columns ptr
+          cols <- c_cmark_gfm_extensions_get_table_alignments ptr
           mapM (fmap ucharToAlignment . peekElemOff cols) [0..(fromIntegral ncols) - 1]
         ucharToAlignment (CUChar 108) = LeftAligned
         ucharToAlignment (CUChar 99)  = CenterAligned
@@ -498,145 +498,145 @@
 foreign import ccall "string.h strlen"
     c_strlen :: CString -> Int
 
-foreign import ccall "cmark.h cmark_node_new"
+foreign import ccall "cmark-gfm.h cmark_node_new"
     c_cmark_node_new :: Int -> IO NodePtr
 
-foreign import ccall "cmark.h cmark_render_html"
+foreign import ccall "cmark-gfm.h cmark_render_html"
     c_cmark_render_html :: NodePtr -> CInt -> LlistPtr ExtensionPtr -> IO CString
 
-foreign import ccall "cmark.h cmark_render_xml"
+foreign import ccall "cmark-gfm.h cmark_render_xml"
     c_cmark_render_xml :: NodePtr -> CInt -> IO CString
 
-foreign import ccall "cmark.h cmark_render_man"
+foreign import ccall "cmark-gfm.h cmark_render_man"
     c_cmark_render_man :: NodePtr -> CInt -> Int -> IO CString
 
-foreign import ccall "cmark.h cmark_render_latex"
+foreign import ccall "cmark-gfm.h cmark_render_latex"
     c_cmark_render_latex :: NodePtr -> CInt -> Int -> IO CString
 
-foreign import ccall "cmark.h cmark_render_commonmark"
+foreign import ccall "cmark-gfm.h cmark_render_commonmark"
     c_cmark_render_commonmark :: NodePtr -> CInt -> Int -> IO CString
 
-foreign import ccall "cmark.h cmark_parser_new"
+foreign import ccall "cmark-gfm.h cmark_parser_new"
     c_cmark_parser_new :: CInt -> IO ParserPtr
 
-foreign import ccall "cmark.h cmark_parser_feed"
+foreign import ccall "cmark-gfm.h cmark_parser_feed"
     c_cmark_parser_feed :: ParserPtr -> CString -> Int -> IO ()
 
-foreign import ccall "cmark.h cmark_parser_finish"
+foreign import ccall "cmark-gfm.h cmark_parser_finish"
     c_cmark_parser_finish :: ParserPtr -> IO NodePtr
 
-foreign import ccall "cmark.h cmark_parser_free"
+foreign import ccall "cmark-gfm.h cmark_parser_free"
     c_cmark_parser_free :: ParserPtr -> IO ()
 
-foreign import ccall "cmark.h cmark_node_get_type"
+foreign import ccall "cmark-gfm.h cmark_node_get_type"
     c_cmark_node_get_type :: NodePtr -> IO Int
 
-foreign import ccall "cmark.h cmark_node_first_child"
+foreign import ccall "cmark-gfm.h cmark_node_first_child"
     c_cmark_node_first_child :: NodePtr -> IO NodePtr
 
-foreign import ccall "cmark.h cmark_node_next"
+foreign import ccall "cmark-gfm.h cmark_node_next"
     c_cmark_node_next :: NodePtr -> IO NodePtr
 
-foreign import ccall "cmark.h cmark_node_get_literal"
+foreign import ccall "cmark-gfm.h cmark_node_get_literal"
     c_cmark_node_get_literal :: NodePtr -> IO CString
 
-foreign import ccall "cmark.h cmark_node_get_url"
+foreign import ccall "cmark-gfm.h cmark_node_get_url"
     c_cmark_node_get_url :: NodePtr -> IO CString
 
-foreign import ccall "cmark.h cmark_node_get_title"
+foreign import ccall "cmark-gfm.h cmark_node_get_title"
     c_cmark_node_get_title :: NodePtr -> IO CString
 
-foreign import ccall "cmark.h cmark_node_get_heading_level"
+foreign import ccall "cmark-gfm.h cmark_node_get_heading_level"
     c_cmark_node_get_heading_level :: NodePtr -> IO Int
 
-foreign import ccall "cmark.h cmark_node_get_list_type"
+foreign import ccall "cmark-gfm.h cmark_node_get_list_type"
     c_cmark_node_get_list_type :: NodePtr -> IO Int
 
-foreign import ccall "cmark.h cmark_node_get_list_tight"
+foreign import ccall "cmark-gfm.h cmark_node_get_list_tight"
     c_cmark_node_get_list_tight :: NodePtr -> IO Bool
 
-foreign import ccall "cmark.h cmark_node_get_list_start"
+foreign import ccall "cmark-gfm.h cmark_node_get_list_start"
     c_cmark_node_get_list_start :: NodePtr -> IO Int
 
-foreign import ccall "cmark.h cmark_node_get_list_delim"
+foreign import ccall "cmark-gfm.h cmark_node_get_list_delim"
     c_cmark_node_get_list_delim :: NodePtr -> IO Int
 
-foreign import ccall "cmark.h cmark_node_get_fence_info"
+foreign import ccall "cmark-gfm.h cmark_node_get_fence_info"
     c_cmark_node_get_fence_info :: NodePtr -> IO CString
 
-foreign import ccall "cmark.h cmark_node_get_start_line"
+foreign import ccall "cmark-gfm.h cmark_node_get_start_line"
     c_cmark_node_get_start_line :: NodePtr -> IO Int
 
-foreign import ccall "cmark.h cmark_node_get_start_column"
+foreign import ccall "cmark-gfm.h cmark_node_get_start_column"
     c_cmark_node_get_start_column :: NodePtr -> IO Int
 
-foreign import ccall "cmark.h cmark_node_get_end_line"
+foreign import ccall "cmark-gfm.h cmark_node_get_end_line"
     c_cmark_node_get_end_line :: NodePtr -> IO Int
 
-foreign import ccall "cmark.h cmark_node_get_end_column"
+foreign import ccall "cmark-gfm.h cmark_node_get_end_column"
     c_cmark_node_get_end_column :: NodePtr -> IO Int
 
-foreign import ccall "cmark.h cmark_node_get_on_enter"
+foreign import ccall "cmark-gfm.h cmark_node_get_on_enter"
     c_cmark_node_get_on_enter :: NodePtr -> IO CString
 
-foreign import ccall "cmark.h cmark_node_get_on_exit"
+foreign import ccall "cmark-gfm.h cmark_node_get_on_exit"
     c_cmark_node_get_on_exit :: NodePtr -> IO CString
 
-foreign import ccall "cmark.h cmark_node_append_child"
+foreign import ccall "cmark-gfm.h cmark_node_append_child"
     c_cmark_node_append_child :: NodePtr -> NodePtr -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_literal"
+foreign import ccall "cmark-gfm.h cmark_node_set_literal"
     c_cmark_node_set_literal :: NodePtr -> CString -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_url"
+foreign import ccall "cmark-gfm.h cmark_node_set_url"
     c_cmark_node_set_url :: NodePtr -> CString -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_title"
+foreign import ccall "cmark-gfm.h cmark_node_set_title"
     c_cmark_node_set_title :: NodePtr -> CString -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_heading_level"
+foreign import ccall "cmark-gfm.h cmark_node_set_heading_level"
     c_cmark_node_set_heading_level :: NodePtr -> Int -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_list_type"
+foreign import ccall "cmark-gfm.h cmark_node_set_list_type"
     c_cmark_node_set_list_type :: NodePtr -> Int -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_list_tight"
+foreign import ccall "cmark-gfm.h cmark_node_set_list_tight"
     c_cmark_node_set_list_tight :: NodePtr -> Bool -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_list_start"
+foreign import ccall "cmark-gfm.h cmark_node_set_list_start"
     c_cmark_node_set_list_start :: NodePtr -> Int -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_list_delim"
+foreign import ccall "cmark-gfm.h cmark_node_set_list_delim"
     c_cmark_node_set_list_delim :: NodePtr -> Int -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_fence_info"
+foreign import ccall "cmark-gfm.h cmark_node_set_fence_info"
     c_cmark_node_set_fence_info :: NodePtr -> CString -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_on_enter"
+foreign import ccall "cmark-gfm.h cmark_node_set_on_enter"
     c_cmark_node_set_on_enter :: NodePtr -> CString -> IO Int
 
-foreign import ccall "cmark.h cmark_node_set_on_exit"
+foreign import ccall "cmark-gfm.h cmark_node_set_on_exit"
     c_cmark_node_set_on_exit :: NodePtr -> CString -> IO Int
 
-foreign import ccall "cmark.h &cmark_node_free"
+foreign import ccall "cmark-gfm.h &cmark_node_free"
     c_cmark_node_free :: FunPtr (NodePtr -> IO ())
 
-foreign import ccall "core-extensions.h core_extensions_ensure_registered"
-    c_core_extensions_ensure_registered :: IO ()
+foreign import ccall "cmark-gfm-core-extensions.h cmark_gfm_core_extensions_ensure_registered"
+    c_cmark_gfm_core_extensions_ensure_registered :: IO ()
 
-foreign import ccall "cmark_extension_api.h cmark_find_syntax_extension"
+foreign import ccall "cmark-gfm-extension_api.h cmark_find_syntax_extension"
     c_cmark_find_syntax_extension :: CString -> IO ExtensionPtr
 
-foreign import ccall "cmark.h cmark_llist_append"
+foreign import ccall "cmark-gfm.h cmark_llist_append"
     c_cmark_llist_append :: MemPtr -> LlistPtr a -> Ptr () -> IO (LlistPtr a)
 
-foreign import ccall "cmark.h cmark_llist_free"
+foreign import ccall "cmark-gfm.h cmark_llist_free"
     c_cmark_llist_free :: MemPtr -> LlistPtr a -> IO ()
 
-foreign import ccall "cmark.h &CMARK_DEFAULT_MEM_ALLOCATOR"
-    c_CMARK_DEFAULT_MEM_ALLOCATOR :: MemPtr
+foreign import ccall "cmark-gfm.h cmark_get_default_mem_allocator"
+    c_cmark_mem :: MemPtr
 
-foreign import ccall "cmark_extension_api.h cmark_parser_attach_syntax_extension"
+foreign import ccall "cmark-gfm-extension_api.h cmark_parser_attach_syntax_extension"
     c_cmark_parser_attach_syntax_extension :: ParserPtr -> ExtensionPtr -> IO ()
 
 foreign import ccall "strikethrough.h &CMARK_NODE_STRIKETHROUGH"
@@ -651,8 +651,8 @@
 foreign import ccall "table.h &CMARK_NODE_TABLE_CELL"
     c_CMARK_NODE_TABLE_CELL :: Ptr #type cmark_node_type
 
-foreign import ccall "core-extensions.h cmarkextensions_get_table_columns"
-    c_cmarkextensions_get_table_columns :: NodePtr -> IO CUShort
+foreign import ccall "cmark-gfm-core-extensions.h cmark_gfm_extensions_get_table_columns"
+    c_cmark_gfm_extensions_get_table_columns :: NodePtr -> IO CUShort
 
-foreign import ccall "core-extensions.h cmarkextensions_get_table_alignments"
-    c_cmarkextensions_get_table_alignments :: NodePtr -> IO (Ptr CUChar)
+foreign import ccall "cmark-gfm-core-extensions.h cmark_gfm_extensions_get_table_alignments"
+    c_cmark_gfm_extensions_get_table_alignments :: NodePtr -> IO (Ptr CUChar)
diff --git a/bench/bench-cmark.hs b/bench/bench-cmark.hs
--- a/bench/bench-cmark.hs
+++ b/bench/bench-cmark.hs
@@ -20,7 +20,7 @@
       mkBench "cheapskate" (T.concat . toChunks . Blaze.renderHtml . CheapskateHtml.renderDoc . Cheapskate.markdown Cheapskate.def) sample
     , mkBench "discount" (Discount.parseMarkdownUtf8 []) sample
     , mkBench "markdown" (T.concat . toChunks . Blaze.renderHtml . Markdown.markdown Markdown.def . fromChunks . (:[])) sample
-    , mkBench "cmark" (CMarkGFM.commonmarkToHtml []) sample
+    , mkBench "cmark" (CMarkGFM.commonmarkToHtml [] []) sample
      ]
 
 -- Note: when full-sample.md rather than sample.md is used markdown
diff --git a/cbits/arena.c b/cbits/arena.c
--- a/cbits/arena.c
+++ b/cbits/arena.c
@@ -1,8 +1,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
-#include "cmark.h"
-#include "cmark_extension_api.h"
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
 
 static struct arena_chunk {
   size_t sz, used;
diff --git a/cbits/autolink.c b/cbits/autolink.c
--- a/cbits/autolink.c
+++ b/cbits/autolink.c
@@ -319,7 +319,7 @@
 
     if (c == '@')
       nb++;
-    else if (c == '.' && link_end < size - 1)
+    else if (c == '.' && link_end < size - 1 && cmark_isalnum(data[link_end + 1]))
       np++;
     else if (c != '-' && c != '_')
       break;
diff --git a/cbits/autolink.h b/cbits/autolink.h
--- a/cbits/autolink.h
+++ b/cbits/autolink.h
@@ -1,7 +1,7 @@
-#ifndef AUTOLINK_H
-#define AUTOLINK_H
+#ifndef CMARK_GFM_AUTOLINK_H
+#define CMARK_GFM_AUTOLINK_H
 
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 
 cmark_syntax_extension *create_autolink_extension(void);
 
diff --git a/cbits/blocks.c b/cbits/blocks.c
--- a/cbits/blocks.c
+++ b/cbits/blocks.c
@@ -13,7 +13,7 @@
 #include "syntax_extension.h"
 #include "config.h"
 #include "parser.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "references.h"
 #include "utf8.h"
@@ -21,6 +21,7 @@
 #include "inlines.h"
 #include "houdini.h"
 #include "buffer.h"
+#include "footnotes.h"
 
 #define CODE_INDENT 4
 #define TAB_STOP 4
@@ -97,7 +98,7 @@
     cmark_node_free(parser->root);
 
   if (parser->refmap)
-    cmark_reference_map_free(parser->refmap);
+    cmark_map_free(parser->refmap);
 }
 
 static void cmark_parser_reset(cmark_parser *parser) {
@@ -281,17 +282,21 @@
 
   switch (S_type(b)) {
   case CMARK_NODE_PARAGRAPH:
-    while (cmark_strbuf_at(node_content, 0) == '[' &&
-           (pos = cmark_parse_reference_inline(parser->mem, node_content,
-                                               parser->refmap))) {
+  {
+    cmark_chunk chunk = {node_content->ptr, node_content->size, 0};
+    while (chunk.len && chunk.data[0] == '[' &&
+           (pos = cmark_parse_reference_inline(parser->mem, &chunk, parser->refmap))) {
 
-      cmark_strbuf_drop(node_content, pos);
+      chunk.data += pos;
+      chunk.len -= pos;
     }
+    cmark_strbuf_drop(node_content, (node_content->size - chunk.len));
     if (is_blank(node_content, 0)) {
       // remove blank node (former reference def)
       cmark_node_free(b);
     }
     break;
+  }
 
   case CMARK_NODE_CODE_BLOCK:
     if (!b->as.code.fenced) { // indented code
@@ -385,7 +390,7 @@
   return child;
 }
 
-void cmark_manage_extensions_special_characters(cmark_parser *parser, bool add) {
+void cmark_manage_extensions_special_characters(cmark_parser *parser, int add) {
   cmark_llist *tmp_ext;
 
   for (tmp_ext = parser->inline_syntax_extensions; tmp_ext; tmp_ext=tmp_ext->next) {
@@ -394,9 +399,9 @@
     for (tmp_char = ext->special_inline_chars; tmp_char; tmp_char=tmp_char->next) {
       unsigned char c = (unsigned char)(size_t)tmp_char->data;
       if (add)
-        cmark_inlines_add_special_character(c);
+        cmark_inlines_add_special_character(c, ext->emphasis);
       else
-        cmark_inlines_remove_special_character(c);
+        cmark_inlines_remove_special_character(c, ext->emphasis);
     }
   }
 }
@@ -404,7 +409,7 @@
 // Walk through node and all children, recursively, parsing
 // string content into inline content where appropriate.
 static void process_inlines(cmark_parser *parser,
-                            cmark_reference_map *refmap, int options) {
+                            cmark_map *refmap, int options) {
   cmark_iter *iter = cmark_iter_new(parser->root);
   cmark_node *cur;
   cmark_event_type ev_type;
@@ -425,6 +430,84 @@
   cmark_iter_free(iter);
 }
 
+static int sort_footnote_by_ix(const void *_a, const void *_b) {
+  cmark_footnote *a = *(cmark_footnote **)_a;
+  cmark_footnote *b = *(cmark_footnote **)_b;
+  return (int)a->ix - (int)b->ix;
+}
+
+static void process_footnotes(cmark_parser *parser) {
+  // * Collect definitions in a map.
+  // * Iterate the references in the document in order, assigning indices to
+  //   definitions in the order they're seen.
+  // * Write out the footnotes at the bottom of the document in index order.
+
+  cmark_map *map = cmark_footnote_map_new(parser->mem);
+
+  cmark_iter *iter = cmark_iter_new(parser->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_EXIT && cur->type == CMARK_NODE_FOOTNOTE_DEFINITION) {
+      cmark_node_unlink(cur);
+      cmark_footnote_create(map, cur);
+    }
+  }
+
+  cmark_iter_free(iter);
+  iter = cmark_iter_new(parser->root);
+  unsigned int ix = 0;
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    if (ev_type == CMARK_EVENT_EXIT && cur->type == CMARK_NODE_FOOTNOTE_REFERENCE) {
+      cmark_footnote *footnote = (cmark_footnote *)cmark_map_lookup(map, &cur->as.literal);
+      if (footnote) {
+        if (!footnote->ix)
+          footnote->ix = ++ix;
+
+        char n[32];
+        snprintf(n, sizeof(n), "%d", footnote->ix);
+        cmark_chunk_free(parser->mem, &cur->as.literal);
+        cmark_strbuf buf = CMARK_BUF_INIT(parser->mem);
+        cmark_strbuf_puts(&buf, n);
+
+        cur->as.literal = cmark_chunk_buf_detach(&buf);
+      } else {
+        cmark_node *text = (cmark_node *)parser->mem->calloc(1, sizeof(*text));
+        cmark_strbuf_init(parser->mem, &text->content, 0);
+        text->type = (uint16_t) CMARK_NODE_TEXT;
+
+        cmark_strbuf buf = CMARK_BUF_INIT(parser->mem);
+        cmark_strbuf_puts(&buf, "[^");
+        cmark_strbuf_put(&buf, cur->as.literal.data, cur->as.literal.len);
+        cmark_strbuf_putc(&buf, ']');
+
+        text->as.literal = cmark_chunk_buf_detach(&buf);
+        cmark_node_insert_after(cur, text);
+        cmark_node_free(cur);
+      }
+    }
+  }
+
+  cmark_iter_free(iter);
+
+  if (map->sorted) {
+    qsort(map->sorted, map->size, sizeof(cmark_map_entry *), sort_footnote_by_ix);
+    for (unsigned int i = 0; i < map->size; ++i) {
+      cmark_footnote *footnote = (cmark_footnote *)map->sorted[i];
+      if (!footnote->ix)
+        continue;
+      cmark_node_append_child(parser->root, footnote->node);
+      footnote->node = NULL;
+    }
+  }
+
+  cmark_map_free(map);
+}
+
 // 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.
@@ -529,6 +612,8 @@
 
   finalize(parser, parser->root);
   process_inlines(parser, parser->refmap, parser->options);
+  if (parser->options & CMARK_OPT_FOOTNOTES)
+    process_footnotes(parser);
 
   return parser->root;
 }
@@ -670,22 +755,24 @@
   char c;
   int chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);
 
-  parser->first_nonspace = parser->offset;
-  parser->first_nonspace_column = parser->column;
-  while ((c = peek_at(input, parser->first_nonspace))) {
-    if (c == ' ') {
-      parser->first_nonspace += 1;
-      parser->first_nonspace_column += 1;
-      chars_to_tab = chars_to_tab - 1;
-      if (chars_to_tab == 0) {
+  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;
       }
-    } else if (c == '\t') {
-      parser->first_nonspace += 1;
-      parser->first_nonspace_column += chars_to_tab;
-      chars_to_tab = TAB_STOP;
-    } else {
-      break;
     }
   }
 
@@ -755,6 +842,18 @@
   return res;
 }
 
+static bool parse_footnote_definition_block_prefix(cmark_parser *parser, cmark_chunk *input,
+                                                   cmark_node *container) {
+  if (parser->indent >= 4) {
+    S_advance_offset(parser, input, 4, true);
+    return true;
+  } else if (input->len > 0 && (input->data[0] == '\n' || (input->data[0] == '\r' && input->data[1] == '\n'))) {
+    return true;
+  }
+
+  return false;
+}
+
 static bool parse_node_item_prefix(cmark_parser *parser, cmark_chunk *input,
                                    cmark_node *container) {
   bool res = false;
@@ -909,6 +1008,10 @@
       if (parser->blank)
         goto done;
       break;
+		case CMARK_NODE_FOOTNOTE_DEFINITION:
+			if (!parse_footnote_definition_block_prefix(parser, input, container))
+				goto done;
+			break;
     default:
       break;
     }
@@ -1020,7 +1123,23 @@
       *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 &&
+               parser->options & CMARK_OPT_FOOTNOTES &&
+               (matched = scan_footnote_definition(input, parser->first_nonspace))) {
+      cmark_chunk c = cmark_chunk_dup(input, parser->first_nonspace + 2, matched - 2);
+      cmark_chunk_to_cstr(parser->mem, &c);
+
+      while (c.data[c.len - 1] != ']')
+        --c.len;
+      --c.len;
+
+      S_advance_offset(parser, input, parser->first_nonspace + matched - parser->offset, false);
+      *container = add_child(parser, *container, CMARK_NODE_FOOTNOTE_DEFINITION, parser->first_nonspace + matched + 1);
+      (*container)->as.literal = c;
+
+      (*container)->internal_offset = matched;
     } 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))) {
@@ -1256,6 +1375,9 @@
 
   parser->offset = 0;
   parser->column = 0;
+  parser->first_nonspace = 0;
+  parser->first_nonspace_column = 0;
+  parser->indent = 0;
   parser->blank = false;
   parser->partially_consumed_tab = false;
 
diff --git a/cbits/buffer.h b/cbits/buffer.h
--- a/cbits/buffer.h
+++ b/cbits/buffer.h
@@ -7,14 +7,12 @@
 #include <limits.h>
 #include <stdint.h>
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef int32_t bufsize_t;
-
 typedef struct {
   cmark_mem *mem;
   unsigned char *ptr;
@@ -32,32 +30,32 @@
  * For the cases where CMARK_BUF_INIT cannot be used to do static
  * initialization.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf,
                        bufsize_t initial_size);
 
 /**
  * Grow the buffer to hold at least `target_size` bytes.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_free(cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 bufsize_t cmark_strbuf_len(const cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 unsigned char *cmark_strbuf_detach(cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize,
                             const cmark_strbuf *buf);
 
@@ -67,48 +65,48 @@
 
 #define cmark_strbuf_at(buf, n) ((buf)->ptr[n])
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data,
                       bufsize_t len);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_sets(cmark_strbuf *buf, const char *string);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_putc(cmark_strbuf *buf, int c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
                       bufsize_t len);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_puts(cmark_strbuf *buf, const char *string);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_clear(cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_rtrim(cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_trim(cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_normalize_whitespace(cmark_strbuf *s);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_unescape(cmark_strbuf *s);
 
 #ifdef __cplusplus
diff --git a/cbits/chunk.h b/cbits/chunk.h
--- a/cbits/chunk.h
+++ b/cbits/chunk.h
@@ -4,7 +4,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "buffer.h"
 #include "memory.h"
 #include "cmark_ctype.h"
@@ -12,7 +12,7 @@
 #define CMARK_CHUNK_EMPTY                                                      \
   { NULL, 0, 0 }
 
-typedef struct {
+typedef struct cmark_chunk {
   unsigned char *data;
   bufsize_t len;
   bufsize_t alloc; // also implies a NULL-terminated string
diff --git a/cbits/cmark-gfm-core-extensions.h b/cbits/cmark-gfm-core-extensions.h
new file mode 100644
--- /dev/null
+++ b/cbits/cmark-gfm-core-extensions.h
@@ -0,0 +1,25 @@
+#ifndef CMARK_GFM_CORE_EXTENSIONS_H
+#define CMARK_GFM_CORE_EXTENSIONS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cmark-gfm-extension_api.h"
+#include "cmark-gfm-extensions_export.h"
+#include <stdint.h>
+
+CMARK_GFM_EXTENSIONS_EXPORT
+void cmark_gfm_core_extensions_ensure_registered(void);
+
+CMARK_GFM_EXTENSIONS_EXPORT
+uint16_t cmark_gfm_extensions_get_table_columns(cmark_node *node);
+
+CMARK_GFM_EXTENSIONS_EXPORT
+uint8_t *cmark_gfm_extensions_get_table_alignments(cmark_node *node);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cbits/cmark-gfm-extension_api.h b/cbits/cmark-gfm-extension_api.h
new file mode 100644
--- /dev/null
+++ b/cbits/cmark-gfm-extension_api.h
@@ -0,0 +1,719 @@
+#ifndef CMARK_GFM_EXTENSION_API_H
+#define CMARK_GFM_EXTENSION_API_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cmark-gfm.h"
+
+struct cmark_renderer;
+struct cmark_html_renderer;
+struct cmark_chunk;
+
+/**
+ * ## Extension Support
+ *
+ * While the "core" of libcmark is strictly compliant with the
+ * specification, an API is provided for extension writers to
+ * hook into the parsing process.
+ *
+ * It should be noted that the cmark_node API already offers
+ * room for customization, with methods offered to traverse and
+ * modify the AST, and even define custom blocks.
+ * When the desired customization is achievable in an error-proof
+ * way using that API, it should be the preferred method.
+ *
+ * The following API requires a more in-depth understanding
+ * of libcmark's parsing strategy, which is exposed
+ * [here](http://spec.commonmark.org/0.24/#appendix-a-parsing-strategy).
+ *
+ * It should be used when "a posteriori" modification of the AST
+ * proves to be too difficult / impossible to implement correctly.
+ *
+ * It can also serve as an intermediary step before extending
+ * the specification, as an extension implemented using this API
+ * will be trivially integrated in the core if it proves to be
+ * desirable.
+ */
+
+typedef struct cmark_plugin cmark_plugin;
+
+/** A syntax extension that can be attached to a cmark_parser
+ * with cmark_parser_attach_syntax_extension().
+ *
+ * Extension writers should assign functions matching
+ * the signature of the following 'virtual methods' to
+ * implement new functionality.
+ *
+ * Their calling order and expected behaviour match the procedure outlined
+ * at <http://spec.commonmark.org/0.24/#phase-1-block-structure>:
+ *
+ * During step 1, cmark will call the function provided through
+ * 'cmark_syntax_extension_set_match_block_func' when it
+ * iterates over an open block created by this extension,
+ * to determine  whether it could contain the new line.
+ * If no function was provided, cmark will close the block.
+ *
+ * During step 2, if and only if the new line doesn't match any
+ * of the standard syntax rules, cmark will call the function
+ * provided through 'cmark_syntax_extension_set_open_block_func'
+ * to let the extension determine whether that new line matches
+ * one of its syntax rules.
+ * It is the responsibility of the parser to create and add the
+ * new block with cmark_parser_make_block and cmark_parser_add_child.
+ * If no function was provided is NULL, the extension will have
+ * no effect at all on the final block structure of the AST.
+ *
+ * #### Inline parsing phase hooks
+ *
+ * For each character provided by the extension through
+ * 'cmark_syntax_extension_set_special_inline_chars',
+ * the function provided by the extension through
+ * 'cmark_syntax_extension_set_match_inline_func'
+ * will get called, it is the responsibility of the extension
+ * to scan the characters located at the current inline parsing offset
+ * with the cmark_inline_parser API.
+ *
+ * Depending on the type of the extension, it can either:
+ *
+ * * Scan forward, determine that the syntax matches and return
+ *   a newly-created inline node with the appropriate type.
+ *   This is the technique that would be used if inline code
+ *   (with backticks) was implemented as an extension.
+ * * Scan only the character(s) that its syntax rules require
+ *   for opening and closing nodes, push a delimiter on the
+ *   delimiter stack, and return a simple text node with its
+ *   contents set to the character(s) consumed.
+ *   This is the technique that would be used if emphasis
+ *   inlines were implemented as an extension.
+ *
+ * When an extension has pushed delimiters on the stack,
+ * the function provided through
+ * 'cmark_syntax_extension_set_inline_from_delim_func'
+ * will get called in a latter phase,
+ * when the inline parser has matched opener and closer delimiters
+ * created by the extension together.
+ *
+ * It is then the responsibility of the extension to modify
+ * and populate the opener inline text node, and to remove
+ * the necessary delimiters from the delimiter stack.
+ *
+ * Finally, the extension should return NULL if its scan didn't
+ * match its syntax rules.
+ *
+ * The extension can store whatever private data it might need
+ * with 'cmark_syntax_extension_set_private',
+ * and optionally define a free function for this data.
+ */
+typedef struct cmark_syntax_extension cmark_syntax_extension;
+
+typedef struct subject cmark_inline_parser;
+
+/** Exposed raw for now */
+
+typedef struct delimiter {
+  struct delimiter *previous;
+  struct delimiter *next;
+  cmark_node *inl_text;
+  bufsize_t length;
+  unsigned char delim_char;
+  int can_open;
+  int can_close;
+} delimiter;
+
+/**
+ * ### Plugin API.
+ *
+ * Extensions should be distributed as dynamic libraries,
+ * with a single exported function named after the distributed
+ * filename.
+ *
+ * When discovering extensions (see cmark_init), cmark will
+ * try to load a symbol named "init_{{filename}}" in all the
+ * dynamic libraries it encounters.
+ *
+ * For example, given a dynamic library named myextension.so
+ * (or myextension.dll), cmark will try to load the symbol
+ * named "init_myextension". This means that the filename
+ * must lend itself to forming a valid C identifier, with
+ * the notable exception of dashes, which will be translated
+ * to underscores, which means cmark will look for a function
+ * named "init_my_extension" if it encounters a dynamic library
+ * named "my-extension.so".
+ *
+ * See the 'cmark_plugin_init_func' typedef for the exact prototype
+ * this function should follow.
+ *
+ * For now the extensibility of cmark is not complete, as
+ * it only offers API to hook into the block parsing phase
+ * (<http://spec.commonmark.org/0.24/#phase-1-block-structure>).
+ *
+ * See 'cmark_plugin_register_syntax_extension' for more information.
+ */
+
+/** The prototype plugins' init function should follow.
+ */
+typedef int (*cmark_plugin_init_func)(cmark_plugin *plugin);
+
+/** Register a syntax 'extension' with the 'plugin', it will be made
+ * available as an extension and, if attached to a cmark_parser
+ * with 'cmark_parser_attach_syntax_extension', it will contribute
+ * to the block parsing process.
+ *
+ * See the documentation for 'cmark_syntax_extension' for information
+ * on how to implement one.
+ *
+ * This function will typically be called from the init function
+ * of external modules.
+ *
+ * This takes ownership of 'extension', one should not call
+ * 'cmark_syntax_extension_free' on a registered extension.
+ */
+CMARK_GFM_EXPORT
+int cmark_plugin_register_syntax_extension(cmark_plugin *plugin,
+                                            cmark_syntax_extension *extension);
+
+/** This will search for the syntax extension named 'name' among the
+ *  registered syntax extensions.
+ *
+ *  It can then be attached to a cmark_parser
+ *  with the cmark_parser_attach_syntax_extension method.
+ */
+CMARK_GFM_EXPORT
+cmark_syntax_extension *cmark_find_syntax_extension(const char *name);
+
+/** Should create and add a new open block to 'parent_container' if
+ * 'input' matches a syntax rule for that block type. It is allowed
+ * to modify the type of 'parent_container'.
+ *
+ * Should return the newly created block if there is one, or
+ * 'parent_container' if its type was modified, or NULL.
+ */
+typedef cmark_node * (*cmark_open_block_func) (cmark_syntax_extension *extension,
+                                       int indented,
+                                       cmark_parser *parser,
+                                       cmark_node *parent_container,
+                                       unsigned char *input,
+                                       int len);
+
+typedef cmark_node *(*cmark_match_inline_func)(cmark_syntax_extension *extension,
+                                       cmark_parser *parser,
+                                       cmark_node *parent,
+                                       unsigned char character,
+                                       cmark_inline_parser *inline_parser);
+
+typedef delimiter *(*cmark_inline_from_delim_func)(cmark_syntax_extension *extension,
+                                           cmark_parser *parser,
+                                           cmark_inline_parser *inline_parser,
+                                           delimiter *opener,
+                                           delimiter *closer);
+
+/** Should return 'true' if 'input' can be contained in 'container',
+ *  'false' otherwise.
+ */
+typedef int (*cmark_match_block_func)        (cmark_syntax_extension *extension,
+                                       cmark_parser *parser,
+                                       unsigned char *input,
+                                       int len,
+                                       cmark_node *container);
+
+typedef const char *(*cmark_get_type_string_func) (cmark_syntax_extension *extension,
+                                                   cmark_node *node);
+
+typedef int (*cmark_can_contain_func) (cmark_syntax_extension *extension,
+                                       cmark_node *node,
+                                       cmark_node_type child);
+
+typedef int (*cmark_contains_inlines_func) (cmark_syntax_extension *extension,
+                                            cmark_node *node);
+
+typedef void (*cmark_common_render_func) (cmark_syntax_extension *extension,
+                                          struct cmark_renderer *renderer,
+                                          cmark_node *node,
+                                          cmark_event_type ev_type,
+                                          int options);
+
+typedef int (*cmark_commonmark_escape_func) (cmark_syntax_extension *extension,
+                                              cmark_node *node,
+                                              int c);
+
+typedef void (*cmark_html_render_func) (cmark_syntax_extension *extension,
+                                        struct cmark_html_renderer *renderer,
+                                        cmark_node *node,
+                                        cmark_event_type ev_type,
+                                        int options);
+
+typedef int (*cmark_html_filter_func) (cmark_syntax_extension *extension,
+                                       const unsigned char *tag,
+                                       size_t tag_len);
+
+typedef cmark_node *(*cmark_postprocess_func) (cmark_syntax_extension *extension,
+                                               cmark_parser *parser,
+                                               cmark_node *root);
+
+typedef int (*cmark_ispunct_func) (char c);
+
+typedef void (*cmark_opaque_free_func) (cmark_syntax_extension *extension,
+                                        cmark_mem *mem,
+                                        cmark_node *node);
+
+/** Free a cmark_syntax_extension.
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_free               (cmark_mem *mem, cmark_syntax_extension *extension);
+
+/** Return a newly-constructed cmark_syntax_extension, named 'name'.
+ */
+CMARK_GFM_EXPORT
+cmark_syntax_extension *cmark_syntax_extension_new (const char *name);
+
+CMARK_GFM_EXPORT
+cmark_node_type cmark_syntax_extension_add_node(int is_inline);
+
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_emphasis(cmark_syntax_extension *extension, int emphasis);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_open_block_func(cmark_syntax_extension *extension,
+                                                cmark_open_block_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_match_block_func(cmark_syntax_extension *extension,
+                                                 cmark_match_block_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_match_inline_func(cmark_syntax_extension *extension,
+                                                  cmark_match_inline_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_inline_from_delim_func(cmark_syntax_extension *extension,
+                                                       cmark_inline_from_delim_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_special_inline_chars(cmark_syntax_extension *extension,
+                                                     cmark_llist *special_chars);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_get_type_string_func(cmark_syntax_extension *extension,
+                                                     cmark_get_type_string_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_can_contain_func(cmark_syntax_extension *extension,
+                                                 cmark_can_contain_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_contains_inlines_func(cmark_syntax_extension *extension,
+                                                      cmark_contains_inlines_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_commonmark_render_func(cmark_syntax_extension *extension,
+                                                       cmark_common_render_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_plaintext_render_func(cmark_syntax_extension *extension,
+                                                      cmark_common_render_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_latex_render_func(cmark_syntax_extension *extension,
+                                                  cmark_common_render_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_man_render_func(cmark_syntax_extension *extension,
+                                                cmark_common_render_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_html_render_func(cmark_syntax_extension *extension,
+                                                 cmark_html_render_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_html_filter_func(cmark_syntax_extension *extension,
+                                                 cmark_html_filter_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_commonmark_escape_func(cmark_syntax_extension *extension,
+                                                       cmark_commonmark_escape_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_private(cmark_syntax_extension *extension,
+                                        void *priv,
+                                        cmark_free_func free_func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void *cmark_syntax_extension_get_private(cmark_syntax_extension *extension);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_postprocess_func(cmark_syntax_extension *extension,
+                                                 cmark_postprocess_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_opaque_free_func(cmark_syntax_extension *extension,
+                                                 cmark_opaque_free_func func);
+
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_parser_set_backslash_ispunct_func(cmark_parser *parser,
+                                             cmark_ispunct_func func);
+
+/** Return the index of the line currently being parsed, starting with 1.
+ */
+CMARK_GFM_EXPORT
+int cmark_parser_get_line_number(cmark_parser *parser);
+
+/** Return the offset in bytes in the line being processed.
+ *
+ * Example:
+ *
+ * ### foo
+ *
+ * Here, offset will first be 0, then 5 (the index of the 'f' character).
+ */
+CMARK_GFM_EXPORT
+int cmark_parser_get_offset(cmark_parser *parser);
+
+/**
+ * Return the offset in 'columns' in the line being processed.
+ *
+ * This value may differ from the value returned by
+ * cmark_parser_get_offset() in that it accounts for tabs,
+ * and as such should not be used as an index in the current line's
+ * buffer.
+ *
+ * Example:
+ *
+ * cmark_parser_advance_offset() can be called to advance the
+ * offset by a number of columns, instead of a number of bytes.
+ *
+ * In that case, if offset falls "in the middle" of a tab
+ * character, 'column' and offset will differ.
+ *
+ * ```
+ * foo                 \t bar
+ * ^                   ^^
+ * offset (0)          20
+ * ```
+ *
+ * If cmark_parser_advance_offset is called here with 'columns'
+ * set to 'true' and 'offset' set to 22, cmark_parser_get_offset()
+ * will return 20, whereas cmark_parser_get_column() will return
+ * 22.
+ *
+ * Additionally, as tabs expand to the next multiple of 4 column,
+ * cmark_parser_has_partially_consumed_tab() will now return
+ * 'true'.
+ */
+CMARK_GFM_EXPORT
+int cmark_parser_get_column(cmark_parser *parser);
+
+/** Return the absolute index in bytes of the first nonspace
+ * character coming after the offset as returned by
+ * cmark_parser_get_offset() in the line currently being processed.
+ *
+ * Example:
+ *
+ * ```
+ *   foo        bar            baz  \n
+ * ^               ^           ^
+ * 0            offset (16) first_nonspace (28)
+ * ```
+ */
+CMARK_GFM_EXPORT
+int cmark_parser_get_first_nonspace(cmark_parser *parser);
+
+/** Return the absolute index of the first nonspace column coming after 'offset'
+ * in the line currently being processed, counting tabs as multiple
+ * columns as appropriate.
+ *
+ * See the documentation for cmark_parser_get_first_nonspace() and
+ * cmark_parser_get_column() for more information.
+ */
+CMARK_GFM_EXPORT
+int cmark_parser_get_first_nonspace_column(cmark_parser *parser);
+
+/** Return the difference between the values returned by
+ * cmark_parser_get_first_nonspace_column() and
+ * cmark_parser_get_column().
+ *
+ * This is not a byte offset, as it can count one tab as multiple
+ * characters.
+ */
+CMARK_GFM_EXPORT
+int cmark_parser_get_indent(cmark_parser *parser);
+
+/** Return 'true' if the line currently being processed has been entirely
+ * consumed, 'false' otherwise.
+ *
+ * Example:
+ *
+ * ```
+ *   foo        bar            baz  \n
+ * ^
+ * offset
+ * ```
+ *
+ * This function will return 'false' here.
+ *
+ * ```
+ *   foo        bar            baz  \n
+ *                 ^
+ *              offset
+ * ```
+ * This function will still return 'false'.
+ *
+ * ```
+ *   foo        bar            baz  \n
+ *                                ^
+ *                             offset
+ * ```
+ *
+ * At this point, this function will now return 'true'.
+ */
+CMARK_GFM_EXPORT
+int cmark_parser_is_blank(cmark_parser *parser);
+
+/** Return 'true' if the value returned by cmark_parser_get_offset()
+ * is 'inside' an expanded tab.
+ *
+ * See the documentation for cmark_parser_get_column() for more
+ * information.
+ */
+CMARK_GFM_EXPORT
+int cmark_parser_has_partially_consumed_tab(cmark_parser *parser);
+
+/** Return the length in bytes of the previously processed line, excluding potential
+ * newline (\n) and carriage return (\r) trailing characters.
+ */
+CMARK_GFM_EXPORT
+int cmark_parser_get_last_line_length(cmark_parser *parser);
+
+/** Add a child to 'parent' during the parsing process.
+ *
+ * If 'parent' isn't the kind of node that can accept this child,
+ * this function will back up till it hits a node that can, closing
+ * blocks as appropriate.
+ */
+CMARK_GFM_EXPORT
+cmark_node*cmark_parser_add_child(cmark_parser *parser,
+                                  cmark_node *parent,
+                                  cmark_node_type block_type,
+                                  int start_column);
+
+/** Advance the 'offset' of the parser in the current line.
+ *
+ * See the documentation of cmark_parser_get_offset() and
+ * cmark_parser_get_column() for more information.
+ */
+CMARK_GFM_EXPORT
+void cmark_parser_advance_offset(cmark_parser *parser,
+                                 const char *input,
+                                 int count,
+                                 int columns);
+
+
+CMARK_GFM_EXPORT
+void cmark_parser_feed_reentrant(cmark_parser *parser, const char *buffer, size_t len);
+
+/** Attach the syntax 'extension' to the 'parser', to provide extra syntax
+ *  rules.
+ *  See the documentation for cmark_syntax_extension for more information.
+ *
+ *  Returns 'true' if the 'extension' was successfully attached,
+ *  'false' otherwise.
+ */
+CMARK_GFM_EXPORT
+int cmark_parser_attach_syntax_extension(cmark_parser *parser, cmark_syntax_extension *extension);
+
+/** Change the type of 'node'.
+ *
+ * Return 0 if the type could be changed, 1 otherwise.
+ */
+CMARK_GFM_EXPORT int cmark_node_set_type(cmark_node *node, cmark_node_type type);
+
+/** Return the string content for all types of 'node'.
+ *  The pointer stays valid as long as 'node' isn't freed.
+ */
+CMARK_GFM_EXPORT const char *cmark_node_get_string_content(cmark_node *node);
+
+/** Set the string 'content' for all types of 'node'.
+ *  Copies 'content'.
+ */
+CMARK_GFM_EXPORT int cmark_node_set_string_content(cmark_node *node, const char *content);
+
+/** Get the syntax extension responsible for the creation of 'node'.
+ *  Return NULL if 'node' was created because it matched standard syntax rules.
+ */
+CMARK_GFM_EXPORT cmark_syntax_extension *cmark_node_get_syntax_extension(cmark_node *node);
+
+/** Set the syntax extension responsible for creating 'node'.
+ */
+CMARK_GFM_EXPORT int cmark_node_set_syntax_extension(cmark_node *node,
+                                                  cmark_syntax_extension *extension);
+
+/**
+ * ## Inline syntax extension helpers
+ *
+ * The inline parsing process is described in detail at
+ * <http://spec.commonmark.org/0.24/#phase-2-inline-structure>
+ */
+
+/** Should return 'true' if the predicate matches 'c', 'false' otherwise
+ */
+typedef int (*cmark_inline_predicate)(int c);
+
+/** Advance the current inline parsing offset */
+CMARK_GFM_EXPORT
+void cmark_inline_parser_advance_offset(cmark_inline_parser *parser);
+
+/** Get the current inline parsing offset */
+CMARK_GFM_EXPORT
+int cmark_inline_parser_get_offset(cmark_inline_parser *parser);
+
+/** Set the offset in bytes in the chunk being processed by the given inline parser.
+ */
+CMARK_GFM_EXPORT
+void cmark_inline_parser_set_offset(cmark_inline_parser *parser, int offset);
+
+/** Gets the cmark_chunk being operated on by the given inline parser.
+ * Use cmark_inline_parser_get_offset to get our current position in the chunk.
+ */
+CMARK_GFM_EXPORT
+struct cmark_chunk *cmark_inline_parser_get_chunk(cmark_inline_parser *parser);
+
+/** Returns 1 if the inline parser is currently in a bracket; pass 1 for 'image'
+ * if you want to know about an image-type bracket, 0 for link-type. */
+CMARK_GFM_EXPORT
+int cmark_inline_parser_in_bracket(cmark_inline_parser *parser, int image);
+
+/** Remove the last n characters from the last child of the given node.
+ * This only works where all n characters are in the single last child, and the last
+ * child is CMARK_NODE_TEXT.
+ */
+CMARK_GFM_EXPORT
+void cmark_node_unput(cmark_node *node, int n);
+
+
+/** Get the character located at the current inline parsing offset
+ */
+CMARK_GFM_EXPORT
+unsigned char cmark_inline_parser_peek_char(cmark_inline_parser *parser);
+
+/** Get the character located 'pos' bytes in the current line.
+ */
+CMARK_GFM_EXPORT
+unsigned char cmark_inline_parser_peek_at(cmark_inline_parser *parser, int pos);
+
+/** Whether the inline parser has reached the end of the current line
+ */
+CMARK_GFM_EXPORT
+int cmark_inline_parser_is_eof(cmark_inline_parser *parser);
+
+/** Get the characters located after the current inline parsing offset
+ * while 'pred' matches. Free after usage.
+ */
+CMARK_GFM_EXPORT
+char *cmark_inline_parser_take_while(cmark_inline_parser *parser, cmark_inline_predicate pred);
+
+/** Push a delimiter on the delimiter stack.
+ * See <<http://spec.commonmark.org/0.24/#phase-2-inline-structure> for
+ * more information on the parameters
+ */
+CMARK_GFM_EXPORT
+void cmark_inline_parser_push_delimiter(cmark_inline_parser *parser,
+                                  unsigned char c,
+                                  int can_open,
+                                  int can_close,
+                                  cmark_node *inl_text);
+
+/** Remove 'delim' from the delimiter stack
+ */
+CMARK_GFM_EXPORT
+void cmark_inline_parser_remove_delimiter(cmark_inline_parser *parser, delimiter *delim);
+
+CMARK_GFM_EXPORT
+delimiter *cmark_inline_parser_get_last_delimiter(cmark_inline_parser *parser);
+
+CMARK_GFM_EXPORT
+int cmark_inline_parser_get_line(cmark_inline_parser *parser);
+
+CMARK_GFM_EXPORT
+int cmark_inline_parser_get_column(cmark_inline_parser *parser);
+
+/** Convenience function to scan a given delimiter.
+ *
+ * 'left_flanking' and 'right_flanking' will be set to true if they
+ * respectively precede and follow a non-space, non-punctuation
+ * character.
+ *
+ * Additionally, 'punct_before' and 'punct_after' will respectively be set
+ * if the preceding or following character is a punctuation character.
+ *
+ * Note that 'left_flanking' and 'right_flanking' can both be 'true'.
+ *
+ * Returns the number of delimiters encountered, in the limit
+ * of 'max_delims', and advances the inline parsing offset.
+ */
+CMARK_GFM_EXPORT
+int cmark_inline_parser_scan_delimiters(cmark_inline_parser *parser,
+                                  int max_delims,
+                                  unsigned char c,
+                                  int *left_flanking,
+                                  int *right_flanking,
+                                  int *punct_before,
+                                  int *punct_after);
+
+CMARK_GFM_EXPORT
+void cmark_manage_extensions_special_characters(cmark_parser *parser, int add);
+
+CMARK_GFM_EXPORT
+cmark_llist *cmark_parser_get_syntax_extensions(cmark_parser *parser);
+
+CMARK_GFM_EXPORT
+void cmark_arena_push(void);
+
+CMARK_GFM_EXPORT
+int cmark_arena_pop(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cbits/cmark-gfm-extensions_export.h b/cbits/cmark-gfm-extensions_export.h
new file mode 100644
--- /dev/null
+++ b/cbits/cmark-gfm-extensions_export.h
@@ -0,0 +1,42 @@
+
+#ifndef CMARK_GFM_EXTENSIONS_EXPORT_H
+#define CMARK_GFM_EXTENSIONS_EXPORT_H
+
+#ifdef CMARK_GFM_EXTENSIONS_STATIC_DEFINE
+#  define CMARK_GFM_EXTENSIONS_EXPORT
+#  define CMARK_GFM_EXTENSIONS_NO_EXPORT
+#else
+#  ifndef CMARK_GFM_EXTENSIONS_EXPORT
+#    ifdef libcmark_gfm_extensions_EXPORTS
+        /* We are building this library */
+#      define CMARK_GFM_EXTENSIONS_EXPORT __attribute__((visibility("default")))
+#    else
+        /* We are using this library */
+#      define CMARK_GFM_EXTENSIONS_EXPORT __attribute__((visibility("default")))
+#    endif
+#  endif
+
+#  ifndef CMARK_GFM_EXTENSIONS_NO_EXPORT
+#    define CMARK_GFM_EXTENSIONS_NO_EXPORT __attribute__((visibility("hidden")))
+#  endif
+#endif
+
+#ifndef CMARK_GFM_EXTENSIONS_DEPRECATED
+#  define CMARK_GFM_EXTENSIONS_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef CMARK_GFM_EXTENSIONS_DEPRECATED_EXPORT
+#  define CMARK_GFM_EXTENSIONS_DEPRECATED_EXPORT CMARK_GFM_EXTENSIONS_EXPORT CMARK_GFM_EXTENSIONS_DEPRECATED
+#endif
+
+#ifndef CMARK_GFM_EXTENSIONS_DEPRECATED_NO_EXPORT
+#  define CMARK_GFM_EXTENSIONS_DEPRECATED_NO_EXPORT CMARK_GFM_EXTENSIONS_NO_EXPORT CMARK_GFM_EXTENSIONS_DEPRECATED
+#endif
+
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef CMARK_GFM_EXTENSIONS_NO_DEPRECATED
+#    define CMARK_GFM_EXTENSIONS_NO_DEPRECATED
+#  endif
+#endif
+
+#endif
diff --git a/cbits/cmark-gfm.h b/cbits/cmark-gfm.h
new file mode 100644
--- /dev/null
+++ b/cbits/cmark-gfm.h
@@ -0,0 +1,803 @@
+#ifndef CMARK_GFM_H
+#define CMARK_GFM_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include "cmark-gfm_export.h"
+#include "cmark-gfm_version.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** # NAME
+ *
+ * **cmark-gfm** - 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_GFM_EXPORT
+char *cmark_markdown_to_html(const char *text, size_t len, int options);
+
+/** ## Node Structure
+ */
+
+#define CMARK_NODE_TYPE_PRESENT (0x8000)
+#define CMARK_NODE_TYPE_BLOCK (CMARK_NODE_TYPE_PRESENT | 0x0000)
+#define CMARK_NODE_TYPE_INLINE (CMARK_NODE_TYPE_PRESENT | 0x4000)
+#define CMARK_NODE_TYPE_MASK (0xc000)
+#define CMARK_NODE_VALUE_MASK (0x3fff)
+
+typedef enum {
+  /* Error status */
+  CMARK_NODE_NONE = 0x0000,
+
+  /* Block */
+  CMARK_NODE_DOCUMENT       = CMARK_NODE_TYPE_BLOCK | 0x0001,
+  CMARK_NODE_BLOCK_QUOTE    = CMARK_NODE_TYPE_BLOCK | 0x0002,
+  CMARK_NODE_LIST           = CMARK_NODE_TYPE_BLOCK | 0x0003,
+  CMARK_NODE_ITEM           = CMARK_NODE_TYPE_BLOCK | 0x0004,
+  CMARK_NODE_CODE_BLOCK     = CMARK_NODE_TYPE_BLOCK | 0x0005,
+  CMARK_NODE_HTML_BLOCK     = CMARK_NODE_TYPE_BLOCK | 0x0006,
+  CMARK_NODE_CUSTOM_BLOCK   = CMARK_NODE_TYPE_BLOCK | 0x0007,
+  CMARK_NODE_PARAGRAPH      = CMARK_NODE_TYPE_BLOCK | 0x0008,
+  CMARK_NODE_HEADING        = CMARK_NODE_TYPE_BLOCK | 0x0009,
+  CMARK_NODE_THEMATIC_BREAK = CMARK_NODE_TYPE_BLOCK | 0x000a,
+  CMARK_NODE_FOOTNOTE_DEFINITION = CMARK_NODE_TYPE_BLOCK | 0x000b,
+
+  /* Inline */
+  CMARK_NODE_TEXT          = CMARK_NODE_TYPE_INLINE | 0x0001,
+  CMARK_NODE_SOFTBREAK     = CMARK_NODE_TYPE_INLINE | 0x0002,
+  CMARK_NODE_LINEBREAK     = CMARK_NODE_TYPE_INLINE | 0x0003,
+  CMARK_NODE_CODE          = CMARK_NODE_TYPE_INLINE | 0x0004,
+  CMARK_NODE_HTML_INLINE   = CMARK_NODE_TYPE_INLINE | 0x0005,
+  CMARK_NODE_CUSTOM_INLINE = CMARK_NODE_TYPE_INLINE | 0x0006,
+  CMARK_NODE_EMPH          = CMARK_NODE_TYPE_INLINE | 0x0007,
+  CMARK_NODE_STRONG        = CMARK_NODE_TYPE_INLINE | 0x0008,
+  CMARK_NODE_LINK          = CMARK_NODE_TYPE_INLINE | 0x0009,
+  CMARK_NODE_IMAGE         = CMARK_NODE_TYPE_INLINE | 0x000a,
+  CMARK_NODE_FOOTNOTE_REFERENCE = CMARK_NODE_TYPE_INLINE | 0x000b,
+} cmark_node_type;
+
+extern cmark_node_type CMARK_NODE_LAST_BLOCK;
+extern cmark_node_type CMARK_NODE_LAST_INLINE;
+
+/* 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;
+
+/** The default memory allocator; uses the system's calloc,
+ * realloc and free.
+ */
+CMARK_GFM_EXPORT
+cmark_mem *cmark_get_default_mem_allocator();
+
+/** An arena allocator; uses system calloc to allocate large
+ * slabs of memory.  Memory in these slabs is not reused at all.
+ */
+CMARK_GFM_EXPORT
+cmark_mem *cmark_get_arena_mem_allocator();
+
+/** Resets the arena allocator, quickly returning all used memory
+ * to the operating system.
+ */
+CMARK_GFM_EXPORT
+void cmark_arena_reset(void);
+
+/** Callback for freeing user data with a 'cmark_mem' context.
+ */
+typedef void (*cmark_free_func) (cmark_mem *mem, void *user_data);
+
+
+/*
+ * ## Basic data structures
+ *
+ * To keep dependencies to the strict minimum, libcmark implements
+ * its own versions of "classic" data structures.
+ */
+
+/**
+ * ### Linked list
+ */
+
+/** A generic singly linked list.
+ */
+typedef struct _cmark_llist
+{
+  struct _cmark_llist *next;
+  void         *data;
+} cmark_llist;
+
+/** Append an element to the linked list, return the possibly modified
+ * head of the list.
+ */
+CMARK_GFM_EXPORT
+cmark_llist * cmark_llist_append    (cmark_mem         * mem,
+                                     cmark_llist       * head,
+                                     void              * data);
+
+/** Free the list starting with 'head', calling 'free_func' with the
+ *  data pointer of each of its elements
+ */
+CMARK_GFM_EXPORT
+void          cmark_llist_free_full (cmark_mem         * mem,
+                                     cmark_llist       * head,
+                                     cmark_free_func     free_func);
+
+/** Free the list starting with 'head'
+ */
+CMARK_GFM_EXPORT
+void          cmark_llist_free      (cmark_mem         * mem,
+                                     cmark_llist       * head);
+
+/**
+ * ## 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_GFM_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_GFM_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_GFM_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_GFM_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_GFM_EXPORT cmark_node *cmark_node_previous(cmark_node *node);
+
+/** Returns the parent of 'node', or NULL if there is none.
+ */
+CMARK_GFM_EXPORT cmark_node *cmark_node_parent(cmark_node *node);
+
+/** Returns the first child of 'node', or NULL if 'node' has no children.
+ */
+CMARK_GFM_EXPORT cmark_node *cmark_node_first_child(cmark_node *node);
+
+/** Returns the last child of 'node', or NULL if 'node' has no children.
+ */
+CMARK_GFM_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_GFM_EXPORT
+cmark_iter *cmark_iter_new(cmark_node *root);
+
+/** Frees the memory allocated for an iterator.
+ */
+CMARK_GFM_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_GFM_EXPORT
+cmark_event_type cmark_iter_next(cmark_iter *iter);
+
+/** Returns the current node.
+ */
+CMARK_GFM_EXPORT
+cmark_node *cmark_iter_get_node(cmark_iter *iter);
+
+/** Returns the current event type.
+ */
+CMARK_GFM_EXPORT
+cmark_event_type cmark_iter_get_event_type(cmark_iter *iter);
+
+/** Returns the root node.
+ */
+CMARK_GFM_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_GFM_EXPORT
+void cmark_iter_reset(cmark_iter *iter, cmark_node *current,
+                      cmark_event_type event_type);
+
+/**
+ * ## Accessors
+ */
+
+/** Returns the user data of 'node'.
+ */
+CMARK_GFM_EXPORT void *cmark_node_get_user_data(cmark_node *node);
+
+/** Sets arbitrary user data for 'node'.  Returns 1 on success,
+ * 0 on failure.
+ */
+CMARK_GFM_EXPORT int cmark_node_set_user_data(cmark_node *node, void *user_data);
+
+/** Set free function for user data */
+CMARK_GFM_EXPORT
+int cmark_node_set_user_data_free_func(cmark_node *node,
+                                        cmark_free_func free_func);
+
+/** Returns the type of 'node', or `CMARK_NODE_NONE` on error.
+ */
+CMARK_GFM_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_GFM_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_GFM_EXPORT const char *cmark_node_get_literal(cmark_node *node);
+
+/** Sets the string contents of 'node'.  Returns 1 on success,
+ * 0 on failure.
+ */
+CMARK_GFM_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_GFM_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_GFM_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_GFM_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_GFM_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_GFM_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_GFM_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_GFM_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_GFM_EXPORT int cmark_node_set_list_start(cmark_node *node, int start);
+
+/** Returns 1 if 'node' is a tight list, 0 otherwise.
+ */
+CMARK_GFM_EXPORT int cmark_node_get_list_tight(cmark_node *node);
+
+/** Sets the "tightness" of a list.  Returns 1 on success, 0 on failure.
+ */
+CMARK_GFM_EXPORT int cmark_node_set_list_tight(cmark_node *node, int tight);
+
+/** Returns the info string from a fenced code block.
+ */
+CMARK_GFM_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_GFM_EXPORT int cmark_node_set_fence_info(cmark_node *node, const char *info);
+
+/** Sets code blocks fencing details
+ */
+CMARK_GFM_EXPORT int cmark_node_set_fenced(cmark_node * node, int fenced,
+    int length, int offset, char character);
+
+/** Returns code blocks fencing details
+ */
+CMARK_GFM_EXPORT int cmark_node_get_fenced(cmark_node *node, int *length, int *offset, char *character);
+
+/** 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_GFM_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_GFM_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_GFM_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_GFM_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_GFM_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_GFM_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_GFM_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_GFM_EXPORT int cmark_node_set_on_exit(cmark_node *node, const char *on_exit);
+
+/** Returns the line on which 'node' begins.
+ */
+CMARK_GFM_EXPORT int cmark_node_get_start_line(cmark_node *node);
+
+/** Returns the column at which 'node' begins.
+ */
+CMARK_GFM_EXPORT int cmark_node_get_start_column(cmark_node *node);
+
+/** Returns the line on which 'node' ends.
+ */
+CMARK_GFM_EXPORT int cmark_node_get_end_line(cmark_node *node);
+
+/** Returns the column at which 'node' ends.
+ */
+CMARK_GFM_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_GFM_EXPORT void cmark_node_unlink(cmark_node *node);
+
+/** Inserts 'sibling' before 'node'.  Returns 1 on success, 0 on failure.
+ */
+CMARK_GFM_EXPORT int cmark_node_insert_before(cmark_node *node,
+                                          cmark_node *sibling);
+
+/** Inserts 'sibling' after 'node'. Returns 1 on success, 0 on failure.
+ */
+CMARK_GFM_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_GFM_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_GFM_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_GFM_EXPORT int cmark_node_append_child(cmark_node *node, cmark_node *child);
+
+/** Consolidates adjacent text nodes.
+ */
+CMARK_GFM_EXPORT void cmark_consolidate_text_nodes(cmark_node *root);
+
+/** Ensures a node and all its children own their own chunk memory.
+ */
+CMARK_GFM_EXPORT void cmark_node_own(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_GFM_EXPORT
+cmark_parser *cmark_parser_new(int options);
+
+/** Creates a new parser object with the given memory allocator
+ */
+CMARK_GFM_EXPORT
+cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem);
+
+/** Frees memory allocated for a parser object.
+ */
+CMARK_GFM_EXPORT
+void cmark_parser_free(cmark_parser *parser);
+
+/** Feeds a string of length 'len' to 'parser'.
+ */
+CMARK_GFM_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_GFM_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_GFM_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_GFM_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_GFM_EXPORT
+char *cmark_render_xml(cmark_node *root, int options);
+
+/** As for 'cmark_render_xml', but specifying the allocator to use for
+ * the resulting string.
+ */
+CMARK_GFM_EXPORT
+char *cmark_render_xml_with_mem(cmark_node *root, int options, cmark_mem *mem);
+
+/** 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_GFM_EXPORT
+char *cmark_render_html(cmark_node *root, int options, cmark_llist *extensions);
+
+/** As for 'cmark_render_html', but specifying the allocator to use for
+ * the resulting string.
+ */
+CMARK_GFM_EXPORT
+char *cmark_render_html_with_mem(cmark_node *root, int options, cmark_llist *extensions, cmark_mem *mem);
+
+/** Render a 'node' tree as a groff man page, without the header.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_GFM_EXPORT
+char *cmark_render_man(cmark_node *root, int options, int width);
+
+/** As for 'cmark_render_man', but specifying the allocator to use for
+ * the resulting string.
+ */
+CMARK_GFM_EXPORT
+char *cmark_render_man_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
+
+/** Render a 'node' tree as a commonmark document.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_GFM_EXPORT
+char *cmark_render_commonmark(cmark_node *root, int options, int width);
+
+/** As for 'cmark_render_commonmark', but specifying the allocator to use for
+ * the resulting string.
+ */
+CMARK_GFM_EXPORT
+char *cmark_render_commonmark_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
+
+/** Render a 'node' tree as a plain text document.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_GFM_EXPORT
+char *cmark_render_plaintext(cmark_node *root, int options, int width);
+
+/** As for 'cmark_render_plaintext', but specifying the allocator to use for
+ * the resulting string.
+ */
+CMARK_GFM_EXPORT
+char *cmark_render_plaintext_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
+
+/** Render a 'node' tree as a LaTeX document.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_GFM_EXPORT
+char *cmark_render_latex(cmark_node *root, int options, int width);
+
+/** As for 'cmark_render_latex', but specifying the allocator to use for
+ * the resulting string.
+ */
+CMARK_GFM_EXPORT
+char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
+
+/**
+ * ## 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)
+
+/** Suppress raw HTML and unsafe links (`javascript:`, `vbscript:`,
+ * `file:`, and `data:`, except for `image/png`, `image/gif`,
+ * `image/jpeg`, or `image/webp` mime types).  Raw HTML is replaced
+ * by a placeholder HTML comment. Unsafe links are replaced by
+ * empty strings.
+ */
+#define CMARK_OPT_SAFE (1 << 3)
+
+/** 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)
+
+/** Use GitHub-style <pre lang="x"> tags for code blocks instead of <pre><code
+ * class="language-x">.
+ */
+#define CMARK_OPT_GITHUB_PRE_LANG (1 << 11)
+
+/** Be liberal in interpreting inline HTML tags.
+ */
+#define CMARK_OPT_LIBERAL_HTML_TAG (1 << 12)
+
+/** Parse footnotes.
+ */
+#define CMARK_OPT_FOOTNOTES (1 << 13)
+
+/** Only parse strikethroughs if surrounded by exactly 2 tildes.
+ * Gives some compatibility with redcarpet.
+ */
+#define CMARK_OPT_STRIKETHROUGH_DOUBLE_TILDE (1 << 14)
+
+/** Use style attributes to align table cells instead of align attributes.
+ */
+#define CMARK_OPT_TABLE_PREFER_STYLE_ATTRIBUTES (1 << 15)
+
+/** Include the remainder of the info string in code blocks in
+ * a separate attribute.
+ */
+#define CMARK_OPT_FULL_INFO_STRING (1 << 16)
+
+/**
+ * ## 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_GFM_EXPORT
+int cmark_version(void);
+
+/** The library version string for runtime checks. Also available as
+ * macro CMARK_VERSION_STRING for compile time checks.
+ */
+CMARK_GFM_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
+
+typedef int32_t bufsize_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cbits/cmark-gfm_export.h b/cbits/cmark-gfm_export.h
new file mode 100644
--- /dev/null
+++ b/cbits/cmark-gfm_export.h
@@ -0,0 +1,42 @@
+
+#ifndef CMARK_GFM_EXPORT_H
+#define CMARK_GFM_EXPORT_H
+
+#ifdef CMARK_GFM_STATIC_DEFINE
+#  define CMARK_GFM_EXPORT
+#  define CMARK_GFM_NO_EXPORT
+#else
+#  ifndef CMARK_GFM_EXPORT
+#    ifdef libcmark_gfm_EXPORTS
+        /* We are building this library */
+#      define CMARK_GFM_EXPORT __attribute__((visibility("default")))
+#    else
+        /* We are using this library */
+#      define CMARK_GFM_EXPORT __attribute__((visibility("default")))
+#    endif
+#  endif
+
+#  ifndef CMARK_GFM_NO_EXPORT
+#    define CMARK_GFM_NO_EXPORT __attribute__((visibility("hidden")))
+#  endif
+#endif
+
+#ifndef CMARK_GFM_DEPRECATED
+#  define CMARK_GFM_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef CMARK_GFM_DEPRECATED_EXPORT
+#  define CMARK_GFM_DEPRECATED_EXPORT CMARK_GFM_EXPORT CMARK_GFM_DEPRECATED
+#endif
+
+#ifndef CMARK_GFM_DEPRECATED_NO_EXPORT
+#  define CMARK_GFM_DEPRECATED_NO_EXPORT CMARK_GFM_NO_EXPORT CMARK_GFM_DEPRECATED
+#endif
+
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef CMARK_GFM_NO_DEPRECATED
+#    define CMARK_GFM_NO_DEPRECATED
+#  endif
+#endif
+
+#endif
diff --git a/cbits/cmark-gfm_version.h b/cbits/cmark-gfm_version.h
new file mode 100644
--- /dev/null
+++ b/cbits/cmark-gfm_version.h
@@ -0,0 +1,7 @@
+#ifndef CMARK_GFM_VERSION_H
+#define CMARK_GFM_VERSION_H
+
+#define CMARK_GFM_VERSION ((0 << 24) | (28 << 16) | (3 << 8) | 14)
+#define CMARK_GFM_VERSION_STRING "0.28.3.gfm.14"
+
+#endif
diff --git a/cbits/cmark.c b/cbits/cmark.c
--- a/cbits/cmark.c
+++ b/cbits/cmark.c
@@ -4,15 +4,15 @@
 #include "registry.h"
 #include "node.h"
 #include "houdini.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "buffer.h"
 
-cmark_node_type CMARK_NODE_LAST_BLOCK = CMARK_NODE_THEMATIC_BREAK;
-cmark_node_type CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE;
+cmark_node_type CMARK_NODE_LAST_BLOCK = CMARK_NODE_FOOTNOTE_DEFINITION;
+cmark_node_type CMARK_NODE_LAST_INLINE = CMARK_NODE_FOOTNOTE_REFERENCE;
 
-int cmark_version() { return CMARK_VERSION; }
+int cmark_version() { return CMARK_GFM_VERSION; }
 
-const char *cmark_version_string() { return CMARK_VERSION_STRING; }
+const char *cmark_version_string() { return CMARK_GFM_VERSION_STRING; }
 
 static void *xcalloc(size_t nmem, size_t size) {
   void *ptr = calloc(nmem, size);
diff --git a/cbits/cmark.h b/cbits/cmark.h
deleted file mode 100644
--- a/cbits/cmark.h
+++ /dev/null
@@ -1,780 +0,0 @@
-#ifndef CMARK_CMARK_H
-#define CMARK_CMARK_H
-
-#include <stdio.h>
-#include "cmark_export.h"
-#include "cmark_version.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** # NAME
- *
- * **cmark-gfm** - 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
- */
-
-#define CMARK_NODE_TYPE_PRESENT (0x8000)
-#define CMARK_NODE_TYPE_BLOCK (CMARK_NODE_TYPE_PRESENT | 0x0000)
-#define CMARK_NODE_TYPE_INLINE (CMARK_NODE_TYPE_PRESENT | 0x4000)
-#define CMARK_NODE_TYPE_MASK (0xc000)
-#define CMARK_NODE_VALUE_MASK (0x3fff)
-
-typedef enum {
-  /* Error status */
-  CMARK_NODE_NONE = 0x0000,
-
-  /* Block */
-  CMARK_NODE_DOCUMENT       = CMARK_NODE_TYPE_BLOCK | 0x0001,
-  CMARK_NODE_BLOCK_QUOTE    = CMARK_NODE_TYPE_BLOCK | 0x0002,
-  CMARK_NODE_LIST           = CMARK_NODE_TYPE_BLOCK | 0x0003,
-  CMARK_NODE_ITEM           = CMARK_NODE_TYPE_BLOCK | 0x0004,
-  CMARK_NODE_CODE_BLOCK     = CMARK_NODE_TYPE_BLOCK | 0x0005,
-  CMARK_NODE_HTML_BLOCK     = CMARK_NODE_TYPE_BLOCK | 0x0006,
-  CMARK_NODE_CUSTOM_BLOCK   = CMARK_NODE_TYPE_BLOCK | 0x0007,
-  CMARK_NODE_PARAGRAPH      = CMARK_NODE_TYPE_BLOCK | 0x0008,
-  CMARK_NODE_HEADING        = CMARK_NODE_TYPE_BLOCK | 0x0009,
-  CMARK_NODE_THEMATIC_BREAK = CMARK_NODE_TYPE_BLOCK | 0x000a,
-
-  /* Inline */
-  CMARK_NODE_TEXT          = CMARK_NODE_TYPE_INLINE | 0x0001,
-  CMARK_NODE_SOFTBREAK     = CMARK_NODE_TYPE_INLINE | 0x0002,
-  CMARK_NODE_LINEBREAK     = CMARK_NODE_TYPE_INLINE | 0x0003,
-  CMARK_NODE_CODE          = CMARK_NODE_TYPE_INLINE | 0x0004,
-  CMARK_NODE_HTML_INLINE   = CMARK_NODE_TYPE_INLINE | 0x0005,
-  CMARK_NODE_CUSTOM_INLINE = CMARK_NODE_TYPE_INLINE | 0x0006,
-  CMARK_NODE_EMPH          = CMARK_NODE_TYPE_INLINE | 0x0007,
-  CMARK_NODE_STRONG        = CMARK_NODE_TYPE_INLINE | 0x0008,
-  CMARK_NODE_LINK          = CMARK_NODE_TYPE_INLINE | 0x0009,
-  CMARK_NODE_IMAGE         = CMARK_NODE_TYPE_INLINE | 0x000a,
-} cmark_node_type;
-
-extern cmark_node_type CMARK_NODE_LAST_BLOCK;
-extern cmark_node_type CMARK_NODE_LAST_INLINE;
-
-/* 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;
-
-/** The default memory allocator; uses the system's calloc,
- * realloc and free.
- */
-CMARK_EXPORT
-cmark_mem *cmark_get_default_mem_allocator();
-
-/** An arena allocator; uses system calloc to allocate large
- * slabs of memory.  Memory in these slabs is not reused at all.
- */
-CMARK_EXPORT
-cmark_mem *cmark_get_arena_mem_allocator();
-
-/** Resets the arena allocator, quickly returning all used memory
- * to the operating system.
- */
-CMARK_EXPORT
-void cmark_arena_reset(void);
-
-/** Callback for freeing user data with a 'cmark_mem' context.
- */
-typedef void (*cmark_free_func) (cmark_mem *mem, void *user_data);
-
-
-/*
- * ## Basic data structures
- *
- * To keep dependencies to the strict minimum, libcmark implements
- * its own versions of "classic" data structures.
- */
-
-/**
- * ### Linked list
- */
-
-/** A generic singly linked list.
- */
-typedef struct _cmark_llist
-{
-  struct _cmark_llist *next;
-  void         *data;
-} cmark_llist;
-
-/** Append an element to the linked list, return the possibly modified
- * head of the list.
- */
-CMARK_EXPORT
-cmark_llist * cmark_llist_append    (cmark_mem         * mem,
-                                     cmark_llist       * head,
-                                     void              * data);
-
-/** Free the list starting with 'head', calling 'free_func' with the
- *  data pointer of each of its elements
- */
-CMARK_EXPORT
-void          cmark_llist_free_full (cmark_mem         * mem,
-                                     cmark_llist       * head,
-                                     cmark_free_func     free_func);
-
-/** Free the list starting with 'head'
- */
-CMARK_EXPORT
-void          cmark_llist_free      (cmark_mem         * mem,
-                                     cmark_llist       * head);
-
-/**
- * ## 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);
-
-/** Set free function for user data */
-CMARK_EXPORT
-int cmark_node_set_user_data_free_func(cmark_node *node,
-                                        cmark_free_func free_func);
-
-/** 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);
-
-/** Sets code blocks fencing details
- */
-CMARK_EXPORT int cmark_node_set_fenced(cmark_node * node, int fenced,
-    int length, int offset, char character);
-
-/** Returns code blocks fencing details
- */
-CMARK_EXPORT int cmark_node_get_fenced(cmark_node *node, int *length, int *offset, char *character);
-
-/** 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);
-
-/** Ensures a node and all its children own their own chunk memory.
- */
-CMARK_EXPORT void cmark_node_own(cmark_node *root);
-
-/**
- * ## Parsing
- *
- * Simple interface:
- *
- *     cmark_node *document = cmark_parse_document("Hello *world*", 13,
- *                                                 CMARK_OPT_DEFAULT);
- *
- * Streaming interface:
- *
- *     cmark_parser *parser = cmark_parser_new(CMARK_OPT_DEFAULT);
- *     FILE *fp = fopen("myfile.md", "rb");
- *     while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
- *     	   cmark_parser_feed(parser, buffer, bytes);
- *     	   if (bytes < sizeof(buffer)) {
- *     	       break;
- *     	   }
- *     }
- *     document = cmark_parser_finish(parser);
- *     cmark_parser_free(parser);
- */
-
-/** Creates a new parser object.
- */
-CMARK_EXPORT
-cmark_parser *cmark_parser_new(int options);
-
-/** Creates a new parser object with the given memory allocator
- */
-CMARK_EXPORT
-cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem);
-
-/** Frees memory allocated for a parser object.
- */
-CMARK_EXPORT
-void cmark_parser_free(cmark_parser *parser);
-
-/** Feeds a string of length 'len' to 'parser'.
- */
-CMARK_EXPORT
-void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len);
-
-/** Finish parsing and return a pointer to a tree of nodes.
- */
-CMARK_EXPORT
-cmark_node *cmark_parser_finish(cmark_parser *parser);
-
-/** Parse a CommonMark document in 'buffer' of length 'len'.
- * Returns a pointer to a tree of nodes.  The memory allocated for
- * the node tree should be released using 'cmark_node_free'
- * when it is no longer needed.
- */
-CMARK_EXPORT
-cmark_node *cmark_parse_document(const char *buffer, size_t len, int options);
-
-/** Parse a CommonMark document in file 'f', returning a pointer to
- * a tree of nodes.  The memory allocated for the node tree should be
- * released using 'cmark_node_free' when it is no longer needed.
- */
-CMARK_EXPORT
-cmark_node *cmark_parse_file(FILE *f, int options);
-
-/**
- * ## Rendering
- */
-
-/** Render a 'node' tree as XML.  It is the caller's responsibility
- * to free the returned buffer.
- */
-CMARK_EXPORT
-char *cmark_render_xml(cmark_node *root, int options);
-
-/** As for 'cmark_render_xml', but specifying the allocator to use for
- * the resulting string.
- */
-CMARK_EXPORT
-char *cmark_render_xml_with_mem(cmark_node *root, int options, cmark_mem *mem);
-
-/** 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, cmark_llist *extensions);
-
-/** As for 'cmark_render_html', but specifying the allocator to use for
- * the resulting string.
- */
-CMARK_EXPORT
-char *cmark_render_html_with_mem(cmark_node *root, int options, cmark_llist *extensions, cmark_mem *mem);
-
-/** 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);
-
-/** As for 'cmark_render_man', but specifying the allocator to use for
- * the resulting string.
- */
-CMARK_EXPORT
-char *cmark_render_man_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
-
-/** 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);
-
-/** As for 'cmark_render_commonmark', but specifying the allocator to use for
- * the resulting string.
- */
-CMARK_EXPORT
-char *cmark_render_commonmark_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
-
-/** Render a 'node' tree as a plain text document.
- * It is the caller's responsibility to free the returned buffer.
- */
-CMARK_EXPORT
-char *cmark_render_plaintext(cmark_node *root, int options, int width);
-
-/** As for 'cmark_render_plaintext', but specifying the allocator to use for
- * the resulting string.
- */
-CMARK_EXPORT
-char *cmark_render_plaintext_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
-
-/** 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);
-
-/** As for 'cmark_render_latex', but specifying the allocator to use for
- * the resulting string.
- */
-CMARK_EXPORT
-char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
-
-/**
- * ## 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)
-
-/** Suppress raw HTML and unsafe links (`javascript:`, `vbscript:`,
- * `file:`, and `data:`, except for `image/png`, `image/gif`,
- * `image/jpeg`, or `image/webp` mime types).  Raw HTML is replaced
- * by a placeholder HTML comment. Unsafe links are replaced by
- * empty strings.
- */
-#define CMARK_OPT_SAFE (1 << 3)
-
-/** 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)
-
-/** Use GitHub-style <pre lang="x"> tags for code blocks instead of <pre><code
- * class="language-x">.
- */
-#define CMARK_OPT_GITHUB_PRE_LANG (1 << 11)
-
-/** Be liberal in interpreting inline HTML tags.
- */
-#define CMARK_OPT_LIBERAL_HTML_TAG (1 << 12)
-
-/**
- * ## 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/cbits/cmark_ctype.h b/cbits/cmark_ctype.h
--- a/cbits/cmark_ctype.h
+++ b/cbits/cmark_ctype.h
@@ -5,25 +5,25 @@
 extern "C" {
 #endif
 
-#include "cmark_export.h"
+#include "cmark-gfm_export.h"
 
 /** Locale-independent versions of functions from ctype.h.
  * We want cmark to behave the same no matter what the system locale.
  */
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isspace(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_ispunct(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isalnum(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isdigit(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isalpha(char c);
 
 #ifdef __cplusplus
diff --git a/cbits/cmark_export.h b/cbits/cmark_export.h
deleted file mode 100644
--- a/cbits/cmark_export.h
+++ /dev/null
@@ -1,42 +0,0 @@
-
-#ifndef CMARK_EXPORT_H
-#define CMARK_EXPORT_H
-
-#ifdef CMARK_STATIC_DEFINE
-#  define CMARK_EXPORT
-#  define CMARK_NO_EXPORT
-#else
-#  ifndef CMARK_EXPORT
-#    ifdef libcmark_gfm_EXPORTS
-        /* We are building this library */
-#      define CMARK_EXPORT __attribute__((visibility("default")))
-#    else
-        /* We are using this library */
-#      define CMARK_EXPORT __attribute__((visibility("default")))
-#    endif
-#  endif
-
-#  ifndef CMARK_NO_EXPORT
-#    define CMARK_NO_EXPORT __attribute__((visibility("hidden")))
-#  endif
-#endif
-
-#ifndef CMARK_DEPRECATED
-#  define CMARK_DEPRECATED __attribute__ ((__deprecated__))
-#endif
-
-#ifndef CMARK_DEPRECATED_EXPORT
-#  define CMARK_DEPRECATED_EXPORT CMARK_EXPORT CMARK_DEPRECATED
-#endif
-
-#ifndef CMARK_DEPRECATED_NO_EXPORT
-#  define CMARK_DEPRECATED_NO_EXPORT CMARK_NO_EXPORT CMARK_DEPRECATED
-#endif
-
-#if 0 /* DEFINE_NO_DEPRECATED */
-#  ifndef CMARK_NO_DEPRECATED
-#    define CMARK_NO_DEPRECATED
-#  endif
-#endif
-
-#endif
diff --git a/cbits/cmark_extension_api.h b/cbits/cmark_extension_api.h
deleted file mode 100644
--- a/cbits/cmark_extension_api.h
+++ /dev/null
@@ -1,714 +0,0 @@
-#ifndef CMARK_CMARK_EXTENSION_API_H
-#define CMARK_CMARK_EXTENSION_API_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <cmark.h>
-#include <render.h>
-#include <buffer.h>
-
-/**
- * ## Extension Support
- *
- * While the "core" of libcmark is strictly compliant with the
- * specification, an API is provided for extension writers to
- * hook into the parsing process.
- *
- * It should be noted that the cmark_node API already offers
- * room for customization, with methods offered to traverse and
- * modify the AST, and even define custom blocks.
- * When the desired customization is achievable in an error-proof
- * way using that API, it should be the preferred method.
- *
- * The following API requires a more in-depth understanding
- * of libcmark's parsing strategy, which is exposed
- * [here](http://spec.commonmark.org/0.24/#appendix-a-parsing-strategy).
- *
- * It should be used when "a posteriori" modification of the AST
- * proves to be too difficult / impossible to implement correctly.
- *
- * It can also serve as an intermediary step before extending
- * the specification, as an extension implemented using this API
- * will be trivially integrated in the core if it proves to be
- * desirable.
- */
-
-typedef struct cmark_plugin cmark_plugin;
-
-/** A syntax extension that can be attached to a cmark_parser
- * with cmark_parser_attach_syntax_extension().
- *
- * Extension writers should assign functions matching
- * the signature of the following 'virtual methods' to
- * implement new functionality.
- *
- * Their calling order and expected behaviour match the procedure outlined
- * at <http://spec.commonmark.org/0.24/#phase-1-block-structure>:
- *
- * During step 1, cmark will call the function provided through
- * 'cmark_syntax_extension_set_match_block_func' when it
- * iterates over an open block created by this extension,
- * to determine  whether it could contain the new line.
- * If no function was provided, cmark will close the block.
- *
- * During step 2, if and only if the new line doesn't match any
- * of the standard syntax rules, cmark will call the function
- * provided through 'cmark_syntax_extension_set_open_block_func'
- * to let the extension determine whether that new line matches
- * one of its syntax rules.
- * It is the responsibility of the parser to create and add the
- * new block with cmark_parser_make_block and cmark_parser_add_child.
- * If no function was provided is NULL, the extension will have
- * no effect at all on the final block structure of the AST.
- *
- * #### Inline parsing phase hooks
- *
- * For each character provided by the extension through
- * 'cmark_syntax_extension_set_special_inline_chars',
- * the function provided by the extension through
- * 'cmark_syntax_extension_set_match_inline_func'
- * will get called, it is the responsibility of the extension
- * to scan the characters located at the current inline parsing offset
- * with the cmark_inline_parser API.
- *
- * Depending on the type of the extension, it can either:
- *
- * * Scan forward, determine that the syntax matches and return
- *   a newly-created inline node with the appropriate type.
- *   This is the technique that would be used if inline code
- *   (with backticks) was implemented as an extension.
- * * Scan only the character(s) that its syntax rules require
- *   for opening and closing nodes, push a delimiter on the
- *   delimiter stack, and return a simple text node with its
- *   contents set to the character(s) consumed.
- *   This is the technique that would be used if emphasis
- *   inlines were implemented as an extension.
- *
- * When an extension has pushed delimiters on the stack,
- * the function provided through
- * 'cmark_syntax_extension_set_inline_from_delim_func'
- * will get called in a latter phase,
- * when the inline parser has matched opener and closer delimiters
- * created by the extension together.
- *
- * It is then the responsibility of the extension to modify
- * and populate the opener inline text node, and to remove
- * the necessary delimiters from the delimiter stack.
- *
- * Finally, the extension should return NULL if its scan didn't
- * match its syntax rules.
- *
- * The extension can store whatever private data it might need
- * with 'cmark_syntax_extension_set_private',
- * and optionally define a free function for this data.
- */
-typedef struct cmark_syntax_extension cmark_syntax_extension;
-
-typedef struct subject cmark_inline_parser;
-
-/** Exposed raw for now */
-
-typedef struct delimiter {
-  struct delimiter *previous;
-  struct delimiter *next;
-  cmark_node *inl_text;
-  bufsize_t length;
-  unsigned char delim_char;
-  int can_open;
-  int can_close;
-} delimiter;
-
-/**
- * ### Plugin API.
- *
- * Extensions should be distributed as dynamic libraries,
- * with a single exported function named after the distributed
- * filename.
- *
- * When discovering extensions (see cmark_init), cmark will
- * try to load a symbol named "init_{{filename}}" in all the
- * dynamic libraries it encounters.
- *
- * For example, given a dynamic library named myextension.so
- * (or myextension.dll), cmark will try to load the symbol
- * named "init_myextension". This means that the filename
- * must lend itself to forming a valid C identifier, with
- * the notable exception of dashes, which will be translated
- * to underscores, which means cmark will look for a function
- * named "init_my_extension" if it encounters a dynamic library
- * named "my-extension.so".
- *
- * See the 'cmark_plugin_init_func' typedef for the exact prototype
- * this function should follow.
- *
- * For now the extensibility of cmark is not complete, as
- * it only offers API to hook into the block parsing phase
- * (<http://spec.commonmark.org/0.24/#phase-1-block-structure>).
- *
- * See 'cmark_plugin_register_syntax_extension' for more information.
- */
-
-/** The prototype plugins' init function should follow.
- */
-typedef int (*cmark_plugin_init_func)(cmark_plugin *plugin);
-
-/** Register a syntax 'extension' with the 'plugin', it will be made
- * available as an extension and, if attached to a cmark_parser
- * with 'cmark_parser_attach_syntax_extension', it will contribute
- * to the block parsing process.
- *
- * See the documentation for 'cmark_syntax_extension' for information
- * on how to implement one.
- *
- * This function will typically be called from the init function
- * of external modules.
- *
- * This takes ownership of 'extension', one should not call
- * 'cmark_syntax_extension_free' on a registered extension.
- */
-CMARK_EXPORT
-int cmark_plugin_register_syntax_extension(cmark_plugin *plugin,
-                                            cmark_syntax_extension *extension);
-
-/** This will search for the syntax extension named 'name' among the
- *  registered syntax extensions.
- *
- *  It can then be attached to a cmark_parser
- *  with the cmark_parser_attach_syntax_extension method.
- */
-CMARK_EXPORT
-cmark_syntax_extension *cmark_find_syntax_extension(const char *name);
-
-/** Should create and add a new open block to 'parent_container' if
- * 'input' matches a syntax rule for that block type. It is allowed
- * to modify the type of 'parent_container'.
- *
- * Should return the newly created block if there is one, or
- * 'parent_container' if its type was modified, or NULL.
- */
-typedef cmark_node * (*cmark_open_block_func) (cmark_syntax_extension *extension,
-                                       int indented,
-                                       cmark_parser *parser,
-                                       cmark_node *parent_container,
-                                       unsigned char *input,
-                                       int len);
-
-typedef cmark_node *(*cmark_match_inline_func)(cmark_syntax_extension *extension,
-                                       cmark_parser *parser,
-                                       cmark_node *parent,
-                                       unsigned char character,
-                                       cmark_inline_parser *inline_parser);
-
-typedef delimiter *(*cmark_inline_from_delim_func)(cmark_syntax_extension *extension,
-                                           cmark_parser *parser,
-                                           cmark_inline_parser *inline_parser,
-                                           delimiter *opener,
-                                           delimiter *closer);
-
-/** Should return 'true' if 'input' can be contained in 'container',
- *  'false' otherwise.
- */
-typedef int (*cmark_match_block_func)        (cmark_syntax_extension *extension,
-                                       cmark_parser *parser,
-                                       unsigned char *input,
-                                       int len,
-                                       cmark_node *container);
-
-typedef const char *(*cmark_get_type_string_func) (cmark_syntax_extension *extension,
-                                                   cmark_node *node);
-
-typedef int (*cmark_can_contain_func) (cmark_syntax_extension *extension,
-                                       cmark_node *node,
-                                       cmark_node_type child);
-
-typedef int (*cmark_contains_inlines_func) (cmark_syntax_extension *extension,
-                                            cmark_node *node);
-
-typedef void (*cmark_common_render_func) (cmark_syntax_extension *extension,
-                                          cmark_renderer *renderer,
-                                          cmark_node *node,
-                                          cmark_event_type ev_type,
-                                          int options);
-
-typedef int (*cmark_commonmark_escape_func) (cmark_syntax_extension *extension,
-                                              cmark_node *node,
-                                              int c);
-
-typedef void (*cmark_html_render_func) (cmark_syntax_extension *extension,
-                                        cmark_html_renderer *renderer,
-                                        cmark_node *node,
-                                        cmark_event_type ev_type,
-                                        int options);
-
-typedef int (*cmark_html_filter_func) (cmark_syntax_extension *extension,
-                                       const unsigned char *tag,
-                                       size_t tag_len);
-
-typedef cmark_node *(*cmark_postprocess_func) (cmark_syntax_extension *extension,
-                                               cmark_parser *parser,
-                                               cmark_node *root);
-
-typedef int (*cmark_ispunct_func) (char c);
-
-typedef void (*cmark_opaque_free_func) (cmark_syntax_extension *extension,
-                                        cmark_mem *mem,
-                                        cmark_node *node);
-
-/** Free a cmark_syntax_extension.
- */
-CMARK_EXPORT
-void cmark_syntax_extension_free               (cmark_mem *mem, cmark_syntax_extension *extension);
-
-/** Return a newly-constructed cmark_syntax_extension, named 'name'.
- */
-CMARK_EXPORT
-cmark_syntax_extension *cmark_syntax_extension_new (const char *name);
-
-CMARK_EXPORT
-cmark_node_type cmark_syntax_extension_add_node(int is_inline);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_open_block_func(cmark_syntax_extension *extension,
-                                                cmark_open_block_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_match_block_func(cmark_syntax_extension *extension,
-                                                 cmark_match_block_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_match_inline_func(cmark_syntax_extension *extension,
-                                                  cmark_match_inline_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_inline_from_delim_func(cmark_syntax_extension *extension,
-                                                       cmark_inline_from_delim_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_special_inline_chars(cmark_syntax_extension *extension,
-                                                     cmark_llist *special_chars);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_get_type_string_func(cmark_syntax_extension *extension,
-                                                     cmark_get_type_string_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_can_contain_func(cmark_syntax_extension *extension,
-                                                 cmark_can_contain_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_contains_inlines_func(cmark_syntax_extension *extension,
-                                                      cmark_contains_inlines_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_commonmark_render_func(cmark_syntax_extension *extension,
-                                                       cmark_common_render_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_plaintext_render_func(cmark_syntax_extension *extension,
-                                                      cmark_common_render_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_latex_render_func(cmark_syntax_extension *extension,
-                                                  cmark_common_render_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_man_render_func(cmark_syntax_extension *extension,
-                                                cmark_common_render_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_html_render_func(cmark_syntax_extension *extension,
-                                                 cmark_html_render_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_html_filter_func(cmark_syntax_extension *extension,
-                                                 cmark_html_filter_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_commonmark_escape_func(cmark_syntax_extension *extension,
-                                                       cmark_commonmark_escape_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_private(cmark_syntax_extension *extension,
-                                        void *priv,
-                                        cmark_free_func free_func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void *cmark_syntax_extension_get_private(cmark_syntax_extension *extension);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_postprocess_func(cmark_syntax_extension *extension,
-                                                 cmark_postprocess_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_syntax_extension_set_opaque_free_func(cmark_syntax_extension *extension,
-                                                 cmark_opaque_free_func func);
-
-/** See the documentation for 'cmark_syntax_extension'
- */
-CMARK_EXPORT
-void cmark_parser_set_backslash_ispunct_func(cmark_parser *parser,
-                                             cmark_ispunct_func func);
-
-/** Return the index of the line currently being parsed, starting with 1.
- */
-CMARK_EXPORT
-int cmark_parser_get_line_number(cmark_parser *parser);
-
-/** Return the offset in bytes in the line being processed.
- *
- * Example:
- *
- * ### foo
- *
- * Here, offset will first be 0, then 5 (the index of the 'f' character).
- */
-CMARK_EXPORT
-int cmark_parser_get_offset(cmark_parser *parser);
-
-/**
- * Return the offset in 'columns' in the line being processed.
- *
- * This value may differ from the value returned by
- * cmark_parser_get_offset() in that it accounts for tabs,
- * and as such should not be used as an index in the current line's
- * buffer.
- *
- * Example:
- *
- * cmark_parser_advance_offset() can be called to advance the
- * offset by a number of columns, instead of a number of bytes.
- *
- * In that case, if offset falls "in the middle" of a tab
- * character, 'column' and offset will differ.
- *
- * ```
- * foo                 \t bar
- * ^                   ^^
- * offset (0)          20
- * ```
- *
- * If cmark_parser_advance_offset is called here with 'columns'
- * set to 'true' and 'offset' set to 22, cmark_parser_get_offset()
- * will return 20, whereas cmark_parser_get_column() will return
- * 22.
- *
- * Additionally, as tabs expand to the next multiple of 4 column,
- * cmark_parser_has_partially_consumed_tab() will now return
- * 'true'.
- */
-CMARK_EXPORT
-int cmark_parser_get_column(cmark_parser *parser);
-
-/** Return the absolute index in bytes of the first nonspace
- * character coming after the offset as returned by
- * cmark_parser_get_offset() in the line currently being processed.
- *
- * Example:
- *
- * ```
- *   foo        bar            baz  \n
- * ^               ^           ^
- * 0            offset (16) first_nonspace (28)
- * ```
- */
-CMARK_EXPORT
-int cmark_parser_get_first_nonspace(cmark_parser *parser);
-
-/** Return the absolute index of the first nonspace column coming after 'offset'
- * in the line currently being processed, counting tabs as multiple
- * columns as appropriate.
- *
- * See the documentation for cmark_parser_get_first_nonspace() and
- * cmark_parser_get_column() for more information.
- */
-CMARK_EXPORT
-int cmark_parser_get_first_nonspace_column(cmark_parser *parser);
-
-/** Return the difference between the values returned by
- * cmark_parser_get_first_nonspace_column() and
- * cmark_parser_get_column().
- *
- * This is not a byte offset, as it can count one tab as multiple
- * characters.
- */
-CMARK_EXPORT
-int cmark_parser_get_indent(cmark_parser *parser);
-
-/** Return 'true' if the line currently being processed has been entirely
- * consumed, 'false' otherwise.
- *
- * Example:
- *
- * ```
- *   foo        bar            baz  \n
- * ^
- * offset
- * ```
- *
- * This function will return 'false' here.
- *
- * ```
- *   foo        bar            baz  \n
- *                 ^
- *              offset
- * ```
- * This function will still return 'false'.
- *
- * ```
- *   foo        bar            baz  \n
- *                                ^
- *                             offset
- * ```
- *
- * At this point, this function will now return 'true'.
- */
-CMARK_EXPORT
-int cmark_parser_is_blank(cmark_parser *parser);
-
-/** Return 'true' if the value returned by cmark_parser_get_offset()
- * is 'inside' an expanded tab.
- *
- * See the documentation for cmark_parser_get_column() for more
- * information.
- */
-CMARK_EXPORT
-int cmark_parser_has_partially_consumed_tab(cmark_parser *parser);
-
-/** Return the length in bytes of the previously processed line, excluding potential
- * newline (\n) and carriage return (\r) trailing characters.
- */
-CMARK_EXPORT
-int cmark_parser_get_last_line_length(cmark_parser *parser);
-
-/** Add a child to 'parent' during the parsing process.
- *
- * If 'parent' isn't the kind of node that can accept this child,
- * this function will back up till it hits a node that can, closing
- * blocks as appropriate.
- */
-CMARK_EXPORT
-cmark_node*cmark_parser_add_child(cmark_parser *parser,
-                                  cmark_node *parent,
-                                  cmark_node_type block_type,
-                                  int start_column);
-
-/** Advance the 'offset' of the parser in the current line.
- *
- * See the documentation of cmark_parser_get_offset() and
- * cmark_parser_get_column() for more information.
- */
-CMARK_EXPORT
-void cmark_parser_advance_offset(cmark_parser *parser,
-                                 const char *input,
-                                 int count,
-                                 int columns);
-
-
-CMARK_EXPORT
-void cmark_parser_feed_reentrant(cmark_parser *parser, const char *buffer, size_t len);
-
-/** Attach the syntax 'extension' to the 'parser', to provide extra syntax
- *  rules.
- *  See the documentation for cmark_syntax_extension for more information.
- *
- *  Returns 'true' if the 'extension' was successfully attached,
- *  'false' otherwise.
- */
-CMARK_EXPORT
-int cmark_parser_attach_syntax_extension(cmark_parser *parser, cmark_syntax_extension *extension);
-
-/** Change the type of 'node'.
- *
- * Return 0 if the type could be changed, 1 otherwise.
- */
-CMARK_EXPORT int cmark_node_set_type(cmark_node *node, cmark_node_type type);
-
-/** Return the string content for all types of 'node'.
- *  The pointer stays valid as long as 'node' isn't freed.
- */
-CMARK_EXPORT const char *cmark_node_get_string_content(cmark_node *node);
-
-/** Set the string 'content' for all types of 'node'.
- *  Copies 'content'.
- */
-CMARK_EXPORT int cmark_node_set_string_content(cmark_node *node, const char *content);
-
-/** Get the syntax extension responsible for the creation of 'node'.
- *  Return NULL if 'node' was created because it matched standard syntax rules.
- */
-CMARK_EXPORT cmark_syntax_extension *cmark_node_get_syntax_extension(cmark_node *node);
-
-/** Set the syntax extension responsible for creating 'node'.
- */
-CMARK_EXPORT int cmark_node_set_syntax_extension(cmark_node *node,
-                                                  cmark_syntax_extension *extension);
-
-/**
- * ## Inline syntax extension helpers
- *
- * The inline parsing process is described in detail at
- * <http://spec.commonmark.org/0.24/#phase-2-inline-structure>
- */
-
-/** Should return 'true' if the predicate matches 'c', 'false' otherwise
- */
-typedef int (*cmark_inline_predicate)(int c);
-
-/** Advance the current inline parsing offset */
-CMARK_EXPORT
-void cmark_inline_parser_advance_offset(cmark_inline_parser *parser);
-
-/** Get the current inline parsing offset */
-CMARK_EXPORT
-int cmark_inline_parser_get_offset(cmark_inline_parser *parser);
-
-/** Set the offset in bytes in the chunk being processed by the given inline parser.
- */
-CMARK_EXPORT
-void cmark_inline_parser_set_offset(cmark_inline_parser *parser, int offset);
-
-/** Gets the cmark_chunk being operated on by the given inline parser.
- * Use cmark_inline_parser_get_offset to get our current position in the chunk.
- */
-CMARK_EXPORT
-cmark_chunk *cmark_inline_parser_get_chunk(cmark_inline_parser *parser);
-
-/** Returns 1 if the inline parser is currently in a bracket; pass 1 for 'image'
- * if you want to know about an image-type bracket, 0 for link-type. */
-CMARK_EXPORT
-int cmark_inline_parser_in_bracket(cmark_inline_parser *parser, int image);
-
-/** Remove the last n characters from the last child of the given node.
- * This only works where all n characters are in the single last child, and the last
- * child is CMARK_NODE_TEXT.
- */
-CMARK_EXPORT
-void cmark_node_unput(cmark_node *node, int n);
-
-
-/** Get the character located at the current inline parsing offset
- */
-CMARK_EXPORT
-unsigned char cmark_inline_parser_peek_char(cmark_inline_parser *parser);
-
-/** Get the character located 'pos' bytes in the current line.
- */
-CMARK_EXPORT
-unsigned char cmark_inline_parser_peek_at(cmark_inline_parser *parser, int pos);
-
-/** Whether the inline parser has reached the end of the current line
- */
-CMARK_EXPORT
-int cmark_inline_parser_is_eof(cmark_inline_parser *parser);
-
-/** Get the characters located after the current inline parsing offset
- * while 'pred' matches. Free after usage.
- */
-CMARK_EXPORT
-char *cmark_inline_parser_take_while(cmark_inline_parser *parser, cmark_inline_predicate pred);
-
-/** Push a delimiter on the delimiter stack.
- * See <<http://spec.commonmark.org/0.24/#phase-2-inline-structure> for
- * more information on the parameters
- */
-CMARK_EXPORT
-void cmark_inline_parser_push_delimiter(cmark_inline_parser *parser,
-                                  unsigned char c,
-                                  int can_open,
-                                  int can_close,
-                                  cmark_node *inl_text);
-
-/** Remove 'delim' from the delimiter stack
- */
-CMARK_EXPORT
-void cmark_inline_parser_remove_delimiter(cmark_inline_parser *parser, delimiter *delim);
-
-CMARK_EXPORT
-delimiter *cmark_inline_parser_get_last_delimiter(cmark_inline_parser *parser);
-
-CMARK_EXPORT
-int cmark_inline_parser_get_line(cmark_inline_parser *parser);
-
-CMARK_EXPORT
-int cmark_inline_parser_get_column(cmark_inline_parser *parser);
-
-/** Convenience function to scan a given delimiter.
- *
- * 'left_flanking' and 'right_flanking' will be set to true if they
- * respectively precede and follow a non-space, non-punctuation
- * character.
- *
- * Additionally, 'punct_before' and 'punct_after' will respectively be set
- * if the preceding or following character is a punctuation character.
- *
- * Note that 'left_flanking' and 'right_flanking' can both be 'true'.
- *
- * Returns the number of delimiters encountered, in the limit
- * of 'max_delims', and advances the inline parsing offset.
- */
-CMARK_EXPORT
-int cmark_inline_parser_scan_delimiters(cmark_inline_parser *parser,
-                                  int max_delims,
-                                  unsigned char c,
-                                  int *left_flanking,
-                                  int *right_flanking,
-                                  int *punct_before,
-                                  int *punct_after);
-
-CMARK_EXPORT
-void cmark_manage_extensions_special_characters(cmark_parser *parser, bool add);
-
-CMARK_EXPORT
-cmark_llist *cmark_parser_get_syntax_extensions(cmark_parser *parser);
-
-CMARK_EXPORT
-void cmark_arena_push(void);
-
-CMARK_EXPORT
-int cmark_arena_pop(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/cbits/cmark_version.h b/cbits/cmark_version.h
deleted file mode 100644
--- a/cbits/cmark_version.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef CMARK_VERSION_H
-#define CMARK_VERSION_H
-
-#define CMARK_VERSION ((0 << 24) | (28 << 16) | (0 << 8) | 5)
-#define CMARK_VERSION_STRING "0.28.0.gfm.5"
-#define CMARK_GFM_VERSION 5
-
-#endif
diff --git a/cbits/cmarkextensions_export.h b/cbits/cmarkextensions_export.h
deleted file mode 100644
--- a/cbits/cmarkextensions_export.h
+++ /dev/null
@@ -1,41 +0,0 @@
-
-#ifndef CMARKEXTENSIONS_EXPORT_H
-#define CMARKEXTENSIONS_EXPORT_H
-
-#ifdef CMARKEXTENSIONS_STATIC_DEFINE
-#  define CMARKEXTENSIONS_EXPORT
-#  define CMARKEXTENSIONS_NO_EXPORT
-#else
-#  ifndef CMARKEXTENSIONS_EXPORT
-#    ifdef libcmark_gfmextensions_EXPORTS
-        /* We are building this library */
-#      define CMARKEXTENSIONS_EXPORT __attribute__((visibility("default")))
-#    else
-        /* We are using this library */
-#      define CMARKEXTENSIONS_EXPORT __attribute__((visibility("default")))
-#    endif
-#  endif
-
-#  ifndef CMARKEXTENSIONS_NO_EXPORT
-#    define CMARKEXTENSIONS_NO_EXPORT __attribute__((visibility("hidden")))
-#  endif
-#endif
-
-#ifndef CMARKEXTENSIONS_DEPRECATED
-#  define CMARKEXTENSIONS_DEPRECATED __attribute__ ((__deprecated__))
-#endif
-
-#ifndef CMARKEXTENSIONS_DEPRECATED_EXPORT
-#  define CMARKEXTENSIONS_DEPRECATED_EXPORT CMARKEXTENSIONS_EXPORT CMARKEXTENSIONS_DEPRECATED
-#endif
-
-#ifndef CMARKEXTENSIONS_DEPRECATED_NO_EXPORT
-#  define CMARKEXTENSIONS_DEPRECATED_NO_EXPORT CMARKEXTENSIONS_NO_EXPORT CMARKEXTENSIONS_DEPRECATED
-#endif
-
-#define DEFINE_NO_DEPRECATED 0
-#if DEFINE_NO_DEPRECATED
-# define CMARKEXTENSIONS_NO_DEPRECATED
-#endif
-
-#endif
diff --git a/cbits/commonmark.c b/cbits/commonmark.c
--- a/cbits/commonmark.c
+++ b/cbits/commonmark.c
@@ -5,7 +5,7 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "utf8.h"
@@ -35,7 +35,7 @@
       c < 0x80 && escape != LITERAL &&
       ((escape == NORMAL &&
         (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' ||
-         c == '>' || c == '\\' || c == '`' || c == '!' ||
+         c == '>' || c == '\\' || c == '`' || c == '~' || c == '!' ||
          (c == '&' && cmark_isalpha(nextc)) || (c == '!' && nextc == '[') ||
          (renderer->begin_content && (c == '-' || c == '+' || c == '=') &&
           // begin_content doesn't get set to false til we've passed digits
@@ -460,6 +460,29 @@
         LIT("\"");
       }
       LIT(")");
+    }
+    break;
+
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
+    if (entering) {
+      LIT("[^");
+      OUT(cmark_chunk_to_cstr(renderer->mem, &node->as.literal), false, LITERAL);
+      LIT("]");
+    }
+    break;
+
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
+    if (entering) {
+      renderer->footnote_ix += 1;
+      LIT("[^");
+      char n[32];
+      snprintf(n, sizeof(n), "%d", renderer->footnote_ix);
+      OUT(n, false, LITERAL);
+      LIT("]:\n");
+
+      cmark_strbuf_puts(renderer->prefix, "    ");
+    } else {
+      cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 4);
     }
     break;
 
diff --git a/cbits/core-extensions.c b/cbits/core-extensions.c
--- a/cbits/core-extensions.c
+++ b/cbits/core-extensions.c
@@ -1,9 +1,10 @@
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 #include "autolink.h"
 #include "strikethrough.h"
 #include "table.h"
 #include "tagfilter.h"
 #include "registry.h"
+#include "plugin.h"
 
 static int core_extensions_registration(cmark_plugin *plugin) {
   cmark_plugin_register_syntax_extension(plugin, create_table_extension());
@@ -14,7 +15,7 @@
   return 1;
 }
 
-void core_extensions_ensure_registered(void) {
+void cmark_gfm_core_extensions_ensure_registered(void) {
   static int registered = 0;
 
   if (!registered) {
diff --git a/cbits/core-extensions.h b/cbits/core-extensions.h
deleted file mode 100644
--- a/cbits/core-extensions.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef CORE_EXTENSIONS_H
-#define CORE_EXTENSIONS_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <cmark_extension_api.h>
-#include "cmarkextensions_export.h"
-
-CMARKEXTENSIONS_EXPORT
-void core_extensions_ensure_registered(void);
-
-CMARKEXTENSIONS_EXPORT
-uint16_t cmarkextensions_get_table_columns(cmark_node *node);
-
-CMARKEXTENSIONS_EXPORT
-uint8_t *cmarkextensions_get_table_alignments(cmark_node *node);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/cbits/ext_scanners.h b/cbits/ext_scanners.h
--- a/cbits/ext_scanners.h
+++ b/cbits/ext_scanners.h
@@ -1,5 +1,5 @@
 #include "chunk.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/cbits/footnotes.c b/cbits/footnotes.c
new file mode 100644
--- /dev/null
+++ b/cbits/footnotes.c
@@ -0,0 +1,40 @@
+#include "cmark-gfm.h"
+#include "parser.h"
+#include "footnotes.h"
+#include "inlines.h"
+#include "chunk.h"
+
+static void footnote_free(cmark_map *map, cmark_map_entry *_ref) {
+  cmark_footnote *ref = (cmark_footnote *)_ref;
+  cmark_mem *mem = map->mem;
+  if (ref != NULL) {
+    mem->free(ref->entry.label);
+    if (ref->node)
+      cmark_node_free(ref->node);
+    mem->free(ref);
+  }
+}
+
+void cmark_footnote_create(cmark_map *map, cmark_node *node) {
+  cmark_footnote *ref;
+  unsigned char *reflabel = normalize_map_label(map->mem, &node->as.literal);
+
+  /* empty footnote name, or composed from only whitespace */
+  if (reflabel == NULL)
+    return;
+
+  assert(map->sorted == NULL);
+
+  ref = (cmark_footnote *)map->mem->calloc(1, sizeof(*ref));
+  ref->entry.label = reflabel;
+  ref->node = node;
+  ref->entry.age = map->size;
+  ref->entry.next = map->refs;
+
+  map->refs = (cmark_map_entry *)ref;
+  map->size++;
+}
+
+cmark_map *cmark_footnote_map_new(cmark_mem *mem) {
+  return cmark_map_new(mem, footnote_free);
+}
diff --git a/cbits/footnotes.h b/cbits/footnotes.h
new file mode 100644
--- /dev/null
+++ b/cbits/footnotes.h
@@ -0,0 +1,25 @@
+#ifndef CMARK_FOOTNOTES_H
+#define CMARK_FOOTNOTES_H
+
+#include "map.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct cmark_footnote {
+  cmark_map_entry entry;
+  cmark_node *node;
+  unsigned int ix;
+};
+
+typedef struct cmark_footnote cmark_footnote;
+
+void cmark_footnote_create(cmark_map *map, cmark_node *node);
+cmark_map *cmark_footnote_map_new(cmark_mem *mem);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cbits/houdini.h b/cbits/houdini.h
--- a/cbits/houdini.h
+++ b/cbits/houdini.h
@@ -31,22 +31,22 @@
 #define HOUDINI_ESCAPED_SIZE(x) (((x)*12) / 10)
 #define HOUDINI_UNESCAPED_SIZE(x) (x)
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src,
                                       bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src,
                                bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src,
                                 bufsize_t size, int secure);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src,
                                  bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src,
                                     bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src,
                                bufsize_t size);
 
diff --git a/cbits/html.c b/cbits/html.c
--- a/cbits/html.c
+++ b/cbits/html.c
@@ -4,11 +4,12 @@
 #include <assert.h>
 #include "cmark_ctype.h"
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "houdini.h"
 #include "scanners.h"
 #include "syntax_extension.h"
 #include "html.h"
+#include "render.h"
 
 // Functions to convert cmark_nodes to HTML strings.
 
@@ -58,6 +59,20 @@
     cmark_strbuf_put(html, data, (bufsize_t)len);
 }
 
+static bool S_put_footnote_backref(cmark_html_renderer *renderer, cmark_strbuf *html) {
+  if (renderer->written_footnote_ix >= renderer->footnote_ix)
+    return false;
+  renderer->written_footnote_ix = renderer->footnote_ix;
+
+  cmark_strbuf_puts(html, "<a href=\"#fnref");
+  char n[32];
+  snprintf(n, sizeof(n), "%d", renderer->footnote_ix);
+  cmark_strbuf_puts(html, n);
+  cmark_strbuf_puts(html, "\" class=\"footnote-backref\">↩</a>");
+
+  return true;
+}
+
 static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
                          cmark_event_type ev_type, int options) {
   cmark_node *parent;
@@ -188,12 +203,20 @@
         cmark_html_render_sourcepos(node, html, options);
         cmark_strbuf_puts(html, " lang=\"");
         escape_html(html, node->as.code.info.data, first_tag);
+        if (first_tag < node->as.code.info.len && (options & CMARK_OPT_FULL_INFO_STRING)) {
+          cmark_strbuf_puts(html, "\" data-meta=\"");
+          escape_html(html, node->as.code.info.data + first_tag + 1, node->as.code.info.len - first_tag - 1);
+        }
         cmark_strbuf_puts(html, "\"><code>");
       } else {
         cmark_strbuf_puts(html, "<pre");
         cmark_html_render_sourcepos(node, html, options);
         cmark_strbuf_puts(html, "><code class=\"language-");
         escape_html(html, node->as.code.info.data, first_tag);
+        if (first_tag < node->as.code.info.len && (options & CMARK_OPT_FULL_INFO_STRING)) {
+          cmark_strbuf_puts(html, "\" data-meta=\"");
+          escape_html(html, node->as.code.info.data + first_tag + 1, node->as.code.info.len - first_tag - 1);
+        }
         cmark_strbuf_puts(html, "\">");
       }
     }
@@ -248,6 +271,10 @@
         cmark_html_render_sourcepos(node, html, options);
         cmark_strbuf_putc(html, '>');
       } else {
+        if (parent->type == CMARK_NODE_FOOTNOTE_DEFINITION && node->next == NULL) {
+          cmark_strbuf_putc(html, ' ');
+          S_put_footnote_backref(renderer, html);
+        }
         cmark_strbuf_puts(html, "</p>\n");
       }
     }
@@ -362,6 +389,37 @@
     }
     break;
 
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
+    if (entering) {
+      if (renderer->footnote_ix == 0) {
+        cmark_strbuf_puts(html, "<section class=\"footnotes\">\n<ol>\n");
+      }
+      ++renderer->footnote_ix;
+      cmark_strbuf_puts(html, "<li id=\"fn");
+      char n[32];
+      snprintf(n, sizeof(n), "%d", renderer->footnote_ix);
+      cmark_strbuf_puts(html, n);
+      cmark_strbuf_puts(html, "\">\n");
+    } else {
+      if (S_put_footnote_backref(renderer, html)) {
+        cmark_strbuf_putc(html, '\n');
+      }
+      cmark_strbuf_puts(html, "</li>\n");
+    }
+    break;
+
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
+    if (entering) {
+      cmark_strbuf_puts(html, "<sup class=\"footnote-ref\"><a href=\"#fn");
+      cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
+      cmark_strbuf_puts(html, "\" id=\"fnref");
+      cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
+      cmark_strbuf_puts(html, "\">");
+      cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
+      cmark_strbuf_puts(html, "</a></sup>");
+    }
+    break;
+
   default:
     assert(false);
     break;
@@ -379,7 +437,7 @@
   cmark_strbuf html = CMARK_BUF_INIT(mem);
   cmark_event_type ev_type;
   cmark_node *cur;
-  cmark_html_renderer renderer = {&html, NULL, NULL, NULL};
+  cmark_html_renderer renderer = {&html, NULL, NULL, 0, 0, NULL};
   cmark_iter *iter = cmark_iter_new(root);
 
   for (; extensions; extensions = extensions->next)
@@ -393,6 +451,11 @@
     cur = cmark_iter_get_node(iter);
     S_render_node(&renderer, cur, ev_type, options);
   }
+
+  if (renderer.footnote_ix) {
+    cmark_strbuf_puts(&html, "</ol>\n</section>\n");
+  }
+
   result = (char *)cmark_strbuf_detach(&html);
 
   cmark_llist_free(mem, renderer.filter_extensions);
diff --git a/cbits/inlines.c b/cbits/inlines.c
--- a/cbits/inlines.c
+++ b/cbits/inlines.c
@@ -7,7 +7,7 @@
 #include "node.h"
 #include "parser.h"
 #include "references.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "houdini.h"
 #include "utf8.h"
 #include "scanners.h"
@@ -50,13 +50,16 @@
   bufsize_t pos;
   int block_offset;
   int column_offset;
-  cmark_reference_map *refmap;
+  cmark_map *refmap;
   delimiter *last_delim;
   bracket *last_bracket;
   bufsize_t backticks[MAXBACKTICKS + 1];
   bool scanned_for_backticks;
 } subject;
 
+// Extensions may populate this.
+static int8_t SKIP_CHARS[256];
+
 static CMARK_INLINE bool S_is_line_end_char(char c) {
   return (c == '\n' || c == '\r');
 }
@@ -67,7 +70,7 @@
 static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent, int options);
 
 static void subject_from_buf(cmark_mem *mem, int line_number, int block_offset, subject *e,
-                             cmark_strbuf *buffer, cmark_reference_map *refmap);
+                             cmark_chunk *buffer, cmark_map *refmap);
 static bufsize_t subject_find_special_char(subject *subj, int options);
 
 // Create an inline with a literal string value.
@@ -154,12 +157,10 @@
 }
 
 static void subject_from_buf(cmark_mem *mem, int line_number, int block_offset, subject *e,
-                             cmark_strbuf *buffer, cmark_reference_map *refmap) {
+                             cmark_chunk *chunk, cmark_map *refmap) {
   int i;
   e->mem = mem;
-  e->input.data = buffer->ptr;
-  e->input.len = buffer->size;
-  e->input.alloc = 0;
+  e->input = *chunk;
   e->line = line_number;
   e->pos = 0;
   e->block_offset = block_offset;
@@ -175,13 +176,17 @@
 
 static CMARK_INLINE int isbacktick(int c) { return (c == '`'); }
 
-static CMARK_INLINE unsigned char peek_char(subject *subj) {
+static CMARK_INLINE unsigned char peek_char_n(subject *subj, bufsize_t n) {
   // 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;
+  assert(!(subj->pos + n < subj->input.len && subj->input.data[subj->pos + n] == 0));
+  return (subj->pos + n < subj->input.len) ? subj->input.data[subj->pos + n] : 0;
 }
 
+static CMARK_INLINE unsigned char peek_char(subject *subj) {
+  return peek_char_n(subj, 0);
+}
+
 static CMARK_INLINE unsigned char peek_at(subject *subj, bufsize_t pos) {
   return subj->input.data[pos];
 }
@@ -345,7 +350,7 @@
 static int scan_delims(subject *subj, unsigned char c, bool *can_open,
                        bool *can_close) {
   int numdelims = 0;
-  bufsize_t before_char_pos;
+  bufsize_t before_char_pos, after_char_pos;
   int32_t after_char = 0;
   int32_t before_char = 0;
   int len;
@@ -356,12 +361,12 @@
   } 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) {
+    while ((peek_at(subj, before_char_pos) >> 6 == 2 || SKIP_CHARS[peek_at(subj, before_char_pos)]) && 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) {
+    if (len == -1 || (before_char < 256 && SKIP_CHARS[(unsigned char) before_char])) {
       before_char = 10;
     }
   }
@@ -376,11 +381,20 @@
     }
   }
 
-  len = cmark_utf8proc_iterate(subj->input.data + subj->pos,
-                               subj->input.len - subj->pos, &after_char);
-  if (len == -1) {
+  if (subj->pos == subj->input.len) {
     after_char = 10;
+  } else {
+    after_char_pos = subj->pos;
+    while (SKIP_CHARS[peek_at(subj, after_char_pos)] && after_char_pos < subj->input.len) {
+      after_char_pos += 1;
+    }
+    len = cmark_utf8proc_iterate(subj->input.data + after_char_pos,
+                                 subj->input.len - after_char_pos, &after_char);
+    if (len == -1 || (after_char < 256 && SKIP_CHARS[(unsigned char) after_char])) {
+    after_char = 10;
   }
+  }
+
   left_flanking = numdelims > 0 && !cmark_utf8proc_is_space(after_char) &&
                   (!cmark_utf8proc_is_punctuation(after_char) ||
                    cmark_utf8proc_is_space(before_char) ||
@@ -395,7 +409,8 @@
     *can_close = right_flanking &&
                  (!left_flanking || cmark_utf8proc_is_punctuation(after_char));
   } else if (c == '\'' || c == '"') {
-    *can_open = left_flanking && !right_flanking;
+    *can_open = left_flanking && !right_flanking &&
+	         before_char != ']' && before_char != ')';
     *can_close = right_flanking;
   } else {
     *can_open = left_flanking;
@@ -686,7 +701,7 @@
   cmark_node *tmp, *tmpnext, *emph;
 
   // calculate the actual number of characters used from this closer
-  use_delims = (closer_num_chars >= 2 && opener_num_chars >=2) ? 2 : 1;
+  use_delims = (closer_num_chars >= 2 && opener_num_chars >= 2) ? 2 : 1;
 
   // remove used characters from associated inlines.
   opener_num_chars -= use_delims;
@@ -770,8 +785,8 @@
   return make_str(subj, subj->pos - 1 - len, subj->pos - 1, cmark_chunk_buf_detach(&ent));
 }
 
-// Clean a URL: remove surrounding whitespace and surrounding <>,
-// and remove \ that escape punctuation.
+// Clean a URL: remove surrounding whitespace, and remove \ that escape
+// punctuation.
 cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url) {
   cmark_strbuf buf = CMARK_BUF_INIT(mem);
 
@@ -782,11 +797,7 @@
     return result;
   }
 
-  if (url->data[0] == '<' && url->data[url->len - 1] == '>') {
-    houdini_unescape_html_f(&buf, url->data + 1, url->len - 2);
-  } else {
-    houdini_unescape_html_f(&buf, url->data, url->len);
-  }
+  houdini_unescape_html_f(&buf, url->data, url->len);
 
   cmark_strbuf_unescape(&buf);
   return cmark_chunk_buf_detach(&buf);
@@ -912,10 +923,47 @@
   subj->pos = startpos; // rewind
   return 0;
 }
-static bufsize_t manual_scan_link_url(cmark_chunk *input, bufsize_t offset) {
+
+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]))
+      break;
+    else
+      ++i;
+  }
+
+  if (i >= input->len)
+    return -1;
+
+  {
+    cmark_chunk result = {input->data + offset, i - offset, 0};
+    *output = result;
+  }
+  return i - offset;
+}
+
+static bufsize_t manual_scan_link_url(cmark_chunk *input, bufsize_t offset,
+                                      cmark_chunk *output) {
+  bufsize_t i = offset;
+
   if (i < input->len && input->data[i] == '<') {
     ++i;
     while (i < input->len) {
@@ -924,44 +972,30 @@
         break;
       } else if (input->data[i] == '\\')
         i += 2;
-      else if (cmark_isspace(input->data[i]))
-        return -1;
+      else if (input->data[i] == '\n' || input->data[i] == '<')
+        return manual_scan_link_url_2(input, offset, output);
       else
         ++i;
     }
   } else {
-    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]))
-        break;
-      else
-        ++i;
-    }
+    return manual_scan_link_url_2(input, offset, output);
   }
 
   if (i >= input->len)
     return -1;
+
+  {
+    cmark_chunk result = {input->data + offset + 1, i - 2 - offset, 0};
+    *output = result;
+  }
   return i - offset;
 }
+
 // Return a link, an image, or a literal close bracket.
 static cmark_node *handle_close_bracket(cmark_parser *parser, subject *subj) {
   bufsize_t initial_pos, after_link_text_pos;
-  bufsize_t starturl, endurl, starttitle, endtitle, endall;
-  bufsize_t n;
-  bufsize_t sps;
+  bufsize_t endurl, starttitle, endtitle, endall;
+  bufsize_t sps, n;
   cmark_reference *ref = NULL;
   cmark_chunk url_chunk, title_chunk;
   cmark_chunk url, title;
@@ -997,11 +1031,11 @@
   // 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)) > -1)) {
+      ((n = manual_scan_link_url(&subj->input, subj->pos + 1 + sps,
+                                 &url_chunk)) > -1)) {
 
     // try to parse an explicit link:
-    starturl = subj->pos + 1 + sps; // after (
-    endurl = starturl + n;
+    endurl = subj->pos + 1 + sps + n;
     starttitle = endurl + scan_spacechars(&subj->input, endurl);
 
     // ensure there are spaces btw url and title
@@ -1014,7 +1048,6 @@
     if (peek_at(subj, endall) == ')') {
       subj->pos = endall + 1;
 
-      url_chunk = cmark_chunk_dup(&subj->input, starturl, endurl - starturl);
       title_chunk =
           cmark_chunk_dup(&subj->input, starttitle, endtitle - starttitle);
       url = cmark_clean_url(subj->mem, &url_chunk);
@@ -1047,7 +1080,7 @@
   }
 
   if (found_label) {
-    ref = cmark_reference_lookup(subj->refmap, &raw_label);
+    ref = (cmark_reference *)cmark_map_lookup(subj->refmap, &raw_label);
     cmark_chunk_free(subj->mem, &raw_label);
   }
 
@@ -1060,7 +1093,28 @@
   }
 
 noMatch:
-  // If we fall through to here, it means we didn't match a link:
+  // If we fall through to here, it means we didn't match a link.
+  // What if we're a footnote link?
+  if (parser->options & CMARK_OPT_FOOTNOTES &&
+      opener->inl_text->next &&
+      opener->inl_text->next->type == CMARK_NODE_TEXT &&
+      !opener->inl_text->next->next) {
+    cmark_chunk *literal = &opener->inl_text->next->as.literal;
+    if (literal->len > 1 && literal->data[0] == '^') {
+      inl = make_simple(subj->mem, CMARK_NODE_FOOTNOTE_REFERENCE);
+      inl->as.literal = cmark_chunk_dup(literal, 1, literal->len - 1);
+      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);
+      cmark_node_free(opener->inl_text->next);
+      cmark_node_free(opener->inl_text);
+      process_emphasis(parser, subj, opener->previous_delimiter);
+      pop_bracket(subj);
+      return NULL;
+    }
+  }
+
   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("]"));
@@ -1173,12 +1227,16 @@
   return subj->input.len;
 }
 
-void cmark_inlines_add_special_character(unsigned char c) {
+void cmark_inlines_add_special_character(unsigned char c, bool emphasis) {
   SPECIAL_CHARS[c] = 1;
+  if (emphasis)
+    SKIP_CHARS[c] = 1;
 }
 
-void cmark_inlines_remove_special_character(unsigned char c) {
+void cmark_inlines_remove_special_character(unsigned char c, bool emphasis) {
   SPECIAL_CHARS[c] = 0;
+  if (emphasis)
+    SKIP_CHARS[c] = 0;
 }
 
 static cmark_node *try_extensions(cmark_parser *parser,
@@ -1249,7 +1307,7 @@
     break;
   case '!':
     advance(subj);
-    if (peek_char(subj) == '[') {
+    if (peek_char(subj) == '[' && peek_char_n(subj, 1) != '^') {
       advance(subj);
       new_inl = make_str(subj, subj->pos - 2, subj->pos - 1, cmark_chunk_literal("!["));
       push_bracket(subj, true, new_inl);
@@ -1284,10 +1342,11 @@
 // Parse inlines from parent's string_content, adding as children of parent.
 void cmark_parse_inlines(cmark_parser *parser,
                          cmark_node *parent,
-                         cmark_reference_map *refmap,
+                         cmark_map *refmap,
                          int options) {
   subject subj;
-  subject_from_buf(parser->mem, parent->start_line, parent->start_column - 1 + parent->internal_offset, &subj, &parent->content, refmap);
+  cmark_chunk content = {parent->content.ptr, parent->content.size, 0};
+  subject_from_buf(parser->mem, parent->start_line, parent->start_column - 1 + parent->internal_offset, &subj, &content, refmap);
   cmark_chunk_rtrim(&subj.input);
 
   while (!is_eof(&subj) && parse_inline(parser, &subj, parent, options))
@@ -1315,8 +1374,8 @@
 // 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_strbuf *input,
-                                       cmark_reference_map *refmap) {
+bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
+                                       cmark_map *refmap) {
   subject subj;
 
   cmark_chunk lab;
@@ -1341,9 +1400,8 @@
 
   // parse link url:
   spnl(&subj);
-  matchlen = manual_scan_link_url(&subj.input, subj.pos);
-  if (matchlen > 0) {
-    url = cmark_chunk_dup(&subj.input, subj.pos, matchlen);
+  if ((matchlen = manual_scan_link_url(&subj.input, subj.pos, &url)) > -1 &&
+      url.len > 0) {
     subj.pos += matchlen;
   } else {
     return 0;
diff --git a/cbits/inlines.h b/cbits/inlines.h
--- a/cbits/inlines.h
+++ b/cbits/inlines.h
@@ -10,17 +10,17 @@
 cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url);
 cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_parse_inlines(cmark_parser *parser,
                          cmark_node *parent,
-                         cmark_reference_map *refmap,
+                         cmark_map *refmap,
                          int options);
 
-bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_strbuf *input,
-                                       cmark_reference_map *refmap);
+bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
+                                       cmark_map *refmap);
 
-void cmark_inlines_add_special_character(unsigned char c);
-void cmark_inlines_remove_special_character(unsigned char c);
+void cmark_inlines_add_special_character(unsigned char c, bool emphasis);
+void cmark_inlines_remove_special_character(unsigned char c, bool emphasis);
 
 #ifdef __cplusplus
 }
diff --git a/cbits/iterator.c b/cbits/iterator.c
--- a/cbits/iterator.c
+++ b/cbits/iterator.c
@@ -3,7 +3,7 @@
 
 #include "config.h"
 #include "node.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "iterator.h"
 
 cmark_iter *cmark_iter_new(cmark_node *root) {
diff --git a/cbits/iterator.h b/cbits/iterator.h
--- a/cbits/iterator.h
+++ b/cbits/iterator.h
@@ -5,7 +5,7 @@
 extern "C" {
 #endif
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "memory.h"
 
 typedef struct {
diff --git a/cbits/latex.c b/cbits/latex.c
--- a/cbits/latex.c
+++ b/cbits/latex.c
@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "utf8.h"
@@ -256,24 +256,24 @@
       CR();
       list_number = cmark_node_get_list_start(node);
       if (list_number > 1) {
-	enumlevel = S_get_enumlevel(node);
-	// latex normally supports only five levels
-	if (enumlevel >= 1 && enumlevel <= 5) {
+        enumlevel = S_get_enumlevel(node);
+        // latex normally supports only five levels
+        if (enumlevel >= 1 && enumlevel <= 5) {
           snprintf(list_number_string, LIST_NUMBER_STRING_SIZE, "%d",
                    list_number);
           LIT("\\setcounter{enum");
-          switch(enumlevel) {
-	  case 1: LIT("i"); break;
-	  case 2: LIT("ii"); break;
-	  case 3: LIT("iii"); break;
-	  case 4: LIT("iv"); break;
-	  case 5: LIT("v"); break;
-	  default: LIT("i"); break;
+          switch (enumlevel) {
+          case 1: LIT("i"); break;
+          case 2: LIT("ii"); break;
+          case 3: LIT("iii"); break;
+          case 4: LIT("iv"); break;
+          case 5: LIT("v"); break;
+          default: LIT("i"); break;
 	  }
           LIT("}{");
           OUT(list_number_string, false, NORMAL);
           LIT("}");
-	}
+        }
         CR();
       }
     } else {
@@ -442,6 +442,11 @@
       LIT("}");
       return 0;
     }
+    break;
+
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
+    // TODO
     break;
 
   default:
diff --git a/cbits/linked_list.c b/cbits/linked_list.c
--- a/cbits/linked_list.c
+++ b/cbits/linked_list.c
@@ -1,6 +1,6 @@
 #include <stdlib.h>
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 
 cmark_llist *cmark_llist_append(cmark_mem *mem, cmark_llist *head, void *data) {
   cmark_llist *tmp;
diff --git a/cbits/man.c b/cbits/man.c
--- a/cbits/man.c
+++ b/cbits/man.c
@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "utf8.h"
@@ -254,6 +254,11 @@
     } else {
       LIT("]");
     }
+    break;
+
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
+    // TODO
     break;
 
   default:
diff --git a/cbits/map.c b/cbits/map.c
new file mode 100644
--- /dev/null
+++ b/cbits/map.c
@@ -0,0 +1,122 @@
+#include "map.h"
+#include "utf8.h"
+#include "parser.h"
+
+// normalize map label:  collapse internal whitespace to single space,
+// remove leading/trailing whitespace, case fold
+// Return NULL if the label is actually empty (i.e. composed solely from
+// whitespace)
+unsigned char *normalize_map_label(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;
+}
+
+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_map_entry *r1 = *(cmark_map_entry **)p1;
+  cmark_map_entry *r2 = *(cmark_map_entry **)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_map_entry *ref = *(cmark_map_entry **)p2;
+  return labelcmp((const unsigned char *)label, ref->label);
+}
+
+static void sort_map(cmark_map *map) {
+  unsigned int i = 0, last = 0, size = map->size;
+  cmark_map_entry *r = map->refs, **sorted = NULL;
+
+  sorted = (cmark_map_entry **)map->mem->calloc(size, sizeof(cmark_map_entry *));
+  while (r) {
+    sorted[i++] = r;
+    r = r->next;
+  }
+
+  qsort(sorted, size, sizeof(cmark_map_entry *), 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;
+}
+
+cmark_map_entry *cmark_map_lookup(cmark_map *map, cmark_chunk *label) {
+  cmark_map_entry **ref = NULL;
+  unsigned char *norm;
+
+  if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH)
+    return NULL;
+
+  if (map == NULL || !map->size)
+    return NULL;
+
+  norm = normalize_map_label(map->mem, label);
+  if (norm == NULL)
+    return NULL;
+
+  if (!map->sorted)
+    sort_map(map);
+
+  ref = (cmark_map_entry **)bsearch(norm, map->sorted, map->size, sizeof(cmark_map_entry *), refsearch);
+  map->mem->free(norm);
+
+  if (!ref)
+    return NULL;
+
+  return ref[0];
+}
+
+void cmark_map_free(cmark_map *map) {
+  cmark_map_entry *ref;
+
+  if (map == NULL)
+    return;
+
+  ref = map->refs;
+  while (ref) {
+    cmark_map_entry *next = ref->next;
+    map->free(map, ref);
+    ref = next;
+  }
+
+  map->mem->free(map->sorted);
+  map->mem->free(map);
+}
+
+cmark_map *cmark_map_new(cmark_mem *mem, cmark_map_free_f free) {
+  cmark_map *map = (cmark_map *)mem->calloc(1, sizeof(cmark_map));
+  map->mem = mem;
+  map->free = free;
+  return map;
+}
diff --git a/cbits/map.h b/cbits/map.h
new file mode 100644
--- /dev/null
+++ b/cbits/map.h
@@ -0,0 +1,42 @@
+#ifndef CMARK_MAP_H
+#define CMARK_MAP_H
+
+#include "memory.h"
+#include "chunk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct cmark_map_entry {
+  struct cmark_map_entry *next;
+  unsigned char *label;
+  unsigned int age;
+};
+
+typedef struct cmark_map_entry cmark_map_entry;
+
+struct cmark_map;
+
+typedef void (*cmark_map_free_f)(struct cmark_map *, cmark_map_entry *);
+
+struct cmark_map {
+  cmark_mem *mem;
+  cmark_map_entry *refs;
+  cmark_map_entry **sorted;
+  unsigned int size;
+  cmark_map_free_f free;
+};
+
+typedef struct cmark_map cmark_map;
+
+unsigned char *normalize_map_label(cmark_mem *mem, cmark_chunk *ref);
+cmark_map *cmark_map_new(cmark_mem *mem, cmark_map_free_f free);
+void cmark_map_free(cmark_map *map);
+cmark_map_entry *cmark_map_lookup(cmark_map *map, cmark_chunk *label);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/cbits/node.c b/cbits/node.c
--- a/cbits/node.c
+++ b/cbits/node.c
@@ -21,6 +21,7 @@
   switch (node->type) {
   case CMARK_NODE_DOCUMENT:
   case CMARK_NODE_BLOCK_QUOTE:
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
   case CMARK_NODE_ITEM:
     return CMARK_NODE_TYPE_BLOCK_P(child_type) && child_type != CMARK_NODE_ITEM;
 
@@ -108,6 +109,8 @@
     case CMARK_NODE_HTML_INLINE:
     case CMARK_NODE_CODE:
     case CMARK_NODE_HTML_BLOCK:
+    case CMARK_NODE_FOOTNOTE_REFERENCE:
+    case CMARK_NODE_FOOTNOTE_DEFINITION:
     cmark_chunk_free(NODE_MEM(node), &node->as.literal);
       break;
     case CMARK_NODE_LINK:
@@ -319,6 +322,7 @@
   case CMARK_NODE_TEXT:
   case CMARK_NODE_HTML_INLINE:
   case CMARK_NODE_CODE:
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
     return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.literal);
 
   case CMARK_NODE_CODE_BLOCK:
@@ -341,6 +345,7 @@
   case CMARK_NODE_TEXT:
   case CMARK_NODE_HTML_INLINE:
   case CMARK_NODE_CODE:
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
     cmark_chunk_set_cstr(NODE_MEM(node), &node->as.literal, content);
     return 1;
 
diff --git a/cbits/node.h b/cbits/node.h
--- a/cbits/node.h
+++ b/cbits/node.h
@@ -8,8 +8,8 @@
 #include <stdio.h>
 #include <stdint.h>
 
-#include "cmark.h"
-#include "cmark_extension_api.h"
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
 #include "buffer.h"
 #include "chunk.h"
 
@@ -89,7 +89,7 @@
 static CMARK_INLINE cmark_mem *cmark_node_mem(cmark_node *node) {
   return node->content.mem;
 }
-CMARK_EXPORT int cmark_node_check(cmark_node *node, FILE *out);
+CMARK_GFM_EXPORT int cmark_node_check(cmark_node *node, FILE *out);
 
 static CMARK_INLINE bool CMARK_NODE_TYPE_BLOCK_P(cmark_node_type node_type) {
 	return (node_type & CMARK_NODE_TYPE_MASK) == CMARK_NODE_TYPE_BLOCK;
@@ -107,7 +107,7 @@
 	return node != NULL && CMARK_NODE_TYPE_INLINE_P((cmark_node_type) node->type);
 }
 
-CMARK_EXPORT bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type);
+CMARK_GFM_EXPORT bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type);
 
 #ifdef __cplusplus
 }
diff --git a/cbits/parser.h b/cbits/parser.h
--- a/cbits/parser.h
+++ b/cbits/parser.h
@@ -15,7 +15,7 @@
 struct cmark_parser {
   struct cmark_mem *mem;
   /* A hashtable of urls in the current document for cross-references */
-  struct cmark_reference_map *refmap;
+  struct cmark_map *refmap;
   /* The root node of the parser, always a CMARK_NODE_DOCUMENT */
   struct cmark_node *root;
   /* The last open block after a line is fully processed */
diff --git a/cbits/plaintext.c b/cbits/plaintext.c
--- a/cbits/plaintext.c
+++ b/cbits/plaintext.c
@@ -1,5 +1,6 @@
 #include "node.h"
 #include "syntax_extension.h"
+#include "render.h"
 
 #define OUT(s, wrap, escaping) renderer->out(renderer, node, s, wrap, escaping)
 #define LIT(s) renderer->out(renderer, node, s, false, LITERAL)
diff --git a/cbits/plugin.h b/cbits/plugin.h
--- a/cbits/plugin.h
+++ b/cbits/plugin.h
@@ -5,8 +5,8 @@
 extern "C" {
 #endif
 
-#include "cmark.h"
-#include "cmark_extension_api.h"
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
 
 /**
  * cmark_plugin:
diff --git a/cbits/references.c b/cbits/references.c
--- a/cbits/references.c
+++ b/cbits/references.c
@@ -1,53 +1,24 @@
-#include "cmark.h"
-#include "utf8.h"
+#include "cmark-gfm.h"
 #include "parser.h"
 #include "references.h"
 #include "inlines.h"
 #include "chunk.h"
 
-static void reference_free(cmark_reference_map *map, cmark_reference *ref) {
+static void reference_free(cmark_map *map, cmark_map_entry *_ref) {
+  cmark_reference *ref = (cmark_reference *)_ref;
   cmark_mem *mem = map->mem;
   if (ref != NULL) {
-    mem->free(ref->label);
+    mem->free(ref->entry.label);
     cmark_chunk_free(mem, &ref->url);
     cmark_chunk_free(mem, &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,
+void cmark_reference_create(cmark_map *map, cmark_chunk *label,
                             cmark_chunk *url, cmark_chunk *title) {
   cmark_reference *ref;
-  unsigned char *reflabel = normalize_reference(map->mem, label);
+  unsigned char *reflabel = normalize_map_label(map->mem, label);
 
   /* empty reference name, or composed from only whitespace */
   if (reflabel == NULL)
@@ -56,101 +27,16 @@
   assert(map->sorted == NULL);
 
   ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref));
-  ref->label = reflabel;
+  ref->entry.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;
+  ref->entry.age = map->size;
+  ref->entry.next = map->refs;
 
-  map->refs = ref;
+  map->refs = (cmark_map_entry *)ref;
   map->size++;
 }
 
-static int
-labelcmp(const unsigned char *a, const unsigned char *b) {
-  return strcmp((const char *)a, (const char *)b);
-}
-
-static int
-refcmp(const void *p1, const void *p2) {
-  cmark_reference *r1 = *(cmark_reference **)p1;
-  cmark_reference *r2 = *(cmark_reference **)p2;
-  int res = labelcmp(r1->label, r2->label);
-  return res ? res : ((int)r1->age - (int)r2->age);
-}
-
-static int
-refsearch(const void *label, const void *p2) {
-  cmark_reference *ref = *(cmark_reference **)p2;
-  return labelcmp((const unsigned char *)label, ref->label);
-}
-
-static void sort_references(cmark_reference_map *map) {
-  unsigned int i = 0, last = 0, size = map->size;
-  cmark_reference *r = map->refs, **sorted = NULL;
-
-  sorted = (cmark_reference **)map->mem->calloc(size, sizeof(cmark_reference *));
-  while (r) {
-    sorted[i++] = r;
-    r = r->next;
-  }
-
-  qsort(sorted, size, sizeof(cmark_reference *), refcmp);
-
-  for (i = 1; i < size; i++) {
-    if (labelcmp(sorted[i]->label, sorted[last]->label) != 0)
-      sorted[++last] = sorted[i];
-  }
-
-  map->sorted = sorted;
-  map->size = last + 1;
-}
-
-// Returns reference if refmap contains a reference with matching
-// label, otherwise NULL.
-cmark_reference *cmark_reference_lookup(cmark_reference_map *map,
-                                        cmark_chunk *label) {
-  cmark_reference **ref = NULL;
-  unsigned char *norm;
-
-  if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH)
-    return NULL;
-
-  if (map == NULL || !map->size)
-    return NULL;
-
-  norm = normalize_reference(map->mem, label);
-  if (norm == NULL)
-    return NULL;
-
-  if (!map->sorted)
-    sort_references(map);
-
-  ref = (cmark_reference **)bsearch(norm, map->sorted, map->size, sizeof(cmark_reference *), refsearch);
-  map->mem->free(norm);
-  return ref ? ref[0] : NULL;
-}
-
-void cmark_reference_map_free(cmark_reference_map *map) {
-  cmark_reference *ref;
-
-  if (map == NULL)
-    return;
-
-  ref = map->refs;
-  while (ref) {
-    cmark_reference *next = ref->next;
-    reference_free(map, ref);
-    ref = next;
-  }
-
-  map->mem->free(map->sorted);
-  map->mem->free(map);
-}
-
-cmark_reference_map *cmark_reference_map_new(cmark_mem *mem) {
-  cmark_reference_map *map =
-      (cmark_reference_map *)mem->calloc(1, sizeof(cmark_reference_map));
-  map->mem = mem;
-  return map;
+cmark_map *cmark_reference_map_new(cmark_mem *mem) {
+  return cmark_map_new(mem, reference_free);
 }
diff --git a/cbits/references.h b/cbits/references.h
--- a/cbits/references.h
+++ b/cbits/references.h
@@ -1,38 +1,23 @@
 #ifndef CMARK_REFERENCES_H
 #define CMARK_REFERENCES_H
 
-#include "memory.h"
-#include "chunk.h"
+#include "map.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 struct cmark_reference {
-  struct cmark_reference *next;
-  unsigned char *label;
+  cmark_map_entry entry;
   cmark_chunk url;
   cmark_chunk title;
-  unsigned int age;
 };
 
 typedef struct cmark_reference cmark_reference;
 
-struct cmark_reference_map {
-  cmark_mem *mem;
-  cmark_reference *refs;
-  cmark_reference **sorted;
-  unsigned int size;
-};
-
-typedef struct cmark_reference_map cmark_reference_map;
-
-cmark_reference_map *cmark_reference_map_new(cmark_mem *mem);
-void cmark_reference_map_free(cmark_reference_map *map);
-cmark_reference *cmark_reference_lookup(cmark_reference_map *map,
-                                        cmark_chunk *label);
-extern void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label,
-                                   cmark_chunk *url, cmark_chunk *title);
+void cmark_reference_create(cmark_map *map, cmark_chunk *label,
+                            cmark_chunk *url, cmark_chunk *title);
+cmark_map *cmark_reference_map_new(cmark_mem *mem);
 
 #ifdef __cplusplus
 }
diff --git a/cbits/registry.c b/cbits/registry.c
--- a/cbits/registry.c
+++ b/cbits/registry.c
@@ -3,7 +3,7 @@
 #include <string.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "syntax_extension.h"
 #include "registry.h"
 #include "plugin.h"
diff --git a/cbits/registry.h b/cbits/registry.h
--- a/cbits/registry.h
+++ b/cbits/registry.h
@@ -5,16 +5,16 @@
 extern "C" {
 #endif
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "plugin.h"
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_register_plugin(cmark_plugin_init_func reg_fn);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_release_plugins(void);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_llist *cmark_list_syntax_extensions(cmark_mem *mem);
 
 #ifdef __cplusplus
diff --git a/cbits/render.c b/cbits/render.c
--- a/cbits/render.c
+++ b/cbits/render.c
@@ -1,7 +1,7 @@
 #include <stdlib.h>
 #include "buffer.h"
 #include "chunk.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "utf8.h"
 #include "render.h"
 #include "node.h"
@@ -174,7 +174,8 @@
 
   cmark_renderer renderer = {mem,   &buf, &pref, 0,           width,
                              0,     0,    true,  true,        false,
-                             false, outc, S_cr,  S_blankline, S_out};
+                             false, outc, S_cr,  S_blankline, S_out,
+                             0};
 
   while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
     cur = cmark_iter_get_node(iter);
diff --git a/cbits/render.h b/cbits/render.h
--- a/cbits/render.h
+++ b/cbits/render.h
@@ -28,6 +28,7 @@
   void (*cr)(struct cmark_renderer *);
   void (*blankline)(struct cmark_renderer *);
   void (*out)(struct cmark_renderer *, cmark_node *, const char *, bool, cmark_escaping);
+  unsigned int footnote_ix;
 };
 
 typedef struct cmark_renderer cmark_renderer;
@@ -36,6 +37,8 @@
   cmark_strbuf *html;
   cmark_node *plain;
   cmark_llist *filter_extensions;
+  unsigned int footnote_ix;
+  unsigned int written_footnote_ix;
   void *opaque;
 };
 
diff --git a/cbits/scanners.c b/cbits/scanners.c
--- a/cbits/scanners.c
+++ b/cbits/scanners.c
@@ -1,18049 +1,10694 @@
-/* Generated by re2c 0.15.3 */
-#include <stdlib.h>
-#include "chunk.h"
-#include "scanners.h"
-
-bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c,
-                   bufsize_t offset) {
-  bufsize_t res;
-  unsigned char *ptr = (unsigned char *)c->data;
-
-  if (ptr == NULL || offset > c->len) {
-    return 0;
-  } else {
-    unsigned char lim = ptr[c->len];
-
-    ptr[c->len] = '\0';
-    res = scanner(ptr + offset);
-    ptr[c->len] = lim;
-  }
-
-  return res;
-}
-
-// Try to match a scheme including colon.
-bufsize_t _scan_scheme(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    yych = *p;
-    if (yych <= '@')
-      goto yy2;
-    if (yych <= 'Z')
-      goto yy4;
-    if (yych <= '`')
-      goto yy2;
-    if (yych <= 'z')
-      goto yy4;
-  yy2:
-    ++p;
-  yy3 : { return 0; }
-  yy4:
-    yych = *(marker = ++p);
-    if (yych <= '/') {
-      if (yych <= '+') {
-        if (yych <= '*')
-          goto yy3;
-      } else {
-        if (yych <= ',')
-          goto yy3;
-        if (yych >= '/')
-          goto yy3;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '9')
-          goto yy5;
-        if (yych <= '@')
-          goto yy3;
-      } else {
-        if (yych <= '`')
-          goto yy3;
-        if (yych >= '{')
-          goto yy3;
-      }
-    }
-  yy5:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych == '+')
-          goto yy9;
-      } else {
-        if (yych != '/')
-          goto yy9;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych >= 'A')
-          goto yy9;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych <= 'z')
-          goto yy9;
-      }
-    }
-  yy6:
-    p = marker;
-    goto yy3;
-  yy7:
-    ++p;
-    { return (bufsize_t)(p - start); }
-  yy9:
-    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 <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy6;
-      } else {
-        if (yych == '/')
-          goto yy6;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy7;
-        if (yych <= '@')
-          goto yy6;
-      } else {
-        if (yych <= '`')
-          goto yy6;
-        if (yych >= '{')
-          goto yy6;
-      }
-    }
-    ++p;
-    if ((yych = *p) == ':')
-      goto yy7;
-    goto yy6;
-  }
-}
-
-// Try to match URI autolink after first <, returning number of chars matched.
-bufsize_t _scan_autolink_uri(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    static const unsigned char yybm[] = {
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   128, 128, 128, 128, 128, 128, 128, 128, 128,
-        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
-        128, 128, 128, 128, 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, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,
-    };
-    yych = *p;
-    if (yych <= '@')
-      goto yy41;
-    if (yych <= 'Z')
-      goto yy43;
-    if (yych <= '`')
-      goto yy41;
-    if (yych <= 'z')
-      goto yy43;
-  yy41:
-    ++p;
-  yy42 : { return 0; }
-  yy43:
-    yych = *(marker = ++p);
-    if (yych <= '/') {
-      if (yych <= '+') {
-        if (yych <= '*')
-          goto yy42;
-      } else {
-        if (yych <= ',')
-          goto yy42;
-        if (yych >= '/')
-          goto yy42;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '9')
-          goto yy44;
-        if (yych <= '@')
-          goto yy42;
-      } else {
-        if (yych <= '`')
-          goto yy42;
-        if (yych >= '{')
-          goto yy42;
-      }
-    }
-  yy44:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych == '+')
-          goto yy48;
-      } else {
-        if (yych != '/')
-          goto yy48;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych >= 'A')
-          goto yy48;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych <= 'z')
-          goto yy48;
-      }
-    }
-  yy45:
-    p = marker;
-    goto yy42;
-  yy46:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy46;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= ' ')
-          goto yy45;
-        if (yych <= '>')
-          goto yy85;
-        goto yy45;
-      } else {
-        if (yych <= 0xDF)
-          goto yy78;
-        if (yych <= 0xE0)
-          goto yy79;
-        goto yy80;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy84;
-        if (yych <= 0xEF)
-          goto yy80;
-        goto yy81;
-      } else {
-        if (yych <= 0xF3)
-          goto yy82;
-        if (yych <= 0xF4)
-          goto yy83;
-        goto yy45;
-      }
-    }
-  yy48:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych <= ',') {
-        if (yych != '+')
-          goto yy45;
-      } else {
-        if (yych == '/')
-          goto yy45;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= ':')
-          goto yy46;
-        if (yych <= '@')
-          goto yy45;
-      } else {
-        if (yych <= '`')
-          goto yy45;
-        if (yych >= '{')
-          goto yy45;
-      }
-    }
-    yych = *++p;
-    if (yych == ':')
-      goto yy46;
-    goto yy45;
-  yy78:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy45;
-    if (yych <= 0xBF)
-      goto yy46;
-    goto yy45;
-  yy79:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy45;
-    if (yych <= 0xBF)
-      goto yy78;
-    goto yy45;
-  yy80:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy45;
-    if (yych <= 0xBF)
-      goto yy78;
-    goto yy45;
-  yy81:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy45;
-    if (yych <= 0xBF)
-      goto yy80;
-    goto yy45;
-  yy82:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy45;
-    if (yych <= 0xBF)
-      goto yy80;
-    goto yy45;
-  yy83:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy45;
-    if (yych <= 0x8F)
-      goto yy80;
-    goto yy45;
-  yy84:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy45;
-    if (yych <= 0x9F)
-      goto yy78;
-    goto yy45;
-  yy85:
-    ++p;
-    { return (bufsize_t)(p - start); }
-  }
-}
-
-// Try to match email autolink after first <, returning num of chars matched.
-bufsize_t _scan_autolink_email(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    static const unsigned char yybm[] = {
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   128, 0,   128, 128, 128, 128, 128, 0,   0,
-        128, 128, 0,   128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
-        128, 128, 0,   0,   0,   128, 0,   128, 0,   128, 128, 128, 128, 128,
-        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
-        128, 128, 128, 128, 128, 128, 128, 0,   0,   0,   128, 128, 128, 128,
-        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
-        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
-        128, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,
-    };
-    yych = *p;
-    if (yych <= '9') {
-      if (yych <= '\'') {
-        if (yych == '!')
-          goto yy91;
-        if (yych >= '#')
-          goto yy91;
-      } else {
-        if (yych <= ')')
-          goto yy89;
-        if (yych != ',')
-          goto yy91;
-      }
-    } else {
-      if (yych <= '?') {
-        if (yych == '=')
-          goto yy91;
-        if (yych >= '?')
-          goto yy91;
-      } else {
-        if (yych <= 'Z') {
-          if (yych >= 'A')
-            goto yy91;
-        } else {
-          if (yych <= ']')
-            goto yy89;
-          if (yych <= '~')
-            goto yy91;
-        }
-      }
-    }
-  yy89:
-    ++p;
-  yy90 : { return 0; }
-  yy91:
-    yych = *(marker = ++p);
-    if (yych <= ',') {
-      if (yych <= '"') {
-        if (yych == '!')
-          goto yy95;
-        goto yy90;
-      } else {
-        if (yych <= '\'')
-          goto yy95;
-        if (yych <= ')')
-          goto yy90;
-        if (yych <= '+')
-          goto yy95;
-        goto yy90;
-      }
-    } else {
-      if (yych <= '>') {
-        if (yych <= '9')
-          goto yy95;
-        if (yych == '=')
-          goto yy95;
-        goto yy90;
-      } else {
-        if (yych <= 'Z')
-          goto yy95;
-        if (yych <= ']')
-          goto yy90;
-        if (yych <= '~')
-          goto yy95;
-        goto yy90;
-      }
-    }
-  yy92:
-    yych = *++p;
-    if (yych <= '@') {
-      if (yych <= '/')
-        goto yy93;
-      if (yych <= '9')
-        goto yy96;
-    } else {
-      if (yych <= 'Z')
-        goto yy96;
-      if (yych <= '`')
-        goto yy93;
-      if (yych <= 'z')
-        goto yy96;
-    }
-  yy93:
-    p = marker;
-    goto yy90;
-  yy94:
-    ++p;
-    yych = *p;
-  yy95:
-    if (yybm[0 + yych] & 128) {
-      goto yy94;
-    }
-    if (yych <= '>')
-      goto yy93;
-    if (yych <= '@')
-      goto yy92;
-    goto yy93;
-  yy96:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy98;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych >= ':')
-          goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy227;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy226;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy226;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy226;
-        goto yy93;
-      }
-    }
-  yy98:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy227;
-      if (yych <= '/')
-        goto yy93;
-      goto yy226;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-        goto yy226;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy226;
-        goto yy93;
-      }
-    }
-  yy99:
-    ++p;
-    yych = *p;
-    if (yych <= '@') {
-      if (yych <= '/')
-        goto yy93;
-      if (yych <= '9')
-        goto yy102;
-      goto yy93;
-    } else {
-      if (yych <= 'Z')
-        goto yy102;
-      if (yych <= '`')
-        goto yy93;
-      if (yych <= 'z')
-        goto yy102;
-      goto yy93;
-    }
-  yy100:
-    ++p;
-    { return (bufsize_t)(p - start); }
-  yy102:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy104;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych >= ':')
-          goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy106;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy105;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy105;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy105;
-        goto yy93;
-      }
-    }
-  yy104:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy106;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy105:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy108;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy107;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy107;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy107;
-        goto yy93;
-      }
-    }
-  yy106:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy108;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy107:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy110;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy109;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy109;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy109;
-        goto yy93;
-      }
-    }
-  yy108:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy110;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy109:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy112;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy111;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy111;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy111;
-        goto yy93;
-      }
-    }
-  yy110:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy112;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy111:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy114;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy113;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy113;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy113;
-        goto yy93;
-      }
-    }
-  yy112:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy114;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy113:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy116;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy115;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy115;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy115;
-        goto yy93;
-      }
-    }
-  yy114:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy116;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy115:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy118;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy117;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy117;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy117;
-        goto yy93;
-      }
-    }
-  yy116:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy118;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy117:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy120;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy119;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy119;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy119;
-        goto yy93;
-      }
-    }
-  yy118:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy120;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy119:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy122;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy121;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy121;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy121;
-        goto yy93;
-      }
-    }
-  yy120:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy122;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy121:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy124;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy123;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy123;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy123;
-        goto yy93;
-      }
-    }
-  yy122:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy124;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy123:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy126;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy125;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy125;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy125;
-        goto yy93;
-      }
-    }
-  yy124:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy126;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy125:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy128;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy127;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy127;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy127;
-        goto yy93;
-      }
-    }
-  yy126:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy128;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy127:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy130;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy129;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy129;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy129;
-        goto yy93;
-      }
-    }
-  yy128:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy130;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy129:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy132;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy131;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy131;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy131;
-        goto yy93;
-      }
-    }
-  yy130:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy132;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy131:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy134;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy133;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy133;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy133;
-        goto yy93;
-      }
-    }
-  yy132:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy134;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy133:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy136;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy135;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy135;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy135;
-        goto yy93;
-      }
-    }
-  yy134:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy136;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy135:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy138;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy137;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy137;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy137;
-        goto yy93;
-      }
-    }
-  yy136:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy138;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy137:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy140;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy139;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy139;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy139;
-        goto yy93;
-      }
-    }
-  yy138:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy140;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy139:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy142;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy141;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy141;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy141;
-        goto yy93;
-      }
-    }
-  yy140:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy142;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy141:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy144;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy143;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy143;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy143;
-        goto yy93;
-      }
-    }
-  yy142:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy144;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy143:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy146;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy145;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy145;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy145;
-        goto yy93;
-      }
-    }
-  yy144:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy146;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy145:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy148;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy147;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy147;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy147;
-        goto yy93;
-      }
-    }
-  yy146:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy148;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy147:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy150;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy149;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy149;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy149;
-        goto yy93;
-      }
-    }
-  yy148:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy150;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy149:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy152;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy151;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy151;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy151;
-        goto yy93;
-      }
-    }
-  yy150:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy152;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy151:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy154;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy153;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy153;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy153;
-        goto yy93;
-      }
-    }
-  yy152:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy154;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy153:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy156;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy155;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy155;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy155;
-        goto yy93;
-      }
-    }
-  yy154:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy156;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy155:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy158;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy157;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy157;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy157;
-        goto yy93;
-      }
-    }
-  yy156:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy158;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy157:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy160;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy159;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy159;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy159;
-        goto yy93;
-      }
-    }
-  yy158:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy160;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy159:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy162;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy161;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy161;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy161;
-        goto yy93;
-      }
-    }
-  yy160:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy162;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy161:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy164;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy163;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy163;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy163;
-        goto yy93;
-      }
-    }
-  yy162:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy164;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy163:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy166;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy165;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy165;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy165;
-        goto yy93;
-      }
-    }
-  yy164:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy166;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy165:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy168;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy167;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy167;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy167;
-        goto yy93;
-      }
-    }
-  yy166:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy168;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy167:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy170;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy169;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy169;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy169;
-        goto yy93;
-      }
-    }
-  yy168:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy170;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy169:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy172;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy171;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy171;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy171;
-        goto yy93;
-      }
-    }
-  yy170:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy172;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy171:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy174;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy173;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy173;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy173;
-        goto yy93;
-      }
-    }
-  yy172:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy174;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy173:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy176;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy175;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy175;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy175;
-        goto yy93;
-      }
-    }
-  yy174:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy176;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy175:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy178;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy177;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy177;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy177;
-        goto yy93;
-      }
-    }
-  yy176:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy178;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy177:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy180;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy179;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy179;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy179;
-        goto yy93;
-      }
-    }
-  yy178:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy180;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy179:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy182;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy181;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy181;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy181;
-        goto yy93;
-      }
-    }
-  yy180:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy182;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy181:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy184;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy183;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy183;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy183;
-        goto yy93;
-      }
-    }
-  yy182:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy184;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy183:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy186;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy185;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy185;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy185;
-        goto yy93;
-      }
-    }
-  yy184:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy186;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy185:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy188;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy187;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy187;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy187;
-        goto yy93;
-      }
-    }
-  yy186:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy188;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy187:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy190;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy189;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy189;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy189;
-        goto yy93;
-      }
-    }
-  yy188:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy190;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy189:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy192;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy191;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy191;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy191;
-        goto yy93;
-      }
-    }
-  yy190:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy192;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy191:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy194;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy193;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy193;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy193;
-        goto yy93;
-      }
-    }
-  yy192:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy194;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy193:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy196;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy195;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy195;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy195;
-        goto yy93;
-      }
-    }
-  yy194:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy196;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy195:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy198;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy197;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy197;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy197;
-        goto yy93;
-      }
-    }
-  yy196:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy198;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy197:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy200;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy199;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy199;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy199;
-        goto yy93;
-      }
-    }
-  yy198:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy200;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy199:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy202;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy201;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy201;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy201;
-        goto yy93;
-      }
-    }
-  yy200:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy202;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy201:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy204;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy203;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy203;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy203;
-        goto yy93;
-      }
-    }
-  yy202:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy204;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy203:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy206;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy205;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy205;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy205;
-        goto yy93;
-      }
-    }
-  yy204:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy206;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy205:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy208;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy207;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy207;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy207;
-        goto yy93;
-      }
-    }
-  yy206:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy208;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy207:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy210;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy209;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy209;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy209;
-        goto yy93;
-      }
-    }
-  yy208:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy210;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy209:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy212;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy211;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy211;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy211;
-        goto yy93;
-      }
-    }
-  yy210:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy212;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy211:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy214;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy213;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy213;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy213;
-        goto yy93;
-      }
-    }
-  yy212:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy214;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy213:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy216;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy215;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy215;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy215;
-        goto yy93;
-      }
-    }
-  yy214:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy216;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy215:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy218;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy217;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy217;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy217;
-        goto yy93;
-      }
-    }
-  yy216:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy218;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy217:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy220;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy219;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy219;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy219;
-        goto yy93;
-      }
-    }
-  yy218:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy220;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy219:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy222;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy221;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy221;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy221;
-        goto yy93;
-      }
-    }
-  yy220:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy222;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy221:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy224;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy223;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy223;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy223;
-        goto yy93;
-      }
-    }
-  yy222:
-    ++p;
-    yych = *p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy224;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy223:
-    ++p;
-    yych = *p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= '-')
-          goto yy93;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy225;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy225;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy225;
-        goto yy93;
-      }
-    }
-  yy224:
-    ++p;
-    yych = *p;
-    if (yych <= '@') {
-      if (yych <= '/')
-        goto yy93;
-      if (yych >= ':')
-        goto yy93;
-    } else {
-      if (yych <= 'Z')
-        goto yy225;
-      if (yych <= '`')
-        goto yy93;
-      if (yych >= '{')
-        goto yy93;
-    }
-  yy225:
-    ++p;
-    yych = *p;
-    if (yych == '.')
-      goto yy99;
-    if (yych == '>')
-      goto yy100;
-    goto yy93;
-  yy226:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy229;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy228;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy228;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy228;
-        goto yy93;
-      }
-    }
-  yy227:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy229;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy228:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy231;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy230;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy230;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy230;
-        goto yy93;
-      }
-    }
-  yy229:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy231;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy230:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy233;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy232;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy232;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy232;
-        goto yy93;
-      }
-    }
-  yy231:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy233;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy232:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy235;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy234;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy234;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy234;
-        goto yy93;
-      }
-    }
-  yy233:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy235;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy234:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy237;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy236;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy236;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy236;
-        goto yy93;
-      }
-    }
-  yy235:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy237;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy236:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy239;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy238;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy238;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy238;
-        goto yy93;
-      }
-    }
-  yy237:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy239;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy238:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy241;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy240;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy240;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy240;
-        goto yy93;
-      }
-    }
-  yy239:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy241;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy240:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy243;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy242;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy242;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy242;
-        goto yy93;
-      }
-    }
-  yy241:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy243;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy242:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy245;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy244;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy244;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy244;
-        goto yy93;
-      }
-    }
-  yy243:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy245;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy244:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy247;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy246;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy246;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy246;
-        goto yy93;
-      }
-    }
-  yy245:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy247;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy246:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy249;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy248;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy248;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy248;
-        goto yy93;
-      }
-    }
-  yy247:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy249;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy248:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy251;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy250;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy250;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy250;
-        goto yy93;
-      }
-    }
-  yy249:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy251;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy250:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy253;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy252;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy252;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy252;
-        goto yy93;
-      }
-    }
-  yy251:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy253;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy252:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy255;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy254;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy254;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy254;
-        goto yy93;
-      }
-    }
-  yy253:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy255;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy254:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy257;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy256;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy256;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy256;
-        goto yy93;
-      }
-    }
-  yy255:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy257;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy256:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy259;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy258;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy258;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy258;
-        goto yy93;
-      }
-    }
-  yy257:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy259;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy258:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy261;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy260;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy260;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy260;
-        goto yy93;
-      }
-    }
-  yy259:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy261;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy260:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy263;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy262;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy262;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy262;
-        goto yy93;
-      }
-    }
-  yy261:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy263;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy262:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy265;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy264;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy264;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy264;
-        goto yy93;
-      }
-    }
-  yy263:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy265;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy264:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy267;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy266;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy266;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy266;
-        goto yy93;
-      }
-    }
-  yy265:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy267;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy266:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy269;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy268;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy268;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy268;
-        goto yy93;
-      }
-    }
-  yy267:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy269;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy268:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy271;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy270;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy270;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy270;
-        goto yy93;
-      }
-    }
-  yy269:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy271;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy270:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy273;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy272;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy272;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy272;
-        goto yy93;
-      }
-    }
-  yy271:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy273;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy272:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy275;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy274;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy274;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy274;
-        goto yy93;
-      }
-    }
-  yy273:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy275;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy274:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy277;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy276;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy276;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy276;
-        goto yy93;
-      }
-    }
-  yy275:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy277;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy276:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy279;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy278;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy278;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy278;
-        goto yy93;
-      }
-    }
-  yy277:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy279;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy278:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy281;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy280;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy280;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy280;
-        goto yy93;
-      }
-    }
-  yy279:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy281;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy280:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy283;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy282;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy282;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy282;
-        goto yy93;
-      }
-    }
-  yy281:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy283;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy282:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy285;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy284;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy284;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy284;
-        goto yy93;
-      }
-    }
-  yy283:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy285;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy284:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy287;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy286;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy286;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy286;
-        goto yy93;
-      }
-    }
-  yy285:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy287;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy286:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy289;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy288;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy288;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy288;
-        goto yy93;
-      }
-    }
-  yy287:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy289;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy288:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy291;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy290;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy290;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy290;
-        goto yy93;
-      }
-    }
-  yy289:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy291;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy290:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy293;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy292;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy292;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy292;
-        goto yy93;
-      }
-    }
-  yy291:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy293;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy292:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy295;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy294;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy294;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy294;
-        goto yy93;
-      }
-    }
-  yy293:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy295;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy294:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy297;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy296;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy296;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy296;
-        goto yy93;
-      }
-    }
-  yy295:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy297;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy296:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy299;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy298;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy298;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy298;
-        goto yy93;
-      }
-    }
-  yy297:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy299;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy298:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy301;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy300;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy300;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy300;
-        goto yy93;
-      }
-    }
-  yy299:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy301;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy300:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy303;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy302;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy302;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy302;
-        goto yy93;
-      }
-    }
-  yy301:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy303;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy302:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy305;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy304;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy304;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy304;
-        goto yy93;
-      }
-    }
-  yy303:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy305;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy304:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy307;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy306;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy306;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy306;
-        goto yy93;
-      }
-    }
-  yy305:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy307;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy306:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy309;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy308;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy308;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy308;
-        goto yy93;
-      }
-    }
-  yy307:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy309;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy308:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy311;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy310;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy310;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy310;
-        goto yy93;
-      }
-    }
-  yy309:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy311;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy310:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy313;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy312;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy312;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy312;
-        goto yy93;
-      }
-    }
-  yy311:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy313;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy312:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy315;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy314;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy314;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy314;
-        goto yy93;
-      }
-    }
-  yy313:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy315;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy314:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy317;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy316;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy316;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy316;
-        goto yy93;
-      }
-    }
-  yy315:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy317;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy316:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy319;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy318;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy318;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy318;
-        goto yy93;
-      }
-    }
-  yy317:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy319;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy318:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy321;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy320;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy320;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy320;
-        goto yy93;
-      }
-    }
-  yy319:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy321;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy320:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy323;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy322;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy322;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy322;
-        goto yy93;
-      }
-    }
-  yy321:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy323;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy322:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy325;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy324;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy324;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy324;
-        goto yy93;
-      }
-    }
-  yy323:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy325;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy324:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy327;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy326;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy326;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy326;
-        goto yy93;
-      }
-    }
-  yy325:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy327;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy326:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy329;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy328;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy328;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy328;
-        goto yy93;
-      }
-    }
-  yy327:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy329;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy328:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy331;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy330;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy330;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy330;
-        goto yy93;
-      }
-    }
-  yy329:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy331;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy330:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy333;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy332;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy332;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy332;
-        goto yy93;
-      }
-    }
-  yy331:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy333;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy332:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy335;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy334;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy334;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy334;
-        goto yy93;
-      }
-    }
-  yy333:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy335;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy334:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy337;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy336;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy336;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy336;
-        goto yy93;
-      }
-    }
-  yy335:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy337;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy336:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy339;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy338;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy338;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy338;
-        goto yy93;
-      }
-    }
-  yy337:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy339;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy338:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy341;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy340;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy340;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy340;
-        goto yy93;
-      }
-    }
-  yy339:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy341;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy340:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy343;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy342;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy342;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy342;
-        goto yy93;
-      }
-    }
-  yy341:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy343;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy342:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= ',')
-          goto yy93;
-        if (yych <= '-')
-          goto yy345;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy344;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy344;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy344;
-        goto yy93;
-      }
-    }
-  yy343:
-    yych = *++p;
-    if (yych <= '9') {
-      if (yych == '-')
-        goto yy345;
-      if (yych <= '/')
-        goto yy93;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy93;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych >= '{')
-          goto yy93;
-      }
-    }
-  yy344:
-    yych = *++p;
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych <= '-')
-          goto yy93;
-        goto yy99;
-      } else {
-        if (yych <= '/')
-          goto yy93;
-        if (yych <= '9')
-          goto yy225;
-        goto yy93;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy100;
-        if (yych <= '@')
-          goto yy93;
-        goto yy225;
-      } else {
-        if (yych <= '`')
-          goto yy93;
-        if (yych <= 'z')
-          goto yy225;
-        goto yy93;
-      }
-    }
-  yy345:
-    ++p;
-    if ((yych = *p) <= '@') {
-      if (yych <= '/')
-        goto yy93;
-      if (yych <= '9')
-        goto yy225;
-      goto yy93;
-    } else {
-      if (yych <= 'Z')
-        goto yy225;
-      if (yych <= '`')
-        goto yy93;
-      if (yych <= 'z')
-        goto yy225;
-      goto yy93;
-    }
-  }
-}
-
-// Try to match an HTML tag after first <, returning num of chars matched.
-bufsize_t _scan_html_tag(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    static const unsigned char yybm[] = {
-        /* table 1 .. 8: 0 */
-        0, 239, 239, 239, 239, 239, 239, 239, 239, 238, 238, 238, 238, 238, 239,
-        239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
-        239, 239, 239, 238, 239, 234, 239, 239, 239, 239, 236, 239, 239, 239,
-        239, 239, 207, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
-        239, 239, 239, 238, 238, 174, 231, 239, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 239, 239, 111, 239, 239, 238, 239, 239,
-        239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
-        239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
-        239, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        /* table 9 .. 11: 256 */
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        160, 128, 0, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 128, 0,
-        0, 0, 0, 0, 0, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        160, 0, 0, 0, 0, 128, 0, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        160, 160, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    };
-    yych = *p;
-    if (yych <= '>') {
-      if (yych <= '!') {
-        if (yych >= '!')
-          goto yy350;
-      } else {
-        if (yych == '/')
-          goto yy351;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '?')
-          goto yy352;
-        if (yych >= 'A')
-          goto yy353;
-      } else {
-        if (yych <= '`')
-          goto yy348;
-        if (yych <= 'z')
-          goto yy353;
-      }
-    }
-  yy348:
-    ++p;
-  yy349 : { return 0; }
-  yy350:
-    yych = *(marker = ++p);
-    if (yybm[0 + yych] & 16) {
-      goto yy426;
-    }
-    if (yych == '-')
-      goto yy428;
-    if (yych <= '@')
-      goto yy349;
-    if (yych <= '[')
-      goto yy425;
-    goto yy349;
-  yy351:
-    yych = *(marker = ++p);
-    if (yych <= '@')
-      goto yy349;
-    if (yych <= 'Z')
-      goto yy421;
-    if (yych <= '`')
-      goto yy349;
-    if (yych <= 'z')
-      goto yy421;
-    goto yy349;
-  yy352:
-    yych = *(marker = ++p);
-    if (yych <= 0x00)
-      goto yy349;
-    if (yych <= 0x7F)
-      goto yy405;
-    if (yych <= 0xC1)
-      goto yy349;
-    if (yych <= 0xF4)
-      goto yy405;
-    goto yy349;
-  yy353:
-    yych = *(marker = ++p);
-    if (yybm[256 + yych] & 64) {
-      goto yy357;
-    }
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych != '-')
-          goto yy349;
-      } else {
-        if (yych <= '/')
-          goto yy359;
-        if (yych >= ':')
-          goto yy349;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy360;
-        if (yych <= '@')
-          goto yy349;
-      } else {
-        if (yych <= '`')
-          goto yy349;
-        if (yych >= '{')
-          goto yy349;
-      }
-    }
-  yy354:
-    ++p;
-    yych = *p;
-    if (yybm[256 + yych] & 64) {
-      goto yy357;
-    }
-    if (yych <= '=') {
-      if (yych <= '.') {
-        if (yych == '-')
-          goto yy354;
-      } else {
-        if (yych <= '/')
-          goto yy359;
-        if (yych <= '9')
-          goto yy354;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy360;
-        if (yych >= 'A')
-          goto yy354;
-      } else {
-        if (yych <= '`')
-          goto yy356;
-        if (yych <= 'z')
-          goto yy354;
-      }
-    }
-  yy356:
-    p = marker;
-    goto yy349;
-  yy357:
-    ++p;
-    yych = *p;
-    if (yybm[256 + yych] & 64) {
-      goto yy357;
-    }
-    if (yych <= '>') {
-      if (yych <= '9') {
-        if (yych != '/')
-          goto yy356;
-      } else {
-        if (yych <= ':')
-          goto yy362;
-        if (yych <= '=')
-          goto yy356;
-        goto yy360;
-      }
-    } else {
-      if (yych <= '^') {
-        if (yych <= '@')
-          goto yy356;
-        if (yych <= 'Z')
-          goto yy362;
-        goto yy356;
-      } else {
-        if (yych == '`')
-          goto yy356;
-        if (yych <= 'z')
-          goto yy362;
-        goto yy356;
-      }
-    }
-  yy359:
-    yych = *++p;
-    if (yych != '>')
-      goto yy356;
-  yy360:
-    ++p;
-    { return (bufsize_t)(p - start); }
-  yy362:
-    ++p;
-    yych = *p;
-    if (yybm[256 + yych] & 128) {
-      goto yy362;
-    }
-    if (yych <= ',') {
-      if (yych <= '\r') {
-        if (yych <= 0x08)
-          goto yy356;
-      } else {
-        if (yych != ' ')
-          goto yy356;
-      }
-    } else {
-      if (yych <= '<') {
-        if (yych <= '/')
-          goto yy359;
-        goto yy356;
-      } else {
-        if (yych <= '=')
-          goto yy366;
-        if (yych <= '>')
-          goto yy360;
-        goto yy356;
-      }
-    }
-  yy364:
-    ++p;
-    yych = *p;
-    if (yych <= '<') {
-      if (yych <= ' ') {
-        if (yych <= 0x08)
-          goto yy356;
-        if (yych <= '\r')
-          goto yy364;
-        if (yych <= 0x1F)
-          goto yy356;
-        goto yy364;
-      } else {
-        if (yych <= '/') {
-          if (yych <= '.')
-            goto yy356;
-          goto yy359;
-        } else {
-          if (yych == ':')
-            goto yy362;
-          goto yy356;
-        }
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '=')
-          goto yy366;
-        if (yych <= '>')
-          goto yy360;
-        if (yych <= '@')
-          goto yy356;
-        goto yy362;
-      } else {
-        if (yych <= '_') {
-          if (yych <= '^')
-            goto yy356;
-          goto yy362;
-        } else {
-          if (yych <= '`')
-            goto yy356;
-          if (yych <= 'z')
-            goto yy362;
-          goto yy356;
-        }
-      }
-    }
-  yy366:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 1) {
-      goto yy368;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '"') {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych >= '!')
-          goto yy379;
-      } else {
-        if (yych <= '\'')
-          goto yy377;
-        if (yych <= 0xC1)
-          goto yy356;
-        if (yych <= 0xDF)
-          goto yy370;
-        goto yy371;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy376;
-        goto yy372;
-      } else {
-        if (yych <= 0xF0)
-          goto yy373;
-        if (yych <= 0xF3)
-          goto yy374;
-        if (yych <= 0xF4)
-          goto yy375;
-        goto yy356;
-      }
-    }
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 1) {
-      goto yy368;
-    }
-    if (yych <= 0xDF) {
-      if (yych <= '\'') {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= ' ')
-          goto yy402;
-        if (yych <= '"')
-          goto yy379;
-        goto yy377;
-      } else {
-        if (yych == '>')
-          goto yy360;
-        if (yych <= 0xC1)
-          goto yy356;
-        goto yy370;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy371;
-        if (yych == 0xED)
-          goto yy376;
-        goto yy372;
-      } else {
-        if (yych <= 0xF0)
-          goto yy373;
-        if (yych <= 0xF3)
-          goto yy374;
-        if (yych <= 0xF4)
-          goto yy375;
-        goto yy356;
-      }
-    }
-  yy368:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 1) {
-      goto yy368;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '=') {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= ' ')
-          goto yy396;
-        goto yy356;
-      } else {
-        if (yych <= '>')
-          goto yy360;
-        if (yych <= 0xC1)
-          goto yy356;
-        if (yych >= 0xE0)
-          goto yy371;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy376;
-        goto yy372;
-      } else {
-        if (yych <= 0xF0)
-          goto yy373;
-        if (yych <= 0xF3)
-          goto yy374;
-        if (yych <= 0xF4)
-          goto yy375;
-        goto yy356;
-      }
-    }
-  yy370:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy368;
-    goto yy356;
-  yy371:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy370;
-    goto yy356;
-  yy372:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy370;
-    goto yy356;
-  yy373:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy372;
-    goto yy356;
-  yy374:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy372;
-    goto yy356;
-  yy375:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy372;
-    goto yy356;
-  yy376:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy370;
-    goto yy356;
-  yy377:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 2) {
-      goto yy377;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= '\'')
-          goto yy388;
-        goto yy356;
-      } else {
-        if (yych <= 0xDF)
-          goto yy389;
-        if (yych <= 0xE0)
-          goto yy390;
-        goto yy391;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy395;
-        if (yych <= 0xEF)
-          goto yy391;
-        goto yy392;
-      } else {
-        if (yych <= 0xF3)
-          goto yy393;
-        if (yych <= 0xF4)
-          goto yy394;
-        goto yy356;
-      }
-    }
-  yy379:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 4) {
-      goto yy379;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= '"')
-          goto yy388;
-        goto yy356;
-      } else {
-        if (yych <= 0xDF)
-          goto yy381;
-        if (yych <= 0xE0)
-          goto yy382;
-        goto yy383;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy387;
-        if (yych <= 0xEF)
-          goto yy383;
-        goto yy384;
-      } else {
-        if (yych <= 0xF3)
-          goto yy385;
-        if (yych <= 0xF4)
-          goto yy386;
-        goto yy356;
-      }
-    }
-  yy381:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy379;
-    goto yy356;
-  yy382:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy381;
-    goto yy356;
-  yy383:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy381;
-    goto yy356;
-  yy384:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy383;
-    goto yy356;
-  yy385:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy383;
-    goto yy356;
-  yy386:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy383;
-    goto yy356;
-  yy387:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy381;
-    goto yy356;
-  yy388:
-    ++p;
-    yych = *p;
-    if (yybm[256 + yych] & 64) {
-      goto yy357;
-    }
-    if (yych == '/')
-      goto yy359;
-    if (yych == '>')
-      goto yy360;
-    goto yy356;
-  yy389:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy377;
-    goto yy356;
-  yy390:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy389;
-    goto yy356;
-  yy391:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy389;
-    goto yy356;
-  yy392:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy391;
-    goto yy356;
-  yy393:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy391;
-    goto yy356;
-  yy394:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy391;
-    goto yy356;
-  yy395:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy389;
-    goto yy356;
-  yy396:
-    ++p;
-    yych = *p;
-    if (yych <= '@') {
-      if (yych <= '"') {
-        if (yych <= '\r') {
-          if (yych <= 0x00)
-            goto yy356;
-          if (yych <= 0x08)
-            goto yy368;
-          goto yy396;
-        } else {
-          if (yych == ' ')
-            goto yy396;
-          if (yych <= '!')
-            goto yy368;
-          goto yy356;
-        }
-      } else {
-        if (yych <= ':') {
-          if (yych == '\'')
-            goto yy356;
-          if (yych <= '9')
-            goto yy368;
-        } else {
-          if (yych <= ';')
-            goto yy368;
-          if (yych <= '=')
-            goto yy356;
-          if (yych <= '>')
-            goto yy360;
-          goto yy368;
-        }
-      }
-    } else {
-      if (yych <= 0xDF) {
-        if (yych <= '`') {
-          if (yych <= 'Z')
-            goto yy398;
-          if (yych <= '^')
-            goto yy368;
-          if (yych >= '`')
-            goto yy356;
-        } else {
-          if (yych <= 'z')
-            goto yy398;
-          if (yych <= 0x7F)
-            goto yy368;
-          if (yych <= 0xC1)
-            goto yy356;
-          goto yy370;
-        }
-      } else {
-        if (yych <= 0xEF) {
-          if (yych <= 0xE0)
-            goto yy371;
-          if (yych == 0xED)
-            goto yy376;
-          goto yy372;
-        } else {
-          if (yych <= 0xF0)
-            goto yy373;
-          if (yych <= 0xF3)
-            goto yy374;
-          if (yych <= 0xF4)
-            goto yy375;
-          goto yy356;
-        }
-      }
-    }
-  yy398:
-    ++p;
-    yych = *p;
-    if (yych <= '>') {
-      if (yych <= '&') {
-        if (yych <= 0x1F) {
-          if (yych <= 0x00)
-            goto yy356;
-          if (yych <= 0x08)
-            goto yy368;
-          if (yych >= 0x0E)
-            goto yy368;
-        } else {
-          if (yych <= ' ')
-            goto yy400;
-          if (yych == '"')
-            goto yy356;
-          goto yy368;
-        }
-      } else {
-        if (yych <= '/') {
-          if (yych <= '\'')
-            goto yy356;
-          if (yych <= ',')
-            goto yy368;
-          if (yych <= '.')
-            goto yy398;
-          goto yy368;
-        } else {
-          if (yych <= ';') {
-            if (yych <= ':')
-              goto yy398;
-            goto yy368;
-          } else {
-            if (yych <= '<')
-              goto yy356;
-            if (yych <= '=')
-              goto yy366;
-            goto yy360;
-          }
-        }
-      }
-    } else {
-      if (yych <= 0xC1) {
-        if (yych <= '_') {
-          if (yych <= '@')
-            goto yy368;
-          if (yych <= 'Z')
-            goto yy398;
-          if (yych <= '^')
-            goto yy368;
-          goto yy398;
-        } else {
-          if (yych <= '`')
-            goto yy356;
-          if (yych <= 'z')
-            goto yy398;
-          if (yych <= 0x7F)
-            goto yy368;
-          goto yy356;
-        }
-      } else {
-        if (yych <= 0xED) {
-          if (yych <= 0xDF)
-            goto yy370;
-          if (yych <= 0xE0)
-            goto yy371;
-          if (yych <= 0xEC)
-            goto yy372;
-          goto yy376;
-        } else {
-          if (yych <= 0xF0) {
-            if (yych <= 0xEF)
-              goto yy372;
-            goto yy373;
-          } else {
-            if (yych <= 0xF3)
-              goto yy374;
-            if (yych <= 0xF4)
-              goto yy375;
-            goto yy356;
-          }
-        }
-      }
-    }
-  yy400:
-    ++p;
-    yych = *p;
-    if (yych <= '@') {
-      if (yych <= '&') {
-        if (yych <= 0x1F) {
-          if (yych <= 0x00)
-            goto yy356;
-          if (yych <= 0x08)
-            goto yy368;
-          if (yych <= '\r')
-            goto yy400;
-          goto yy368;
-        } else {
-          if (yych <= ' ')
-            goto yy400;
-          if (yych == '"')
-            goto yy356;
-          goto yy368;
-        }
-      } else {
-        if (yych <= ';') {
-          if (yych <= '\'')
-            goto yy356;
-          if (yych == ':')
-            goto yy398;
-          goto yy368;
-        } else {
-          if (yych <= '<')
-            goto yy356;
-          if (yych <= '=')
-            goto yy366;
-          if (yych <= '>')
-            goto yy360;
-          goto yy368;
-        }
-      }
-    } else {
-      if (yych <= 0xDF) {
-        if (yych <= '`') {
-          if (yych <= 'Z')
-            goto yy398;
-          if (yych <= '^')
-            goto yy368;
-          if (yych <= '_')
-            goto yy398;
-          goto yy356;
-        } else {
-          if (yych <= 'z')
-            goto yy398;
-          if (yych <= 0x7F)
-            goto yy368;
-          if (yych <= 0xC1)
-            goto yy356;
-          goto yy370;
-        }
-      } else {
-        if (yych <= 0xEF) {
-          if (yych <= 0xE0)
-            goto yy371;
-          if (yych == 0xED)
-            goto yy376;
-          goto yy372;
-        } else {
-          if (yych <= 0xF0)
-            goto yy373;
-          if (yych <= 0xF3)
-            goto yy374;
-          if (yych <= 0xF4)
-            goto yy375;
-          goto yy356;
-        }
-      }
-    }
-  yy402:
-    ++p;
-    yych = *p;
-    if (yych <= '@') {
-      if (yych <= '"') {
-        if (yych <= '\r') {
-          if (yych <= 0x00)
-            goto yy356;
-          if (yych <= 0x08)
-            goto yy368;
-          goto yy402;
-        } else {
-          if (yych == ' ')
-            goto yy402;
-          if (yych <= '!')
-            goto yy368;
-          goto yy379;
-        }
-      } else {
-        if (yych <= ':') {
-          if (yych == '\'')
-            goto yy377;
-          if (yych <= '9')
-            goto yy368;
-          goto yy398;
-        } else {
-          if (yych <= ';')
-            goto yy368;
-          if (yych <= '=')
-            goto yy356;
-          if (yych <= '>')
-            goto yy360;
-          goto yy368;
-        }
-      }
-    } else {
-      if (yych <= 0xDF) {
-        if (yych <= '`') {
-          if (yych <= 'Z')
-            goto yy398;
-          if (yych <= '^')
-            goto yy368;
-          if (yych <= '_')
-            goto yy398;
-          goto yy356;
-        } else {
-          if (yych <= 'z')
-            goto yy398;
-          if (yych <= 0x7F)
-            goto yy368;
-          if (yych <= 0xC1)
-            goto yy356;
-          goto yy370;
-        }
-      } else {
-        if (yych <= 0xEF) {
-          if (yych <= 0xE0)
-            goto yy371;
-          if (yych == 0xED)
-            goto yy376;
-          goto yy372;
-        } else {
-          if (yych <= 0xF0)
-            goto yy373;
-          if (yych <= 0xF3)
-            goto yy374;
-          if (yych <= 0xF4)
-            goto yy375;
-          goto yy356;
-        }
-      }
-    }
-  yy404:
-    ++p;
-    yych = *p;
-  yy405:
-    if (yybm[0 + yych] & 8) {
-      goto yy404;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= '?')
-          goto yy413;
-        goto yy356;
-      } else {
-        if (yych <= 0xDF)
-          goto yy406;
-        if (yych <= 0xE0)
-          goto yy407;
-        goto yy408;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy412;
-        if (yych <= 0xEF)
-          goto yy408;
-        goto yy409;
-      } else {
-        if (yych <= 0xF3)
-          goto yy410;
-        if (yych <= 0xF4)
-          goto yy411;
-        goto yy356;
-      }
-    }
-  yy406:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy404;
-    goto yy356;
-  yy407:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy406;
-    goto yy356;
-  yy408:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy406;
-    goto yy356;
-  yy409:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy408;
-    goto yy356;
-  yy410:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy408;
-    goto yy356;
-  yy411:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy408;
-    goto yy356;
-  yy412:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy406;
-    goto yy356;
-  yy413:
-    ++p;
-    yych = *p;
-    if (yych <= 0xE0) {
-      if (yych <= '>') {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= '=')
-          goto yy404;
-        goto yy360;
-      } else {
-        if (yych <= 0x7F)
-          goto yy404;
-        if (yych <= 0xC1)
-          goto yy356;
-        if (yych >= 0xE0)
-          goto yy415;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy420;
-        goto yy416;
-      } else {
-        if (yych <= 0xF0)
-          goto yy417;
-        if (yych <= 0xF3)
-          goto yy418;
-        if (yych <= 0xF4)
-          goto yy419;
-        goto yy356;
-      }
-    }
-  yy414:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy404;
-    goto yy356;
-  yy415:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy414;
-    goto yy356;
-  yy416:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy414;
-    goto yy356;
-  yy417:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy416;
-    goto yy356;
-  yy418:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy416;
-    goto yy356;
-  yy419:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy416;
-    goto yy356;
-  yy420:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy414;
-    goto yy356;
-  yy421:
-    ++p;
-    yych = *p;
-    if (yych <= '/') {
-      if (yych <= 0x1F) {
-        if (yych <= 0x08)
-          goto yy356;
-        if (yych >= 0x0E)
-          goto yy356;
-      } else {
-        if (yych <= ' ')
-          goto yy423;
-        if (yych == '-')
-          goto yy421;
-        goto yy356;
-      }
-    } else {
-      if (yych <= '@') {
-        if (yych <= '9')
-          goto yy421;
-        if (yych == '>')
-          goto yy360;
-        goto yy356;
-      } else {
-        if (yych <= 'Z')
-          goto yy421;
-        if (yych <= '`')
-          goto yy356;
-        if (yych <= 'z')
-          goto yy421;
-        goto yy356;
-      }
-    }
-  yy423:
-    ++p;
-    yych = *p;
-    if (yych <= 0x1F) {
-      if (yych <= 0x08)
-        goto yy356;
-      if (yych <= '\r')
-        goto yy423;
-      goto yy356;
-    } else {
-      if (yych <= ' ')
-        goto yy423;
-      if (yych == '>')
-        goto yy360;
-      goto yy356;
-    }
-  yy425:
-    yych = *++p;
-    if (yych == 'C')
-      goto yy461;
-    if (yych == 'c')
-      goto yy461;
-    goto yy356;
-  yy426:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 16) {
-      goto yy426;
-    }
-    if (yych <= 0x08)
-      goto yy356;
-    if (yych <= '\r')
-      goto yy450;
-    if (yych == ' ')
-      goto yy450;
-    goto yy356;
-  yy428:
-    yych = *++p;
-    if (yych != '-')
-      goto yy356;
-    yych = *++p;
-    if (yych <= 0xE0) {
-      if (yych <= '=') {
-        if (yych != '-')
-          goto yy432;
-      } else {
-        if (yych <= '>')
-          goto yy356;
-        if (yych <= 0xC1)
-          goto yy432;
-        if (yych <= 0xDF)
-          goto yy433;
-        goto yy434;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy439;
-        goto yy435;
-      } else {
-        if (yych <= 0xF0)
-          goto yy436;
-        if (yych <= 0xF3)
-          goto yy437;
-        if (yych <= 0xF4)
-          goto yy438;
-        goto yy432;
-      }
-    }
-    yych = *++p;
-    if (yych <= 0xE0) {
-      if (yych <= '=') {
-        if (yych == '-')
-          goto yy449;
-        goto yy432;
-      } else {
-        if (yych <= '>')
-          goto yy356;
-        if (yych <= 0xC1)
-          goto yy432;
-        if (yych <= 0xDF)
-          goto yy433;
-        goto yy434;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy439;
-        goto yy435;
-      } else {
-        if (yych <= 0xF0)
-          goto yy436;
-        if (yych <= 0xF3)
-          goto yy437;
-        if (yych <= 0xF4)
-          goto yy438;
-        goto yy432;
-      }
-    }
-  yy431:
-    ++p;
-    yych = *p;
-  yy432:
-    if (yybm[0 + yych] & 32) {
-      goto yy431;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= '-')
-          goto yy440;
-        goto yy356;
-      } else {
-        if (yych <= 0xDF)
-          goto yy441;
-        if (yych <= 0xE0)
-          goto yy442;
-        goto yy443;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy447;
-        if (yych <= 0xEF)
-          goto yy443;
-        goto yy444;
-      } else {
-        if (yych <= 0xF3)
-          goto yy445;
-        if (yych <= 0xF4)
-          goto yy446;
-        goto yy356;
-      }
-    }
-  yy433:
-    yych = *++p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy431;
-    goto yy356;
-  yy434:
-    yych = *++p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy433;
-    goto yy356;
-  yy435:
-    yych = *++p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy433;
-    goto yy356;
-  yy436:
-    yych = *++p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy435;
-    goto yy356;
-  yy437:
-    yych = *++p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy435;
-    goto yy356;
-  yy438:
-    yych = *++p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy435;
-    goto yy356;
-  yy439:
-    yych = *++p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy433;
-    goto yy356;
-  yy440:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 32) {
-      goto yy431;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= '-')
-          goto yy448;
-        goto yy356;
-      } else {
-        if (yych <= 0xDF)
-          goto yy441;
-        if (yych <= 0xE0)
-          goto yy442;
-        goto yy443;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy447;
-        if (yych <= 0xEF)
-          goto yy443;
-        goto yy444;
-      } else {
-        if (yych <= 0xF3)
-          goto yy445;
-        if (yych <= 0xF4)
-          goto yy446;
-        goto yy356;
-      }
-    }
-  yy441:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy431;
-    goto yy356;
-  yy442:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy441;
-    goto yy356;
-  yy443:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy441;
-    goto yy356;
-  yy444:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy443;
-    goto yy356;
-  yy445:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy443;
-    goto yy356;
-  yy446:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy443;
-    goto yy356;
-  yy447:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy441;
-    goto yy356;
-  yy448:
-    yych = *++p;
-    if (yych == '>')
-      goto yy360;
-    goto yy356;
-  yy449:
-    yych = *++p;
-    if (yych == '>')
-      goto yy360;
-    goto yy356;
-  yy450:
-    ++p;
-    yych = *p;
-    if (yych <= 0xC1) {
-      if (yych <= 0x1F) {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= 0x08)
-          goto yy452;
-        if (yych <= '\r')
-          goto yy450;
-      } else {
-        if (yych <= '=') {
-          if (yych <= ' ')
-            goto yy450;
-        } else {
-          if (yych <= '>')
-            goto yy360;
-          if (yych >= 0x80)
-            goto yy356;
-        }
-      }
-    } else {
-      if (yych <= 0xED) {
-        if (yych <= 0xDF)
-          goto yy454;
-        if (yych <= 0xE0)
-          goto yy455;
-        if (yych <= 0xEC)
-          goto yy456;
-        goto yy460;
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xEF)
-            goto yy456;
-          goto yy457;
-        } else {
-          if (yych <= 0xF3)
-            goto yy458;
-          if (yych <= 0xF4)
-            goto yy459;
-          goto yy356;
-        }
-      }
-    }
-  yy452:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy452;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= '>')
-          goto yy360;
-        goto yy356;
-      } else {
-        if (yych <= 0xDF)
-          goto yy454;
-        if (yych <= 0xE0)
-          goto yy455;
-        goto yy456;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy460;
-        if (yych <= 0xEF)
-          goto yy456;
-        goto yy457;
-      } else {
-        if (yych <= 0xF3)
-          goto yy458;
-        if (yych <= 0xF4)
-          goto yy459;
-        goto yy356;
-      }
-    }
-  yy454:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy452;
-    goto yy356;
-  yy455:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy454;
-    goto yy356;
-  yy456:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy454;
-    goto yy356;
-  yy457:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy456;
-    goto yy356;
-  yy458:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy456;
-    goto yy356;
-  yy459:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy456;
-    goto yy356;
-  yy460:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy454;
-    goto yy356;
-  yy461:
-    yych = *++p;
-    if (yych == 'D')
-      goto yy462;
-    if (yych != 'd')
-      goto yy356;
-  yy462:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy463;
-    if (yych != 'a')
-      goto yy356;
-  yy463:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy464;
-    if (yych != 't')
-      goto yy356;
-  yy464:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy465;
-    if (yych != 'a')
-      goto yy356;
-  yy465:
-    yych = *++p;
-    if (yych != '[')
-      goto yy356;
-  yy466:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy466;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= ']')
-          goto yy475;
-        goto yy356;
-      } else {
-        if (yych <= 0xDF)
-          goto yy468;
-        if (yych <= 0xE0)
-          goto yy469;
-        goto yy470;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy474;
-        if (yych <= 0xEF)
-          goto yy470;
-        goto yy471;
-      } else {
-        if (yych <= 0xF3)
-          goto yy472;
-        if (yych <= 0xF4)
-          goto yy473;
-        goto yy356;
-      }
-    }
-  yy468:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy466;
-    goto yy356;
-  yy469:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy468;
-    goto yy356;
-  yy470:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy468;
-    goto yy356;
-  yy471:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy470;
-    goto yy356;
-  yy472:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy470;
-    goto yy356;
-  yy473:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy470;
-    goto yy356;
-  yy474:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy468;
-    goto yy356;
-  yy475:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy466;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych >= '^')
-          goto yy356;
-      } else {
-        if (yych <= 0xDF)
-          goto yy477;
-        if (yych <= 0xE0)
-          goto yy478;
-        goto yy479;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy483;
-        if (yych <= 0xEF)
-          goto yy479;
-        goto yy480;
-      } else {
-        if (yych <= 0xF3)
-          goto yy481;
-        if (yych <= 0xF4)
-          goto yy482;
-        goto yy356;
-      }
-    }
-    ++p;
-    yych = *p;
-    if (yych <= 0xE0) {
-      if (yych <= '>') {
-        if (yych <= 0x00)
-          goto yy356;
-        if (yych <= '=')
-          goto yy466;
-        goto yy360;
-      } else {
-        if (yych <= 0x7F)
-          goto yy466;
-        if (yych <= 0xC1)
-          goto yy356;
-        if (yych <= 0xDF)
-          goto yy484;
-        goto yy485;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy490;
-        goto yy486;
-      } else {
-        if (yych <= 0xF0)
-          goto yy487;
-        if (yych <= 0xF3)
-          goto yy488;
-        if (yych <= 0xF4)
-          goto yy489;
-        goto yy356;
-      }
-    }
-  yy477:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy466;
-    goto yy356;
-  yy478:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy477;
-    goto yy356;
-  yy479:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy477;
-    goto yy356;
-  yy480:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy479;
-    goto yy356;
-  yy481:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy479;
-    goto yy356;
-  yy482:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy479;
-    goto yy356;
-  yy483:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy477;
-    goto yy356;
-  yy484:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy466;
-    goto yy356;
-  yy485:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy484;
-    goto yy356;
-  yy486:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy484;
-    goto yy356;
-  yy487:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy486;
-    goto yy356;
-  yy488:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0xBF)
-      goto yy486;
-    goto yy356;
-  yy489:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x8F)
-      goto yy486;
-    goto yy356;
-  yy490:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy356;
-    if (yych <= 0x9F)
-      goto yy484;
-    goto yy356;
-  }
-}
-
-// Try to (liberally) match an HTML tag after first <, returning num of chars
-// matched.
-bufsize_t _scan_liberal_html_tag(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    unsigned int yyaccept = 0;
-    static const unsigned char yybm[] = {
-        0,  64, 64, 64, 64, 64, 64, 64, 64,  64, 0,  64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,
-    };
-    yych = *p;
-    if (yych <= 0xE0) {
-      if (yych <= '\n') {
-        if (yych <= 0x00)
-          goto yy493;
-        if (yych <= '\t')
-          goto yy495;
-      } else {
-        if (yych <= 0x7F)
-          goto yy495;
-        if (yych <= 0xC1)
-          goto yy493;
-        if (yych <= 0xDF)
-          goto yy496;
-        goto yy497;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy499;
-        goto yy498;
-      } else {
-        if (yych <= 0xF0)
-          goto yy500;
-        if (yych <= 0xF3)
-          goto yy501;
-        if (yych <= 0xF4)
-          goto yy502;
-      }
-    }
-  yy493:
-    ++p;
-  yy494 : { return 0; }
-  yy495:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= '\n') {
-      if (yych <= 0x00)
-        goto yy494;
-      if (yych <= '\t')
-        goto yy507;
-      goto yy494;
-    } else {
-      if (yych <= 0x7F)
-        goto yy507;
-      if (yych <= 0xC1)
-        goto yy494;
-      if (yych <= 0xF4)
-        goto yy507;
-      goto yy494;
-    }
-  yy496:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy494;
-    if (yych <= 0xBF)
-      goto yy506;
-    goto yy494;
-  yy497:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x9F)
-      goto yy494;
-    if (yych <= 0xBF)
-      goto yy505;
-    goto yy494;
-  yy498:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy494;
-    if (yych <= 0xBF)
-      goto yy505;
-    goto yy494;
-  yy499:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy494;
-    if (yych <= 0x9F)
-      goto yy505;
-    goto yy494;
-  yy500:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x8F)
-      goto yy494;
-    if (yych <= 0xBF)
-      goto yy503;
-    goto yy494;
-  yy501:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy494;
-    if (yych <= 0xBF)
-      goto yy503;
-    goto yy494;
-  yy502:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy494;
-    if (yych >= 0x90)
-      goto yy494;
-  yy503:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy504;
-    if (yych <= 0xBF)
-      goto yy505;
-  yy504:
-    p = marker;
-    if (yyaccept == 0) {
-      goto yy494;
-    } else {
-      goto yy510;
-    }
-  yy505:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy504;
-    if (yych >= 0xC0)
-      goto yy504;
-  yy506:
-    ++p;
-    yych = *p;
-  yy507:
-    if (yybm[0 + yych] & 64) {
-      goto yy506;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy504;
-        if (yych >= '?')
-          goto yy504;
-      } else {
-        if (yych <= 0xDF)
-          goto yy505;
-        if (yych <= 0xE0)
-          goto yy511;
-        goto yy503;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy515;
-        if (yych <= 0xEF)
-          goto yy503;
-        goto yy512;
-      } else {
-        if (yych <= 0xF3)
-          goto yy513;
-        if (yych <= 0xF4)
-          goto yy514;
-        goto yy504;
-      }
-    }
-  yy508:
-    yyaccept = 1;
-    marker = ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy506;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy510;
-        if (yych <= '>')
-          goto yy508;
-      } else {
-        if (yych <= 0xDF)
-          goto yy505;
-        if (yych <= 0xE0)
-          goto yy511;
-        goto yy503;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy515;
-        if (yych <= 0xEF)
-          goto yy503;
-        goto yy512;
-      } else {
-        if (yych <= 0xF3)
-          goto yy513;
-        if (yych <= 0xF4)
-          goto yy514;
-      }
-    }
-  yy510 : { return (bufsize_t)(p - start); }
-  yy511:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy504;
-    if (yych <= 0xBF)
-      goto yy505;
-    goto yy504;
-  yy512:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy504;
-    if (yych <= 0xBF)
-      goto yy503;
-    goto yy504;
-  yy513:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy504;
-    if (yych <= 0xBF)
-      goto yy503;
-    goto yy504;
-  yy514:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy504;
-    if (yych <= 0x8F)
-      goto yy503;
-    goto yy504;
-  yy515:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy504;
-    if (yych <= 0x9F)
-      goto yy505;
-    goto yy504;
-  }
-}
-
-// 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 yy520;
-    ++p;
-  yy519 : { return 0; }
-  yy520:
-    yych = *(marker = ++p);
-    switch (yych) {
-    case '!':
-      goto yy538;
-    case '/':
-      goto yy521;
-    case '?':
-      goto yy539;
-    case 'A':
-    case 'a':
-      goto yy524;
-    case 'B':
-    case 'b':
-      goto yy525;
-    case 'C':
-    case 'c':
-      goto yy526;
-    case 'D':
-    case 'd':
-      goto yy527;
-    case 'F':
-    case 'f':
-      goto yy528;
-    case 'H':
-    case 'h':
-      goto yy529;
-    case 'I':
-    case 'i':
-      goto yy530;
-    case 'L':
-    case 'l':
-      goto yy531;
-    case 'M':
-    case 'm':
-      goto yy532;
-    case 'N':
-    case 'n':
-      goto yy533;
-    case 'O':
-    case 'o':
-      goto yy534;
-    case 'P':
-    case 'p':
-      goto yy523;
-    case 'S':
-    case 's':
-      goto yy535;
-    case 'T':
-    case 't':
-      goto yy536;
-    case 'U':
-    case 'u':
-      goto yy537;
-    default:
-      goto yy519;
-    }
-  yy521:
-    yych = *++p;
-    switch (yych) {
-    case 'A':
-    case 'a':
-      goto yy524;
-    case 'B':
-    case 'b':
-      goto yy525;
-    case 'C':
-    case 'c':
-      goto yy526;
-    case 'D':
-    case 'd':
-      goto yy527;
-    case 'F':
-    case 'f':
-      goto yy528;
-    case 'H':
-    case 'h':
-      goto yy529;
-    case 'I':
-    case 'i':
-      goto yy530;
-    case 'L':
-    case 'l':
-      goto yy531;
-    case 'M':
-    case 'm':
-      goto yy532;
-    case 'N':
-    case 'n':
-      goto yy533;
-    case 'O':
-    case 'o':
-      goto yy534;
-    case 'P':
-    case 'p':
-      goto yy723;
-    case 'S':
-    case 's':
-      goto yy724;
-    case 'T':
-    case 't':
-      goto yy536;
-    case 'U':
-    case 'u':
-      goto yy537;
-    default:
-      goto yy522;
-    }
-  yy522:
-    p = marker;
-    goto yy519;
-  yy523:
-    yych = *++p;
-    if (yych <= '>') {
-      if (yych <= ' ') {
-        if (yych <= 0x08)
-          goto yy522;
-        if (yych <= '\r')
-          goto yy555;
-        if (yych <= 0x1F)
-          goto yy522;
-        goto yy555;
-      } else {
-        if (yych == '/')
-          goto yy557;
-        if (yych <= '=')
-          goto yy522;
-        goto yy555;
-      }
-    } else {
-      if (yych <= 'R') {
-        if (yych == 'A')
-          goto yy720;
-        if (yych <= 'Q')
-          goto yy522;
-        goto yy719;
-      } else {
-        if (yych <= 'a') {
-          if (yych <= '`')
-            goto yy522;
-          goto yy720;
-        } else {
-          if (yych == 'r')
-            goto yy719;
-          goto yy522;
-        }
-      }
-    }
-  yy524:
-    yych = *++p;
-    if (yych <= 'S') {
-      if (yych <= 'D') {
-        if (yych <= 'C')
-          goto yy522;
-        goto yy708;
-      } else {
-        if (yych <= 'Q')
-          goto yy522;
-        if (yych <= 'R')
-          goto yy707;
-        goto yy706;
-      }
-    } else {
-      if (yych <= 'q') {
-        if (yych == 'd')
-          goto yy708;
-        goto yy522;
-      } else {
-        if (yych <= 'r')
-          goto yy707;
-        if (yych <= 's')
-          goto yy706;
-        goto yy522;
-      }
-    }
-  yy525:
-    yych = *++p;
-    if (yych <= 'O') {
-      if (yych <= 'K') {
-        if (yych == 'A')
-          goto yy692;
-        goto yy522;
-      } else {
-        if (yych <= 'L')
-          goto yy691;
-        if (yych <= 'N')
-          goto yy522;
-        goto yy690;
-      }
-    } else {
-      if (yych <= 'k') {
-        if (yych == 'a')
-          goto yy692;
-        goto yy522;
-      } else {
-        if (yych <= 'l')
-          goto yy691;
-        if (yych == 'o')
-          goto yy690;
-        goto yy522;
-      }
-    }
-  yy526:
-    yych = *++p;
-    if (yych <= 'O') {
-      if (yych <= 'D') {
-        if (yych == 'A')
-          goto yy677;
-        goto yy522;
-      } else {
-        if (yych <= 'E')
-          goto yy676;
-        if (yych <= 'N')
-          goto yy522;
-        goto yy675;
-      }
-    } else {
-      if (yych <= 'd') {
-        if (yych == 'a')
-          goto yy677;
-        goto yy522;
-      } else {
-        if (yych <= 'e')
-          goto yy676;
-        if (yych == 'o')
-          goto yy675;
-        goto yy522;
-      }
-    }
-  yy527:
-    yych = *++p;
-    switch (yych) {
-    case 'D':
-    case 'L':
-    case 'T':
-    case 'd':
-    case 'l':
-    case 't':
-      goto yy554;
-    case 'E':
-    case 'e':
-      goto yy667;
-    case 'I':
-    case 'i':
-      goto yy666;
-    default:
-      goto yy522;
-    }
-  yy528:
-    yych = *++p;
-    if (yych <= 'R') {
-      if (yych <= 'N') {
-        if (yych == 'I')
-          goto yy642;
-        goto yy522;
-      } else {
-        if (yych <= 'O')
-          goto yy641;
-        if (yych <= 'Q')
-          goto yy522;
-        goto yy640;
-      }
-    } else {
-      if (yych <= 'n') {
-        if (yych == 'i')
-          goto yy642;
-        goto yy522;
-      } else {
-        if (yych <= 'o')
-          goto yy641;
-        if (yych == 'r')
-          goto yy640;
-        goto yy522;
-      }
-    }
-  yy529:
-    yych = *++p;
-    if (yych <= 'S') {
-      if (yych <= 'D') {
-        if (yych <= '0')
-          goto yy522;
-        if (yych <= '6')
-          goto yy554;
-        goto yy522;
-      } else {
-        if (yych <= 'E')
-          goto yy635;
-        if (yych == 'R')
-          goto yy554;
-        goto yy522;
-      }
-    } else {
-      if (yych <= 'q') {
-        if (yych <= 'T')
-          goto yy634;
-        if (yych == 'e')
-          goto yy635;
-        goto yy522;
-      } else {
-        if (yych <= 'r')
-          goto yy554;
-        if (yych == 't')
-          goto yy634;
-        goto yy522;
-      }
-    }
-  yy530:
-    yych = *++p;
-    if (yych == 'F')
-      goto yy630;
-    if (yych == 'f')
-      goto yy630;
-    goto yy522;
-  yy531:
-    yych = *++p;
-    if (yych <= 'I') {
-      if (yych == 'E')
-        goto yy625;
-      if (yych <= 'H')
-        goto yy522;
-      goto yy624;
-    } else {
-      if (yych <= 'e') {
-        if (yych <= 'd')
-          goto yy522;
-        goto yy625;
-      } else {
-        if (yych == 'i')
-          goto yy624;
-        goto yy522;
-      }
-    }
-  yy532:
-    yych = *++p;
-    if (yych <= 'E') {
-      if (yych == 'A')
-        goto yy616;
-      if (yych <= 'D')
-        goto yy522;
-      goto yy615;
-    } else {
-      if (yych <= 'a') {
-        if (yych <= '`')
-          goto yy522;
-        goto yy616;
-      } else {
-        if (yych == 'e')
-          goto yy615;
-        goto yy522;
-      }
-    }
-  yy533:
-    yych = *++p;
-    if (yych <= 'O') {
-      if (yych == 'A')
-        goto yy609;
-      if (yych <= 'N')
-        goto yy522;
-      goto yy608;
-    } else {
-      if (yych <= 'a') {
-        if (yych <= '`')
-          goto yy522;
-        goto yy609;
-      } else {
-        if (yych == 'o')
-          goto yy608;
-        goto yy522;
-      }
-    }
-  yy534:
-    yych = *++p;
-    if (yych <= 'P') {
-      if (yych == 'L')
-        goto yy554;
-      if (yych <= 'O')
-        goto yy522;
-      goto yy600;
-    } else {
-      if (yych <= 'l') {
-        if (yych <= 'k')
-          goto yy522;
-        goto yy554;
-      } else {
-        if (yych == 'p')
-          goto yy600;
-        goto yy522;
-      }
-    }
-  yy535:
-    yych = *++p;
-    switch (yych) {
-    case 'C':
-    case 'c':
-      goto yy577;
-    case 'E':
-    case 'e':
-      goto yy580;
-    case 'O':
-    case 'o':
-      goto yy579;
-    case 'T':
-    case 't':
-      goto yy576;
-    case 'U':
-    case 'u':
-      goto yy578;
-    default:
-      goto yy522;
-    }
-  yy536:
-    yych = *++p;
-    switch (yych) {
-    case 'A':
-    case 'a':
-      goto yy563;
-    case 'B':
-    case 'b':
-      goto yy562;
-    case 'D':
-    case 'd':
-      goto yy554;
-    case 'F':
-    case 'f':
-      goto yy561;
-    case 'H':
-    case 'h':
-      goto yy560;
-    case 'I':
-    case 'i':
-      goto yy559;
-    case 'R':
-    case 'r':
-      goto yy558;
-    default:
-      goto yy522;
-    }
-  yy537:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy554;
-    if (yych == 'l')
-      goto yy554;
-    goto yy522;
-  yy538:
-    yych = *++p;
-    if (yych <= '@') {
-      if (yych == '-')
-        goto yy541;
-      goto yy522;
-    } else {
-      if (yych <= 'Z')
-        goto yy542;
-      if (yych <= '[')
-        goto yy544;
-      goto yy522;
-    }
-  yy539:
-    ++p;
-    { return 3; }
-  yy541:
-    yych = *++p;
-    if (yych == '-')
-      goto yy552;
-    goto yy522;
-  yy542:
-    ++p;
-    { return 4; }
-  yy544:
-    yych = *++p;
-    if (yych == 'C')
-      goto yy545;
-    if (yych != 'c')
-      goto yy522;
-  yy545:
-    yych = *++p;
-    if (yych == 'D')
-      goto yy546;
-    if (yych != 'd')
-      goto yy522;
-  yy546:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy547;
-    if (yych != 'a')
-      goto yy522;
-  yy547:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy548;
-    if (yych != 't')
-      goto yy522;
-  yy548:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy549;
-    if (yych != 'a')
-      goto yy522;
-  yy549:
-    yych = *++p;
-    if (yych != '[')
-      goto yy522;
-    ++p;
-    { return 5; }
-  yy552:
-    ++p;
-    { return 2; }
-  yy554:
-    yych = *++p;
-    if (yych <= ' ') {
-      if (yych <= 0x08)
-        goto yy522;
-      if (yych <= '\r')
-        goto yy555;
-      if (yych <= 0x1F)
-        goto yy522;
-    } else {
-      if (yych <= '/') {
-        if (yych <= '.')
-          goto yy522;
-        goto yy557;
-      } else {
-        if (yych != '>')
-          goto yy522;
-      }
-    }
-  yy555:
-    ++p;
-    { return 6; }
-  yy557:
-    yych = *++p;
-    if (yych == '>')
-      goto yy555;
-    goto yy522;
-  yy558:
-    yych = *++p;
-    if (yych <= '/') {
-      if (yych <= 0x1F) {
-        if (yych <= 0x08)
-          goto yy522;
-        if (yych <= '\r')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= ' ')
-          goto yy555;
-        if (yych <= '.')
-          goto yy522;
-        goto yy557;
-      }
-    } else {
-      if (yych <= '@') {
-        if (yych == '>')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= 'A')
-          goto yy574;
-        if (yych == 'a')
-          goto yy574;
-        goto yy522;
-      }
-    }
-  yy559:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy572;
-    if (yych == 't')
-      goto yy572;
-    goto yy522;
-  yy560:
-    yych = *++p;
-    if (yych <= '/') {
-      if (yych <= 0x1F) {
-        if (yych <= 0x08)
-          goto yy522;
-        if (yych <= '\r')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= ' ')
-          goto yy555;
-        if (yych <= '.')
-          goto yy522;
-        goto yy557;
-      }
-    } else {
-      if (yych <= 'D') {
-        if (yych == '>')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= 'E')
-          goto yy570;
-        if (yych == 'e')
-          goto yy570;
-        goto yy522;
-      }
-    }
-  yy561:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy568;
-    if (yych == 'o')
-      goto yy568;
-    goto yy522;
-  yy562:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy566;
-    if (yych == 'o')
-      goto yy566;
-    goto yy522;
-  yy563:
-    yych = *++p;
-    if (yych == 'B')
-      goto yy564;
-    if (yych != 'b')
-      goto yy522;
-  yy564:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy565;
-    if (yych != 'l')
-      goto yy522;
-  yy565:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy554;
-    if (yych == 'e')
-      goto yy554;
-    goto yy522;
-  yy566:
-    yych = *++p;
-    if (yych == 'D')
-      goto yy567;
-    if (yych != 'd')
-      goto yy522;
-  yy567:
-    yych = *++p;
-    if (yych == 'Y')
-      goto yy554;
-    if (yych == 'y')
-      goto yy554;
-    goto yy522;
-  yy568:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy569;
-    if (yych != 'o')
-      goto yy522;
-  yy569:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy554;
-    if (yych == 't')
-      goto yy554;
-    goto yy522;
-  yy570:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy571;
-    if (yych != 'a')
-      goto yy522;
-  yy571:
-    yych = *++p;
-    if (yych == 'D')
-      goto yy554;
-    if (yych == 'd')
-      goto yy554;
-    goto yy522;
-  yy572:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy573;
-    if (yych != 'l')
-      goto yy522;
-  yy573:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy554;
-    if (yych == 'e')
-      goto yy554;
-    goto yy522;
-  yy574:
-    yych = *++p;
-    if (yych == 'C')
-      goto yy575;
-    if (yych != 'c')
-      goto yy522;
-  yy575:
-    yych = *++p;
-    if (yych == 'K')
-      goto yy554;
-    if (yych == 'k')
-      goto yy554;
-    goto yy522;
-  yy576:
-    yych = *++p;
-    if (yych == 'Y')
-      goto yy598;
-    if (yych == 'y')
-      goto yy598;
-    goto yy522;
-  yy577:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy592;
-    if (yych == 'r')
-      goto yy592;
-    goto yy522;
-  yy578:
-    yych = *++p;
-    if (yych == 'M')
-      goto yy588;
-    if (yych == 'm')
-      goto yy588;
-    goto yy522;
-  yy579:
-    yych = *++p;
-    if (yych == 'U')
-      goto yy585;
-    if (yych == 'u')
-      goto yy585;
-    goto yy522;
-  yy580:
-    yych = *++p;
-    if (yych == 'C')
-      goto yy581;
-    if (yych != 'c')
-      goto yy522;
-  yy581:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy582;
-    if (yych != 't')
-      goto yy522;
-  yy582:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy583;
-    if (yych != 'i')
-      goto yy522;
-  yy583:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy584;
-    if (yych != 'o')
-      goto yy522;
-  yy584:
-    yych = *++p;
-    if (yych == 'N')
-      goto yy554;
-    if (yych == 'n')
-      goto yy554;
-    goto yy522;
-  yy585:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy586;
-    if (yych != 'r')
-      goto yy522;
-  yy586:
-    yych = *++p;
-    if (yych == 'C')
-      goto yy587;
-    if (yych != 'c')
-      goto yy522;
-  yy587:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy554;
-    if (yych == 'e')
-      goto yy554;
-    goto yy522;
-  yy588:
-    yych = *++p;
-    if (yych == 'M')
-      goto yy589;
-    if (yych != 'm')
-      goto yy522;
-  yy589:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy590;
-    if (yych != 'a')
-      goto yy522;
-  yy590:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy591;
-    if (yych != 'r')
-      goto yy522;
-  yy591:
-    yych = *++p;
-    if (yych == 'Y')
-      goto yy554;
-    if (yych == 'y')
-      goto yy554;
-    goto yy522;
-  yy592:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy593;
-    if (yych != 'i')
-      goto yy522;
-  yy593:
-    yych = *++p;
-    if (yych == 'P')
-      goto yy594;
-    if (yych != 'p')
-      goto yy522;
-  yy594:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy595;
-    if (yych != 't')
-      goto yy522;
-  yy595:
-    yych = *++p;
-    if (yych <= 0x1F) {
-      if (yych <= 0x08)
-        goto yy522;
-      if (yych >= 0x0E)
-        goto yy522;
-    } else {
-      if (yych <= ' ')
-        goto yy596;
-      if (yych != '>')
-        goto yy522;
-    }
-  yy596:
-    ++p;
-    { return 1; }
-  yy598:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy599;
-    if (yych != 'l')
-      goto yy522;
-  yy599:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy595;
-    if (yych == 'e')
-      goto yy595;
-    goto yy522;
-  yy600:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy601;
-    if (yych != 't')
-      goto yy522;
-  yy601:
-    yych = *++p;
-    if (yych <= 'I') {
-      if (yych == 'G')
-        goto yy603;
-      if (yych <= 'H')
-        goto yy522;
-    } else {
-      if (yych <= 'g') {
-        if (yych <= 'f')
-          goto yy522;
-        goto yy603;
-      } else {
-        if (yych != 'i')
-          goto yy522;
-      }
-    }
-    yych = *++p;
-    if (yych == 'O')
-      goto yy607;
-    if (yych == 'o')
-      goto yy607;
-    goto yy522;
-  yy603:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy604;
-    if (yych != 'r')
-      goto yy522;
-  yy604:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy605;
-    if (yych != 'o')
-      goto yy522;
-  yy605:
-    yych = *++p;
-    if (yych == 'U')
-      goto yy606;
-    if (yych != 'u')
-      goto yy522;
-  yy606:
-    yych = *++p;
-    if (yych == 'P')
-      goto yy554;
-    if (yych == 'p')
-      goto yy554;
-    goto yy522;
-  yy607:
-    yych = *++p;
-    if (yych == 'N')
-      goto yy554;
-    if (yych == 'n')
-      goto yy554;
-    goto yy522;
-  yy608:
-    yych = *++p;
-    if (yych == 'F')
-      goto yy610;
-    if (yych == 'f')
-      goto yy610;
-    goto yy522;
-  yy609:
-    yych = *++p;
-    if (yych == 'V')
-      goto yy554;
-    if (yych == 'v')
-      goto yy554;
-    goto yy522;
-  yy610:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy611;
-    if (yych != 'r')
-      goto yy522;
-  yy611:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy612;
-    if (yych != 'a')
-      goto yy522;
-  yy612:
-    yych = *++p;
-    if (yych == 'M')
-      goto yy613;
-    if (yych != 'm')
-      goto yy522;
-  yy613:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy614;
-    if (yych != 'e')
-      goto yy522;
-  yy614:
-    yych = *++p;
-    if (yych == 'S')
-      goto yy554;
-    if (yych == 's')
-      goto yy554;
-    goto yy522;
-  yy615:
-    yych = *++p;
-    if (yych <= 'T') {
-      if (yych == 'N')
-        goto yy618;
-      if (yych <= 'S')
-        goto yy522;
-      goto yy619;
-    } else {
-      if (yych <= 'n') {
-        if (yych <= 'm')
-          goto yy522;
-        goto yy618;
-      } else {
-        if (yych == 't')
-          goto yy619;
-        goto yy522;
-      }
-    }
-  yy616:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy617;
-    if (yych != 'i')
-      goto yy522;
-  yy617:
-    yych = *++p;
-    if (yych == 'N')
-      goto yy554;
-    if (yych == 'n')
-      goto yy554;
-    goto yy522;
-  yy618:
-    yych = *++p;
-    if (yych == 'U')
-      goto yy620;
-    if (yych == 'u')
-      goto yy620;
-    goto yy522;
-  yy619:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy554;
-    if (yych == 'a')
-      goto yy554;
-    goto yy522;
-  yy620:
-    yych = *++p;
-    if (yych <= '/') {
-      if (yych <= 0x1F) {
-        if (yych <= 0x08)
-          goto yy522;
-        if (yych <= '\r')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= ' ')
-          goto yy555;
-        if (yych <= '.')
-          goto yy522;
-        goto yy557;
-      }
-    } else {
-      if (yych <= 'H') {
-        if (yych == '>')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= 'I')
-          goto yy621;
-        if (yych != 'i')
-          goto yy522;
-      }
-    }
-  yy621:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy622;
-    if (yych != 't')
-      goto yy522;
-  yy622:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy623;
-    if (yych != 'e')
-      goto yy522;
-  yy623:
-    yych = *++p;
-    if (yych == 'M')
-      goto yy554;
-    if (yych == 'm')
-      goto yy554;
-    goto yy522;
-  yy624:
-    yych = *++p;
-    if (yych <= '/') {
-      if (yych <= 0x1F) {
-        if (yych <= 0x08)
-          goto yy522;
-        if (yych <= '\r')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= ' ')
-          goto yy555;
-        if (yych <= '.')
-          goto yy522;
-        goto yy557;
-      }
-    } else {
-      if (yych <= 'M') {
-        if (yych == '>')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= 'N')
-          goto yy629;
-        if (yych == 'n')
-          goto yy629;
-        goto yy522;
-      }
-    }
-  yy625:
-    yych = *++p;
-    if (yych == 'G')
-      goto yy626;
-    if (yych != 'g')
-      goto yy522;
-  yy626:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy627;
-    if (yych != 'e')
-      goto yy522;
-  yy627:
-    yych = *++p;
-    if (yych == 'N')
-      goto yy628;
-    if (yych != 'n')
-      goto yy522;
-  yy628:
-    yych = *++p;
-    if (yych == 'D')
-      goto yy554;
-    if (yych == 'd')
-      goto yy554;
-    goto yy522;
-  yy629:
-    yych = *++p;
-    if (yych == 'K')
-      goto yy554;
-    if (yych == 'k')
-      goto yy554;
-    goto yy522;
-  yy630:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy631;
-    if (yych != 'r')
-      goto yy522;
-  yy631:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy632;
-    if (yych != 'a')
-      goto yy522;
-  yy632:
-    yych = *++p;
-    if (yych == 'M')
-      goto yy633;
-    if (yych != 'm')
-      goto yy522;
-  yy633:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy554;
-    if (yych == 'e')
-      goto yy554;
-    goto yy522;
-  yy634:
-    yych = *++p;
-    if (yych == 'M')
-      goto yy639;
-    if (yych == 'm')
-      goto yy639;
-    goto yy522;
-  yy635:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy636;
-    if (yych != 'a')
-      goto yy522;
-  yy636:
-    yych = *++p;
-    if (yych == 'D')
-      goto yy637;
-    if (yych != 'd')
-      goto yy522;
-  yy637:
-    yych = *++p;
-    if (yych <= '/') {
-      if (yych <= 0x1F) {
-        if (yych <= 0x08)
-          goto yy522;
-        if (yych <= '\r')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= ' ')
-          goto yy555;
-        if (yych <= '.')
-          goto yy522;
-        goto yy557;
-      }
-    } else {
-      if (yych <= 'D') {
-        if (yych == '>')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= 'E')
-          goto yy638;
-        if (yych != 'e')
-          goto yy522;
-      }
-    }
-  yy638:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy554;
-    if (yych == 'r')
-      goto yy554;
-    goto yy522;
-  yy639:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy554;
-    if (yych == 'l')
-      goto yy554;
-    goto yy522;
-  yy640:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy661;
-    if (yych == 'a')
-      goto yy661;
-    goto yy522;
-  yy641:
-    yych = *++p;
-    if (yych <= 'R') {
-      if (yych == 'O')
-        goto yy657;
-      if (yych <= 'Q')
-        goto yy522;
-      goto yy658;
-    } else {
-      if (yych <= 'o') {
-        if (yych <= 'n')
-          goto yy522;
-        goto yy657;
-      } else {
-        if (yych == 'r')
-          goto yy658;
-        goto yy522;
-      }
-    }
-  yy642:
-    yych = *++p;
-    if (yych <= 'G') {
-      if (yych == 'E')
-        goto yy643;
-      if (yych <= 'F')
-        goto yy522;
-      goto yy644;
-    } else {
-      if (yych <= 'e') {
-        if (yych <= 'd')
-          goto yy522;
-      } else {
-        if (yych == 'g')
-          goto yy644;
-        goto yy522;
-      }
-    }
-  yy643:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy653;
-    if (yych == 'l')
-      goto yy653;
-    goto yy522;
-  yy644:
-    yych = *++p;
-    if (yych <= 'U') {
-      if (yych == 'C')
-        goto yy646;
-      if (yych <= 'T')
-        goto yy522;
-    } else {
-      if (yych <= 'c') {
-        if (yych <= 'b')
-          goto yy522;
-        goto yy646;
-      } else {
-        if (yych != 'u')
-          goto yy522;
-      }
-    }
-    yych = *++p;
-    if (yych == 'R')
-      goto yy652;
-    if (yych == 'r')
-      goto yy652;
-    goto yy522;
-  yy646:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy647;
-    if (yych != 'a')
-      goto yy522;
-  yy647:
-    yych = *++p;
-    if (yych == 'P')
-      goto yy648;
-    if (yych != 'p')
-      goto yy522;
-  yy648:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy649;
-    if (yych != 't')
-      goto yy522;
-  yy649:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy650;
-    if (yych != 'i')
-      goto yy522;
-  yy650:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy651;
-    if (yych != 'o')
-      goto yy522;
-  yy651:
-    yych = *++p;
-    if (yych == 'N')
-      goto yy554;
-    if (yych == 'n')
-      goto yy554;
-    goto yy522;
-  yy652:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy554;
-    if (yych == 'e')
-      goto yy554;
-    goto yy522;
-  yy653:
-    yych = *++p;
-    if (yych == 'D')
-      goto yy654;
-    if (yych != 'd')
-      goto yy522;
-  yy654:
-    yych = *++p;
-    if (yych == 'S')
-      goto yy655;
-    if (yych != 's')
-      goto yy522;
-  yy655:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy656;
-    if (yych != 'e')
-      goto yy522;
-  yy656:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy554;
-    if (yych == 't')
-      goto yy554;
-    goto yy522;
-  yy657:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy659;
-    if (yych == 't')
-      goto yy659;
-    goto yy522;
-  yy658:
-    yych = *++p;
-    if (yych == 'M')
-      goto yy554;
-    if (yych == 'm')
-      goto yy554;
-    goto yy522;
-  yy659:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy660;
-    if (yych != 'e')
-      goto yy522;
-  yy660:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy554;
-    if (yych == 'r')
-      goto yy554;
-    goto yy522;
-  yy661:
-    yych = *++p;
-    if (yych == 'M')
-      goto yy662;
-    if (yych != 'm')
-      goto yy522;
-  yy662:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy663;
-    if (yych != 'e')
-      goto yy522;
-  yy663:
-    yych = *++p;
-    if (yych <= '/') {
-      if (yych <= 0x1F) {
-        if (yych <= 0x08)
-          goto yy522;
-        if (yych <= '\r')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= ' ')
-          goto yy555;
-        if (yych <= '.')
-          goto yy522;
-        goto yy557;
-      }
-    } else {
-      if (yych <= 'R') {
-        if (yych == '>')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= 'S')
-          goto yy664;
-        if (yych != 's')
-          goto yy522;
-      }
-    }
-  yy664:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy665;
-    if (yych != 'e')
-      goto yy522;
-  yy665:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy554;
-    if (yych == 't')
-      goto yy554;
-    goto yy522;
-  yy666:
-    yych = *++p;
-    if (yych <= 'V') {
-      if (yych <= 'Q') {
-        if (yych == 'A')
-          goto yy672;
-        goto yy522;
-      } else {
-        if (yych <= 'R')
-          goto yy554;
-        if (yych <= 'U')
-          goto yy522;
-        goto yy554;
-      }
-    } else {
-      if (yych <= 'q') {
-        if (yych == 'a')
-          goto yy672;
-        goto yy522;
-      } else {
-        if (yych <= 'r')
-          goto yy554;
-        if (yych == 'v')
-          goto yy554;
-        goto yy522;
-      }
-    }
-  yy667:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy668;
-    if (yych != 't')
-      goto yy522;
-  yy668:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy669;
-    if (yych != 'a')
-      goto yy522;
-  yy669:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy670;
-    if (yych != 'i')
-      goto yy522;
-  yy670:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy671;
-    if (yych != 'l')
-      goto yy522;
-  yy671:
-    yych = *++p;
-    if (yych == 'S')
-      goto yy554;
-    if (yych == 's')
-      goto yy554;
-    goto yy522;
-  yy672:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy673;
-    if (yych != 'l')
-      goto yy522;
-  yy673:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy674;
-    if (yych != 'o')
-      goto yy522;
-  yy674:
-    yych = *++p;
-    if (yych == 'G')
-      goto yy554;
-    if (yych == 'g')
-      goto yy554;
-    goto yy522;
-  yy675:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy685;
-    if (yych == 'l')
-      goto yy685;
-    goto yy522;
-  yy676:
-    yych = *++p;
-    if (yych == 'N')
-      goto yy682;
-    if (yych == 'n')
-      goto yy682;
-    goto yy522;
-  yy677:
-    yych = *++p;
-    if (yych == 'P')
-      goto yy678;
-    if (yych != 'p')
-      goto yy522;
-  yy678:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy679;
-    if (yych != 't')
-      goto yy522;
-  yy679:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy680;
-    if (yych != 'i')
-      goto yy522;
-  yy680:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy681;
-    if (yych != 'o')
-      goto yy522;
-  yy681:
-    yych = *++p;
-    if (yych == 'N')
-      goto yy554;
-    if (yych == 'n')
-      goto yy554;
-    goto yy522;
-  yy682:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy683;
-    if (yych != 't')
-      goto yy522;
-  yy683:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy684;
-    if (yych != 'e')
-      goto yy522;
-  yy684:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy554;
-    if (yych == 'r')
-      goto yy554;
-    goto yy522;
-  yy685:
-    yych = *++p;
-    if (yych <= '/') {
-      if (yych <= 0x1F) {
-        if (yych <= 0x08)
-          goto yy522;
-        if (yych <= '\r')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= ' ')
-          goto yy555;
-        if (yych <= '.')
-          goto yy522;
-        goto yy557;
-      }
-    } else {
-      if (yych <= 'F') {
-        if (yych == '>')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= 'G')
-          goto yy686;
-        if (yych != 'g')
-          goto yy522;
-      }
-    }
-  yy686:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy687;
-    if (yych != 'r')
-      goto yy522;
-  yy687:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy688;
-    if (yych != 'o')
-      goto yy522;
-  yy688:
-    yych = *++p;
-    if (yych == 'U')
-      goto yy689;
-    if (yych != 'u')
-      goto yy522;
-  yy689:
-    yych = *++p;
-    if (yych == 'P')
-      goto yy554;
-    if (yych == 'p')
-      goto yy554;
-    goto yy522;
-  yy690:
-    yych = *++p;
-    if (yych == 'D')
-      goto yy705;
-    if (yych == 'd')
-      goto yy705;
-    goto yy522;
-  yy691:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy698;
-    if (yych == 'o')
-      goto yy698;
-    goto yy522;
-  yy692:
-    yych = *++p;
-    if (yych == 'S')
-      goto yy693;
-    if (yych != 's')
-      goto yy522;
-  yy693:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy694;
-    if (yych != 'e')
-      goto yy522;
-  yy694:
-    yych = *++p;
-    if (yych <= '/') {
-      if (yych <= 0x1F) {
-        if (yych <= 0x08)
-          goto yy522;
-        if (yych <= '\r')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= ' ')
-          goto yy555;
-        if (yych <= '.')
-          goto yy522;
-        goto yy557;
-      }
-    } else {
-      if (yych <= 'E') {
-        if (yych == '>')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= 'F')
-          goto yy695;
-        if (yych != 'f')
-          goto yy522;
-      }
-    }
-  yy695:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy696;
-    if (yych != 'o')
-      goto yy522;
-  yy696:
-    yych = *++p;
-    if (yych == 'N')
-      goto yy697;
-    if (yych != 'n')
-      goto yy522;
-  yy697:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy554;
-    if (yych == 't')
-      goto yy554;
-    goto yy522;
-  yy698:
-    yych = *++p;
-    if (yych == 'C')
-      goto yy699;
-    if (yych != 'c')
-      goto yy522;
-  yy699:
-    yych = *++p;
-    if (yych == 'K')
-      goto yy700;
-    if (yych != 'k')
-      goto yy522;
-  yy700:
-    yych = *++p;
-    if (yych == 'Q')
-      goto yy701;
-    if (yych != 'q')
-      goto yy522;
-  yy701:
-    yych = *++p;
-    if (yych == 'U')
-      goto yy702;
-    if (yych != 'u')
-      goto yy522;
-  yy702:
-    yych = *++p;
-    if (yych == 'O')
-      goto yy703;
-    if (yych != 'o')
-      goto yy522;
-  yy703:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy704;
-    if (yych != 't')
-      goto yy522;
-  yy704:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy554;
-    if (yych == 'e')
-      goto yy554;
-    goto yy522;
-  yy705:
-    yych = *++p;
-    if (yych == 'Y')
-      goto yy554;
-    if (yych == 'y')
-      goto yy554;
-    goto yy522;
-  yy706:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy717;
-    if (yych == 'i')
-      goto yy717;
-    goto yy522;
-  yy707:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy713;
-    if (yych == 't')
-      goto yy713;
-    goto yy522;
-  yy708:
-    yych = *++p;
-    if (yych == 'D')
-      goto yy709;
-    if (yych != 'd')
-      goto yy522;
-  yy709:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy710;
-    if (yych != 'r')
-      goto yy522;
-  yy710:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy711;
-    if (yych != 'e')
-      goto yy522;
-  yy711:
-    yych = *++p;
-    if (yych == 'S')
-      goto yy712;
-    if (yych != 's')
-      goto yy522;
-  yy712:
-    yych = *++p;
-    if (yych == 'S')
-      goto yy554;
-    if (yych == 's')
-      goto yy554;
-    goto yy522;
-  yy713:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy714;
-    if (yych != 'i')
-      goto yy522;
-  yy714:
-    yych = *++p;
-    if (yych == 'C')
-      goto yy715;
-    if (yych != 'c')
-      goto yy522;
-  yy715:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy716;
-    if (yych != 'l')
-      goto yy522;
-  yy716:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy554;
-    if (yych == 'e')
-      goto yy554;
-    goto yy522;
-  yy717:
-    yych = *++p;
-    if (yych == 'D')
-      goto yy718;
-    if (yych != 'd')
-      goto yy522;
-  yy718:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy554;
-    if (yych == 'e')
-      goto yy554;
-    goto yy522;
-  yy719:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy595;
-    if (yych == 'e')
-      goto yy595;
-    goto yy522;
-  yy720:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy721;
-    if (yych != 'r')
-      goto yy522;
-  yy721:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy722;
-    if (yych != 'a')
-      goto yy522;
-  yy722:
-    yych = *++p;
-    if (yych == 'M')
-      goto yy554;
-    if (yych == 'm')
-      goto yy554;
-    goto yy522;
-  yy723:
-    yych = *++p;
-    if (yych <= '/') {
-      if (yych <= 0x1F) {
-        if (yych <= 0x08)
-          goto yy522;
-        if (yych <= '\r')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= ' ')
-          goto yy555;
-        if (yych <= '.')
-          goto yy522;
-        goto yy557;
-      }
-    } else {
-      if (yych <= '@') {
-        if (yych == '>')
-          goto yy555;
-        goto yy522;
-      } else {
-        if (yych <= 'A')
-          goto yy720;
-        if (yych == 'a')
-          goto yy720;
-        goto yy522;
-      }
-    }
-  yy724:
-    ++p;
-    if ((yych = *p) <= 'U') {
-      if (yych <= 'N') {
-        if (yych == 'E')
-          goto yy580;
-        goto yy522;
-      } else {
-        if (yych <= 'O')
-          goto yy579;
-        if (yych <= 'T')
-          goto yy522;
-        goto yy578;
-      }
-    } else {
-      if (yych <= 'n') {
-        if (yych == 'e')
-          goto yy580;
-        goto yy522;
-      } else {
-        if (yych <= 'o')
-          goto yy579;
-        if (yych == 'u')
-          goto yy578;
-        goto yy522;
-      }
-    }
-  }
-}
-
-// Try to match an HTML block tag start line of type 7, returning
-// 7 if successful, 0 if not.
-bufsize_t _scan_html_block_start_7(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-
-  {
-    unsigned char yych;
-    unsigned int yyaccept = 0;
-    static const unsigned char yybm[] = {
-        0,   224, 224, 224, 224, 224, 224, 224, 224, 198, 202, 194, 198, 194,
-        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
-        224, 224, 224, 224, 198, 224, 64,  224, 224, 224, 224, 128, 224, 224,
-        224, 224, 224, 241, 240, 224, 241, 241, 241, 241, 241, 241, 241, 241,
-        241, 241, 240, 224, 192, 192, 192, 224, 224, 241, 241, 241, 241, 241,
-        241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241,
-        241, 241, 241, 241, 241, 241, 241, 224, 224, 224, 224, 240, 192, 241,
-        241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241,
-        241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 224, 224, 224,
-        224, 224, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,
-    };
-    yych = *p;
-    if (yych == '<')
-      goto yy729;
-    ++p;
-  yy728 : { return 0; }
-  yy729:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= '@') {
-      if (yych == '/')
-        goto yy733;
-      goto yy728;
-    } else {
-      if (yych <= 'Z')
-        goto yy730;
-      if (yych <= '`')
-        goto yy728;
-      if (yych >= '{')
-        goto yy728;
-    }
-  yy730:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 1) {
-      goto yy730;
-    }
-    if (yych <= ' ') {
-      if (yych <= 0x08)
-        goto yy732;
-      if (yych <= '\r')
-        goto yy744;
-      if (yych >= ' ')
-        goto yy744;
-    } else {
-      if (yych <= '/') {
-        if (yych >= '/')
-          goto yy746;
-      } else {
-        if (yych == '>')
-          goto yy738;
-      }
-    }
-  yy732:
-    p = marker;
-    if (yyaccept == 0) {
-      goto yy728;
-    } else {
-      goto yy742;
-    }
-  yy733:
-    yych = *++p;
-    if (yych <= '@')
-      goto yy732;
-    if (yych <= 'Z')
-      goto yy734;
-    if (yych <= '`')
-      goto yy732;
-    if (yych >= '{')
-      goto yy732;
-  yy734:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 2) {
-      goto yy736;
-    }
-    if (yych <= '=') {
-      if (yych <= '-') {
-        if (yych <= ',')
-          goto yy732;
-        goto yy734;
-      } else {
-        if (yych <= '/')
-          goto yy732;
-        if (yych <= '9')
-          goto yy734;
-        goto yy732;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '>')
-          goto yy738;
-        if (yych <= '@')
-          goto yy732;
-        goto yy734;
-      } else {
-        if (yych <= '`')
-          goto yy732;
-        if (yych <= 'z')
-          goto yy734;
-        goto yy732;
-      }
-    }
-  yy736:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 2) {
-      goto yy736;
-    }
-    if (yych != '>')
-      goto yy732;
-  yy738:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 4) {
-      goto yy738;
-    }
-    if (yych <= 0x08)
-      goto yy732;
-    if (yych <= '\n')
-      goto yy740;
-    if (yych <= '\v')
-      goto yy732;
-    if (yych <= '\r')
-      goto yy743;
-    goto yy732;
-  yy740:
-    yyaccept = 1;
-    marker = ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 4) {
-      goto yy738;
-    }
-    if (yych <= 0x08)
-      goto yy742;
-    if (yych <= '\n')
-      goto yy740;
-    if (yych <= '\v')
-      goto yy742;
-    if (yych <= '\r')
-      goto yy743;
-  yy742 : { return 7; }
-  yy743:
-    yych = *++p;
-    goto yy742;
-  yy744:
-    ++p;
-    yych = *p;
-    if (yych <= ':') {
-      if (yych <= ' ') {
-        if (yych <= 0x08)
-          goto yy732;
-        if (yych <= '\r')
-          goto yy744;
-        if (yych <= 0x1F)
-          goto yy732;
-        goto yy744;
-      } else {
-        if (yych == '/')
-          goto yy746;
-        if (yych <= '9')
-          goto yy732;
-        goto yy747;
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych == '>')
-          goto yy738;
-        if (yych <= '@')
-          goto yy732;
-        goto yy747;
-      } else {
-        if (yych <= '_') {
-          if (yych <= '^')
-            goto yy732;
-          goto yy747;
-        } else {
-          if (yych <= '`')
-            goto yy732;
-          if (yych <= 'z')
-            goto yy747;
-          goto yy732;
-        }
-      }
-    }
-  yy746:
-    yych = *++p;
-    if (yych == '>')
-      goto yy738;
-    goto yy732;
-  yy747:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 16) {
-      goto yy747;
-    }
-    if (yych <= ',') {
-      if (yych <= '\r') {
-        if (yych <= 0x08)
-          goto yy732;
-      } else {
-        if (yych != ' ')
-          goto yy732;
-      }
-    } else {
-      if (yych <= '<') {
-        if (yych <= '/')
-          goto yy746;
-        goto yy732;
-      } else {
-        if (yych <= '=')
-          goto yy751;
-        if (yych <= '>')
-          goto yy738;
-        goto yy732;
-      }
-    }
-  yy749:
-    ++p;
-    yych = *p;
-    if (yych <= '<') {
-      if (yych <= ' ') {
-        if (yych <= 0x08)
-          goto yy732;
-        if (yych <= '\r')
-          goto yy749;
-        if (yych <= 0x1F)
-          goto yy732;
-        goto yy749;
-      } else {
-        if (yych <= '/') {
-          if (yych <= '.')
-            goto yy732;
-          goto yy746;
-        } else {
-          if (yych == ':')
-            goto yy747;
-          goto yy732;
-        }
-      }
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '=')
-          goto yy751;
-        if (yych <= '>')
-          goto yy738;
-        if (yych <= '@')
-          goto yy732;
-        goto yy747;
-      } else {
-        if (yych <= '_') {
-          if (yych <= '^')
-            goto yy732;
-          goto yy747;
-        } else {
-          if (yych <= '`')
-            goto yy732;
-          if (yych <= 'z')
-            goto yy747;
-          goto yy732;
-        }
-      }
-    }
-  yy751:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 32) {
-      goto yy753;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '"') {
-        if (yych <= 0x00)
-          goto yy732;
-        if (yych >= '!')
-          goto yy764;
-      } else {
-        if (yych <= '\'')
-          goto yy762;
-        if (yych <= 0xC1)
-          goto yy732;
-        if (yych <= 0xDF)
-          goto yy755;
-        goto yy756;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy761;
-        goto yy757;
-      } else {
-        if (yych <= 0xF0)
-          goto yy758;
-        if (yych <= 0xF3)
-          goto yy759;
-        if (yych <= 0xF4)
-          goto yy760;
-        goto yy732;
-      }
-    }
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 32) {
-      goto yy753;
-    }
-    if (yych <= 0xDF) {
-      if (yych <= '\'') {
-        if (yych <= 0x00)
-          goto yy732;
-        if (yych <= ' ')
-          goto yy787;
-        if (yych <= '"')
-          goto yy764;
-        goto yy762;
-      } else {
-        if (yych == '>')
-          goto yy738;
-        if (yych <= 0xC1)
-          goto yy732;
-        goto yy755;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy756;
-        if (yych == 0xED)
-          goto yy761;
-        goto yy757;
-      } else {
-        if (yych <= 0xF0)
-          goto yy758;
-        if (yych <= 0xF3)
-          goto yy759;
-        if (yych <= 0xF4)
-          goto yy760;
-        goto yy732;
-      }
-    }
-  yy753:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 32) {
-      goto yy753;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '=') {
-        if (yych <= 0x00)
-          goto yy732;
-        if (yych <= ' ')
-          goto yy781;
-        goto yy732;
-      } else {
-        if (yych <= '>')
-          goto yy738;
-        if (yych <= 0xC1)
-          goto yy732;
-        if (yych >= 0xE0)
-          goto yy756;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy761;
-        goto yy757;
-      } else {
-        if (yych <= 0xF0)
-          goto yy758;
-        if (yych <= 0xF3)
-          goto yy759;
-        if (yych <= 0xF4)
-          goto yy760;
-        goto yy732;
-      }
-    }
-  yy755:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy753;
-    goto yy732;
-  yy756:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy755;
-    goto yy732;
-  yy757:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy755;
-    goto yy732;
-  yy758:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy757;
-    goto yy732;
-  yy759:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy757;
-    goto yy732;
-  yy760:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0x8F)
-      goto yy757;
-    goto yy732;
-  yy761:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0x9F)
-      goto yy755;
-    goto yy732;
-  yy762:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy762;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy732;
-        if (yych <= '\'')
-          goto yy773;
-        goto yy732;
-      } else {
-        if (yych <= 0xDF)
-          goto yy774;
-        if (yych <= 0xE0)
-          goto yy775;
-        goto yy776;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy780;
-        if (yych <= 0xEF)
-          goto yy776;
-        goto yy777;
-      } else {
-        if (yych <= 0xF3)
-          goto yy778;
-        if (yych <= 0xF4)
-          goto yy779;
-        goto yy732;
-      }
-    }
-  yy764:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy764;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy732;
-        if (yych <= '"')
-          goto yy773;
-        goto yy732;
-      } else {
-        if (yych <= 0xDF)
-          goto yy766;
-        if (yych <= 0xE0)
-          goto yy767;
-        goto yy768;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy772;
-        if (yych <= 0xEF)
-          goto yy768;
-        goto yy769;
-      } else {
-        if (yych <= 0xF3)
-          goto yy770;
-        if (yych <= 0xF4)
-          goto yy771;
-        goto yy732;
-      }
-    }
-  yy766:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy764;
-    goto yy732;
-  yy767:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy766;
-    goto yy732;
-  yy768:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy766;
-    goto yy732;
-  yy769:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy768;
-    goto yy732;
-  yy770:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy768;
-    goto yy732;
-  yy771:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0x8F)
-      goto yy768;
-    goto yy732;
-  yy772:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0x9F)
-      goto yy766;
-    goto yy732;
-  yy773:
-    ++p;
-    yych = *p;
-    if (yych <= ' ') {
-      if (yych <= 0x08)
-        goto yy732;
-      if (yych <= '\r')
-        goto yy744;
-      if (yych <= 0x1F)
-        goto yy732;
-      goto yy744;
-    } else {
-      if (yych <= '/') {
-        if (yych <= '.')
-          goto yy732;
-        goto yy746;
-      } else {
-        if (yych == '>')
-          goto yy738;
-        goto yy732;
-      }
-    }
-  yy774:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy762;
-    goto yy732;
-  yy775:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy774;
-    goto yy732;
-  yy776:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy774;
-    goto yy732;
-  yy777:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy776;
-    goto yy732;
-  yy778:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0xBF)
-      goto yy776;
-    goto yy732;
-  yy779:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0x8F)
-      goto yy776;
-    goto yy732;
-  yy780:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy732;
-    if (yych <= 0x9F)
-      goto yy774;
-    goto yy732;
-  yy781:
-    ++p;
-    yych = *p;
-    if (yych <= '@') {
-      if (yych <= '"') {
-        if (yych <= '\r') {
-          if (yych <= 0x00)
-            goto yy732;
-          if (yych <= 0x08)
-            goto yy753;
-          goto yy781;
-        } else {
-          if (yych == ' ')
-            goto yy781;
-          if (yych <= '!')
-            goto yy753;
-          goto yy732;
-        }
-      } else {
-        if (yych <= ':') {
-          if (yych == '\'')
-            goto yy732;
-          if (yych <= '9')
-            goto yy753;
-        } else {
-          if (yych <= ';')
-            goto yy753;
-          if (yych <= '=')
-            goto yy732;
-          if (yych <= '>')
-            goto yy738;
-          goto yy753;
-        }
-      }
-    } else {
-      if (yych <= 0xDF) {
-        if (yych <= '`') {
-          if (yych <= 'Z')
-            goto yy783;
-          if (yych <= '^')
-            goto yy753;
-          if (yych >= '`')
-            goto yy732;
-        } else {
-          if (yych <= 'z')
-            goto yy783;
-          if (yych <= 0x7F)
-            goto yy753;
-          if (yych <= 0xC1)
-            goto yy732;
-          goto yy755;
-        }
-      } else {
-        if (yych <= 0xEF) {
-          if (yych <= 0xE0)
-            goto yy756;
-          if (yych == 0xED)
-            goto yy761;
-          goto yy757;
-        } else {
-          if (yych <= 0xF0)
-            goto yy758;
-          if (yych <= 0xF3)
-            goto yy759;
-          if (yych <= 0xF4)
-            goto yy760;
-          goto yy732;
-        }
-      }
-    }
-  yy783:
-    ++p;
-    yych = *p;
-    if (yych <= '>') {
-      if (yych <= '&') {
-        if (yych <= 0x1F) {
-          if (yych <= 0x00)
-            goto yy732;
-          if (yych <= 0x08)
-            goto yy753;
-          if (yych >= 0x0E)
-            goto yy753;
-        } else {
-          if (yych <= ' ')
-            goto yy785;
-          if (yych == '"')
-            goto yy732;
-          goto yy753;
-        }
-      } else {
-        if (yych <= '/') {
-          if (yych <= '\'')
-            goto yy732;
-          if (yych <= ',')
-            goto yy753;
-          if (yych <= '.')
-            goto yy783;
-          goto yy753;
-        } else {
-          if (yych <= ';') {
-            if (yych <= ':')
-              goto yy783;
-            goto yy753;
-          } else {
-            if (yych <= '<')
-              goto yy732;
-            if (yych <= '=')
-              goto yy751;
-            goto yy738;
-          }
-        }
-      }
-    } else {
-      if (yych <= 0xC1) {
-        if (yych <= '_') {
-          if (yych <= '@')
-            goto yy753;
-          if (yych <= 'Z')
-            goto yy783;
-          if (yych <= '^')
-            goto yy753;
-          goto yy783;
-        } else {
-          if (yych <= '`')
-            goto yy732;
-          if (yych <= 'z')
-            goto yy783;
-          if (yych <= 0x7F)
-            goto yy753;
-          goto yy732;
-        }
-      } else {
-        if (yych <= 0xED) {
-          if (yych <= 0xDF)
-            goto yy755;
-          if (yych <= 0xE0)
-            goto yy756;
-          if (yych <= 0xEC)
-            goto yy757;
-          goto yy761;
-        } else {
-          if (yych <= 0xF0) {
-            if (yych <= 0xEF)
-              goto yy757;
-            goto yy758;
-          } else {
-            if (yych <= 0xF3)
-              goto yy759;
-            if (yych <= 0xF4)
-              goto yy760;
-            goto yy732;
-          }
-        }
-      }
-    }
-  yy785:
-    ++p;
-    yych = *p;
-    if (yych <= '@') {
-      if (yych <= '&') {
-        if (yych <= 0x1F) {
-          if (yych <= 0x00)
-            goto yy732;
-          if (yych <= 0x08)
-            goto yy753;
-          if (yych <= '\r')
-            goto yy785;
-          goto yy753;
-        } else {
-          if (yych <= ' ')
-            goto yy785;
-          if (yych == '"')
-            goto yy732;
-          goto yy753;
-        }
-      } else {
-        if (yych <= ';') {
-          if (yych <= '\'')
-            goto yy732;
-          if (yych == ':')
-            goto yy783;
-          goto yy753;
-        } else {
-          if (yych <= '<')
-            goto yy732;
-          if (yych <= '=')
-            goto yy751;
-          if (yych <= '>')
-            goto yy738;
-          goto yy753;
-        }
-      }
-    } else {
-      if (yych <= 0xDF) {
-        if (yych <= '`') {
-          if (yych <= 'Z')
-            goto yy783;
-          if (yych <= '^')
-            goto yy753;
-          if (yych <= '_')
-            goto yy783;
-          goto yy732;
-        } else {
-          if (yych <= 'z')
-            goto yy783;
-          if (yych <= 0x7F)
-            goto yy753;
-          if (yych <= 0xC1)
-            goto yy732;
-          goto yy755;
-        }
-      } else {
-        if (yych <= 0xEF) {
-          if (yych <= 0xE0)
-            goto yy756;
-          if (yych == 0xED)
-            goto yy761;
-          goto yy757;
-        } else {
-          if (yych <= 0xF0)
-            goto yy758;
-          if (yych <= 0xF3)
-            goto yy759;
-          if (yych <= 0xF4)
-            goto yy760;
-          goto yy732;
-        }
-      }
-    }
-  yy787:
-    ++p;
-    yych = *p;
-    if (yych <= '@') {
-      if (yych <= '"') {
-        if (yych <= '\r') {
-          if (yych <= 0x00)
-            goto yy732;
-          if (yych <= 0x08)
-            goto yy753;
-          goto yy787;
-        } else {
-          if (yych == ' ')
-            goto yy787;
-          if (yych <= '!')
-            goto yy753;
-          goto yy764;
-        }
-      } else {
-        if (yych <= ':') {
-          if (yych == '\'')
-            goto yy762;
-          if (yych <= '9')
-            goto yy753;
-          goto yy783;
-        } else {
-          if (yych <= ';')
-            goto yy753;
-          if (yych <= '=')
-            goto yy732;
-          if (yych <= '>')
-            goto yy738;
-          goto yy753;
-        }
-      }
-    } else {
-      if (yych <= 0xDF) {
-        if (yych <= '`') {
-          if (yych <= 'Z')
-            goto yy783;
-          if (yych <= '^')
-            goto yy753;
-          if (yych <= '_')
-            goto yy783;
-          goto yy732;
-        } else {
-          if (yych <= 'z')
-            goto yy783;
-          if (yych <= 0x7F)
-            goto yy753;
-          if (yych <= 0xC1)
-            goto yy732;
-          goto yy755;
-        }
-      } else {
-        if (yych <= 0xEF) {
-          if (yych <= 0xE0)
-            goto yy756;
-          if (yych == 0xED)
-            goto yy761;
-          goto yy757;
-        } else {
-          if (yych <= 0xF0)
-            goto yy758;
-          if (yych <= 0xF3)
-            goto yy759;
-          if (yych <= 0xF4)
-            goto yy760;
-          goto yy732;
-        }
-      }
-    }
-  }
-}
-
-// Try to match an HTML block end line of type 1
-bufsize_t _scan_html_block_end_1(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    unsigned int yyaccept = 0;
-    static const unsigned char yybm[] = {
-        0,  64, 64, 64, 64, 64, 64,  64, 64, 64, 0,  64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,
-    };
-    yych = *p;
-    if (yych <= 0xDF) {
-      if (yych <= ';') {
-        if (yych <= 0x00)
-          goto yy791;
-        if (yych != '\n')
-          goto yy793;
-      } else {
-        if (yych <= '<')
-          goto yy794;
-        if (yych <= 0x7F)
-          goto yy793;
-        if (yych >= 0xC2)
-          goto yy795;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy796;
-        if (yych == 0xED)
-          goto yy798;
-        goto yy797;
-      } else {
-        if (yych <= 0xF0)
-          goto yy799;
-        if (yych <= 0xF3)
-          goto yy800;
-        if (yych <= 0xF4)
-          goto yy801;
-      }
-    }
-  yy791:
-    ++p;
-  yy792 : { return 0; }
-  yy793:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= '\n') {
-      if (yych <= 0x00)
-        goto yy792;
-      if (yych <= '\t')
-        goto yy806;
-      goto yy792;
-    } else {
-      if (yych <= 0x7F)
-        goto yy806;
-      if (yych <= 0xC1)
-        goto yy792;
-      if (yych <= 0xF4)
-        goto yy806;
-      goto yy792;
-    }
-  yy794:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= '.') {
-      if (yych <= 0x00)
-        goto yy792;
-      if (yych == '\n')
-        goto yy792;
-      goto yy806;
-    } else {
-      if (yych <= 0x7F) {
-        if (yych <= '/')
-          goto yy814;
-        goto yy806;
-      } else {
-        if (yych <= 0xC1)
-          goto yy792;
-        if (yych <= 0xF4)
-          goto yy806;
-        goto yy792;
-      }
-    }
-  yy795:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy792;
-    if (yych <= 0xBF)
-      goto yy805;
-    goto yy792;
-  yy796:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x9F)
-      goto yy792;
-    if (yych <= 0xBF)
-      goto yy804;
-    goto yy792;
-  yy797:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy792;
-    if (yych <= 0xBF)
-      goto yy804;
-    goto yy792;
-  yy798:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy792;
-    if (yych <= 0x9F)
-      goto yy804;
-    goto yy792;
-  yy799:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x8F)
-      goto yy792;
-    if (yych <= 0xBF)
-      goto yy802;
-    goto yy792;
-  yy800:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy792;
-    if (yych <= 0xBF)
-      goto yy802;
-    goto yy792;
-  yy801:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy792;
-    if (yych >= 0x90)
-      goto yy792;
-  yy802:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy803;
-    if (yych <= 0xBF)
-      goto yy804;
-  yy803:
-    p = marker;
-    if (yyaccept == 0) {
-      goto yy792;
-    } else {
-      goto yy820;
-    }
-  yy804:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy803;
-    if (yych >= 0xC0)
-      goto yy803;
-  yy805:
-    ++p;
-    yych = *p;
-  yy806:
-    if (yybm[0 + yych] & 64) {
-      goto yy805;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy803;
-        if (yych >= '=')
-          goto yy803;
-      } else {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        goto yy802;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy813;
-        if (yych <= 0xEF)
-          goto yy802;
-        goto yy810;
-      } else {
-        if (yych <= 0xF3)
-          goto yy811;
-        if (yych <= 0xF4)
-          goto yy812;
-        goto yy803;
-      }
-    }
-  yy807:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xDF) {
-      if (yych <= '.') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= '/')
-          goto yy814;
-        if (yych <= 0x7F)
-          goto yy805;
-        if (yych <= 0xC1)
-          goto yy803;
-        goto yy804;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych == 0xED)
-          goto yy813;
-        goto yy802;
-      } else {
-        if (yych <= 0xF0)
-          goto yy810;
-        if (yych <= 0xF3)
-          goto yy811;
-        if (yych <= 0xF4)
-          goto yy812;
-        goto yy803;
-      }
-    }
-  yy809:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy803;
-    if (yych <= 0xBF)
-      goto yy804;
-    goto yy803;
-  yy810:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy803;
-    if (yych <= 0xBF)
-      goto yy802;
-    goto yy803;
-  yy811:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy803;
-    if (yych <= 0xBF)
-      goto yy802;
-    goto yy803;
-  yy812:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy803;
-    if (yych <= 0x8F)
-      goto yy802;
-    goto yy803;
-  yy813:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy803;
-    if (yych <= 0x9F)
-      goto yy804;
-    goto yy803;
-  yy814:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 's') {
-      if (yych <= 'P') {
-        if (yych <= '\t') {
-          if (yych <= 0x00)
-            goto yy803;
-          goto yy805;
-        } else {
-          if (yych <= '\n')
-            goto yy803;
-          if (yych <= 'O')
-            goto yy805;
-          goto yy816;
-        }
-      } else {
-        if (yych <= 'o') {
-          if (yych != 'S')
-            goto yy805;
-        } else {
-          if (yych <= 'p')
-            goto yy816;
-          if (yych <= 'r')
-            goto yy805;
-        }
-      }
-    } else {
-      if (yych <= 0xEC) {
-        if (yych <= 0xC1) {
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        } else {
-          if (yych <= 0xDF)
-            goto yy804;
-          if (yych <= 0xE0)
-            goto yy809;
-          goto yy802;
-        }
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xED)
-            goto yy813;
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 't') {
-      if (yych <= 'C') {
-        if (yych <= '\t') {
-          if (yych <= 0x00)
-            goto yy803;
-          goto yy805;
-        } else {
-          if (yych <= '\n')
-            goto yy803;
-          if (yych <= 'B')
-            goto yy805;
-          goto yy821;
-        }
-      } else {
-        if (yych <= 'b') {
-          if (yych == 'T')
-            goto yy822;
-          goto yy805;
-        } else {
-          if (yych <= 'c')
-            goto yy821;
-          if (yych <= 's')
-            goto yy805;
-          goto yy822;
-        }
-      }
-    } else {
-      if (yych <= 0xEC) {
-        if (yych <= 0xC1) {
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        } else {
-          if (yych <= 0xDF)
-            goto yy804;
-          if (yych <= 0xE0)
-            goto yy809;
-          goto yy802;
-        }
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xED)
-            goto yy813;
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-  yy816:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xC1) {
-      if (yych <= 'Q') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= 'q') {
-          if (yych >= 'S')
-            goto yy805;
-        } else {
-          if (yych <= 'r')
-            goto yy817;
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        }
-      }
-    } else {
-      if (yych <= 0xED) {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych <= 0xEC)
-          goto yy802;
-        goto yy813;
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-  yy817:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xC1) {
-      if (yych <= 'D') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= 'd') {
-          if (yych >= 'F')
-            goto yy805;
-        } else {
-          if (yych <= 'e')
-            goto yy818;
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        }
-      }
-    } else {
-      if (yych <= 0xED) {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych <= 0xEC)
-          goto yy802;
-        goto yy813;
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-  yy818:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xDF) {
-      if (yych <= '=') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= '>')
-          goto yy819;
-        if (yych <= 0x7F)
-          goto yy805;
-        if (yych <= 0xC1)
-          goto yy803;
-        goto yy804;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych == 0xED)
-          goto yy813;
-        goto yy802;
-      } else {
-        if (yych <= 0xF0)
-          goto yy810;
-        if (yych <= 0xF3)
-          goto yy811;
-        if (yych <= 0xF4)
-          goto yy812;
-        goto yy803;
-      }
-    }
-  yy819:
-    yyaccept = 1;
-    marker = ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy805;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy820;
-        if (yych <= '<')
-          goto yy807;
-      } else {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        goto yy802;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy813;
-        if (yych <= 0xEF)
-          goto yy802;
-        goto yy810;
-      } else {
-        if (yych <= 0xF3)
-          goto yy811;
-        if (yych <= 0xF4)
-          goto yy812;
-      }
-    }
-  yy820 : { return (bufsize_t)(p - start); }
-  yy821:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xC1) {
-      if (yych <= 'Q') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= 'q') {
-          if (yych <= 'R')
-            goto yy825;
-          goto yy805;
-        } else {
-          if (yych <= 'r')
-            goto yy825;
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        }
-      }
-    } else {
-      if (yych <= 0xED) {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych <= 0xEC)
-          goto yy802;
-        goto yy813;
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-  yy822:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xC1) {
-      if (yych <= 'X') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= 'x') {
-          if (yych >= 'Z')
-            goto yy805;
-        } else {
-          if (yych <= 'y')
-            goto yy823;
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        }
-      }
-    } else {
-      if (yych <= 0xED) {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych <= 0xEC)
-          goto yy802;
-        goto yy813;
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-  yy823:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xC1) {
-      if (yych <= 'K') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= 'k') {
-          if (yych >= 'M')
-            goto yy805;
-        } else {
-          if (yych <= 'l')
-            goto yy824;
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        }
-      }
-    } else {
-      if (yych <= 0xED) {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych <= 0xEC)
-          goto yy802;
-        goto yy813;
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-  yy824:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xC1) {
-      if (yych <= 'D') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= 'd') {
-          if (yych <= 'E')
-            goto yy818;
-          goto yy805;
-        } else {
-          if (yych <= 'e')
-            goto yy818;
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        }
-      }
-    } else {
-      if (yych <= 0xED) {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych <= 0xEC)
-          goto yy802;
-        goto yy813;
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-  yy825:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xC1) {
-      if (yych <= 'H') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= 'h') {
-          if (yych >= 'J')
-            goto yy805;
-        } else {
-          if (yych <= 'i')
-            goto yy826;
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        }
-      }
-    } else {
-      if (yych <= 0xED) {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych <= 0xEC)
-          goto yy802;
-        goto yy813;
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-  yy826:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xC1) {
-      if (yych <= 'O') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= 'o') {
-          if (yych >= 'Q')
-            goto yy805;
-        } else {
-          if (yych <= 'p')
-            goto yy827;
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        }
-      }
-    } else {
-      if (yych <= 0xED) {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych <= 0xEC)
-          goto yy802;
-        goto yy813;
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-  yy827:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy807;
-    }
-    if (yych <= 0xC1) {
-      if (yych <= 'S') {
-        if (yych <= 0x00)
-          goto yy803;
-        if (yych == '\n')
-          goto yy803;
-        goto yy805;
-      } else {
-        if (yych <= 's') {
-          if (yych <= 'T')
-            goto yy818;
-          goto yy805;
-        } else {
-          if (yych <= 't')
-            goto yy818;
-          if (yych <= 0x7F)
-            goto yy805;
-          goto yy803;
-        }
-      }
-    } else {
-      if (yych <= 0xED) {
-        if (yych <= 0xDF)
-          goto yy804;
-        if (yych <= 0xE0)
-          goto yy809;
-        if (yych <= 0xEC)
-          goto yy802;
-        goto yy813;
-      } else {
-        if (yych <= 0xF0) {
-          if (yych <= 0xEF)
-            goto yy802;
-          goto yy810;
-        } else {
-          if (yych <= 0xF3)
-            goto yy811;
-          if (yych <= 0xF4)
-            goto yy812;
-          goto yy803;
-        }
-      }
-    }
-  }
-}
-
-// Try to match an HTML block end line of type 2
-bufsize_t _scan_html_block_end_2(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    unsigned int yyaccept = 0;
-    static const unsigned char yybm[] = {
-        0,  64, 64, 64, 64, 64, 64, 64, 64, 64,  0,  64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,
-    };
-    yych = *p;
-    if (yych <= 0xDF) {
-      if (yych <= ',') {
-        if (yych <= 0x00)
-          goto yy830;
-        if (yych != '\n')
-          goto yy832;
-      } else {
-        if (yych <= '-')
-          goto yy833;
-        if (yych <= 0x7F)
-          goto yy832;
-        if (yych >= 0xC2)
-          goto yy834;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy835;
-        if (yych == 0xED)
-          goto yy837;
-        goto yy836;
-      } else {
-        if (yych <= 0xF0)
-          goto yy838;
-        if (yych <= 0xF3)
-          goto yy839;
-        if (yych <= 0xF4)
-          goto yy840;
-      }
-    }
-  yy830:
-    ++p;
-  yy831 : { return 0; }
-  yy832:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= '\n') {
-      if (yych <= 0x00)
-        goto yy831;
-      if (yych <= '\t')
-        goto yy845;
-      goto yy831;
-    } else {
-      if (yych <= 0x7F)
-        goto yy845;
-      if (yych <= 0xC1)
-        goto yy831;
-      if (yych <= 0xF4)
-        goto yy845;
-      goto yy831;
-    }
-  yy833:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yybm[0 + yych] & 128) {
-      goto yy852;
-    }
-    if (yych <= '\n') {
-      if (yych <= 0x00)
-        goto yy831;
-      if (yych <= '\t')
-        goto yy845;
-      goto yy831;
-    } else {
-      if (yych <= 0x7F)
-        goto yy845;
-      if (yych <= 0xC1)
-        goto yy831;
-      if (yych <= 0xF4)
-        goto yy845;
-      goto yy831;
-    }
-  yy834:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy831;
-    if (yych <= 0xBF)
-      goto yy844;
-    goto yy831;
-  yy835:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x9F)
-      goto yy831;
-    if (yych <= 0xBF)
-      goto yy843;
-    goto yy831;
-  yy836:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy831;
-    if (yych <= 0xBF)
-      goto yy843;
-    goto yy831;
-  yy837:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy831;
-    if (yych <= 0x9F)
-      goto yy843;
-    goto yy831;
-  yy838:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x8F)
-      goto yy831;
-    if (yych <= 0xBF)
-      goto yy841;
-    goto yy831;
-  yy839:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy831;
-    if (yych <= 0xBF)
-      goto yy841;
-    goto yy831;
-  yy840:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy831;
-    if (yych >= 0x90)
-      goto yy831;
-  yy841:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy842;
-    if (yych <= 0xBF)
-      goto yy843;
-  yy842:
-    p = marker;
-    if (yyaccept == 0) {
-      goto yy831;
-    } else {
-      goto yy855;
-    }
-  yy843:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy842;
-    if (yych >= 0xC0)
-      goto yy842;
-  yy844:
-    ++p;
-    yych = *p;
-  yy845:
-    if (yybm[0 + yych] & 64) {
-      goto yy844;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy842;
-        if (yych >= '.')
-          goto yy842;
-      } else {
-        if (yych <= 0xDF)
-          goto yy843;
-        if (yych <= 0xE0)
-          goto yy847;
-        goto yy841;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy851;
-        if (yych <= 0xEF)
-          goto yy841;
-        goto yy848;
-      } else {
-        if (yych <= 0xF3)
-          goto yy849;
-        if (yych <= 0xF4)
-          goto yy850;
-        goto yy842;
-      }
-    }
-  yy846:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy844;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy842;
-        if (yych <= '-')
-          goto yy852;
-        goto yy842;
-      } else {
-        if (yych <= 0xDF)
-          goto yy843;
-        if (yych >= 0xE1)
-          goto yy841;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy851;
-        if (yych <= 0xEF)
-          goto yy841;
-        goto yy848;
-      } else {
-        if (yych <= 0xF3)
-          goto yy849;
-        if (yych <= 0xF4)
-          goto yy850;
-        goto yy842;
-      }
-    }
-  yy847:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy842;
-    if (yych <= 0xBF)
-      goto yy843;
-    goto yy842;
-  yy848:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy842;
-    if (yych <= 0xBF)
-      goto yy841;
-    goto yy842;
-  yy849:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy842;
-    if (yych <= 0xBF)
-      goto yy841;
-    goto yy842;
-  yy850:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy842;
-    if (yych <= 0x8F)
-      goto yy841;
-    goto yy842;
-  yy851:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy842;
-    if (yych <= 0x9F)
-      goto yy843;
-    goto yy842;
-  yy852:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy852;
-    }
-    if (yych <= 0xDF) {
-      if (yych <= '=') {
-        if (yych <= 0x00)
-          goto yy842;
-        if (yych == '\n')
-          goto yy842;
-        goto yy844;
-      } else {
-        if (yych <= '>')
-          goto yy854;
-        if (yych <= 0x7F)
-          goto yy844;
-        if (yych <= 0xC1)
-          goto yy842;
-        goto yy843;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy847;
-        if (yych == 0xED)
-          goto yy851;
-        goto yy841;
-      } else {
-        if (yych <= 0xF0)
-          goto yy848;
-        if (yych <= 0xF3)
-          goto yy849;
-        if (yych <= 0xF4)
-          goto yy850;
-        goto yy842;
-      }
-    }
-  yy854:
-    yyaccept = 1;
-    marker = ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy844;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy855;
-        if (yych <= '-')
-          goto yy846;
-      } else {
-        if (yych <= 0xDF)
-          goto yy843;
-        if (yych <= 0xE0)
-          goto yy847;
-        goto yy841;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy851;
-        if (yych <= 0xEF)
-          goto yy841;
-        goto yy848;
-      } else {
-        if (yych <= 0xF3)
-          goto yy849;
-        if (yych <= 0xF4)
-          goto yy850;
-      }
-    }
-  yy855 : { return (bufsize_t)(p - start); }
-  }
-}
-
-// Try to match an HTML block end line of type 3
-bufsize_t _scan_html_block_end_3(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    unsigned int yyaccept = 0;
-    static const unsigned char yybm[] = {
-        0,  64, 64, 64, 64, 64, 64, 64, 64, 64,  0,  64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,
-    };
-    yych = *p;
-    if (yych <= 0xDF) {
-      if (yych <= '>') {
-        if (yych <= 0x00)
-          goto yy858;
-        if (yych != '\n')
-          goto yy860;
-      } else {
-        if (yych <= '?')
-          goto yy861;
-        if (yych <= 0x7F)
-          goto yy860;
-        if (yych >= 0xC2)
-          goto yy862;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy863;
-        if (yych == 0xED)
-          goto yy865;
-        goto yy864;
-      } else {
-        if (yych <= 0xF0)
-          goto yy866;
-        if (yych <= 0xF3)
-          goto yy867;
-        if (yych <= 0xF4)
-          goto yy868;
-      }
-    }
-  yy858:
-    ++p;
-  yy859 : { return 0; }
-  yy860:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= '\n') {
-      if (yych <= 0x00)
-        goto yy859;
-      if (yych <= '\t')
-        goto yy873;
-      goto yy859;
-    } else {
-      if (yych <= 0x7F)
-        goto yy873;
-      if (yych <= 0xC1)
-        goto yy859;
-      if (yych <= 0xF4)
-        goto yy873;
-      goto yy859;
-    }
-  yy861:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= '=') {
-      if (yych <= 0x00)
-        goto yy859;
-      if (yych == '\n')
-        goto yy859;
-      goto yy873;
-    } else {
-      if (yych <= 0x7F) {
-        if (yych <= '>')
-          goto yy881;
-        goto yy873;
-      } else {
-        if (yych <= 0xC1)
-          goto yy859;
-        if (yych <= 0xF4)
-          goto yy873;
-        goto yy859;
-      }
-    }
-  yy862:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy859;
-    if (yych <= 0xBF)
-      goto yy872;
-    goto yy859;
-  yy863:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x9F)
-      goto yy859;
-    if (yych <= 0xBF)
-      goto yy871;
-    goto yy859;
-  yy864:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy859;
-    if (yych <= 0xBF)
-      goto yy871;
-    goto yy859;
-  yy865:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy859;
-    if (yych <= 0x9F)
-      goto yy871;
-    goto yy859;
-  yy866:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x8F)
-      goto yy859;
-    if (yych <= 0xBF)
-      goto yy869;
-    goto yy859;
-  yy867:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy859;
-    if (yych <= 0xBF)
-      goto yy869;
-    goto yy859;
-  yy868:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy859;
-    if (yych >= 0x90)
-      goto yy859;
-  yy869:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy870;
-    if (yych <= 0xBF)
-      goto yy871;
-  yy870:
-    p = marker;
-    if (yyaccept == 0) {
-      goto yy859;
-    } else {
-      goto yy882;
-    }
-  yy871:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy870;
-    if (yych >= 0xC0)
-      goto yy870;
-  yy872:
-    ++p;
-    yych = *p;
-  yy873:
-    if (yybm[0 + yych] & 64) {
-      goto yy872;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy870;
-        if (yych >= '@')
-          goto yy870;
-      } else {
-        if (yych <= 0xDF)
-          goto yy871;
-        if (yych <= 0xE0)
-          goto yy876;
-        goto yy869;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy880;
-        if (yych <= 0xEF)
-          goto yy869;
-        goto yy877;
-      } else {
-        if (yych <= 0xF3)
-          goto yy878;
-        if (yych <= 0xF4)
-          goto yy879;
-        goto yy870;
-      }
-    }
-  yy874:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy874;
-    }
-    if (yych <= 0xDF) {
-      if (yych <= '=') {
-        if (yych <= 0x00)
-          goto yy870;
-        if (yych == '\n')
-          goto yy870;
-        goto yy872;
-      } else {
-        if (yych <= '>')
-          goto yy881;
-        if (yych <= 0x7F)
-          goto yy872;
-        if (yych <= 0xC1)
-          goto yy870;
-        goto yy871;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy876;
-        if (yych == 0xED)
-          goto yy880;
-        goto yy869;
-      } else {
-        if (yych <= 0xF0)
-          goto yy877;
-        if (yych <= 0xF3)
-          goto yy878;
-        if (yych <= 0xF4)
-          goto yy879;
-        goto yy870;
-      }
-    }
-  yy876:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy870;
-    if (yych <= 0xBF)
-      goto yy871;
-    goto yy870;
-  yy877:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy870;
-    if (yych <= 0xBF)
-      goto yy869;
-    goto yy870;
-  yy878:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy870;
-    if (yych <= 0xBF)
-      goto yy869;
-    goto yy870;
-  yy879:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy870;
-    if (yych <= 0x8F)
-      goto yy869;
-    goto yy870;
-  yy880:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy870;
-    if (yych <= 0x9F)
-      goto yy871;
-    goto yy870;
-  yy881:
-    yyaccept = 1;
-    marker = ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy872;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy882;
-        if (yych <= '?')
-          goto yy874;
-      } else {
-        if (yych <= 0xDF)
-          goto yy871;
-        if (yych <= 0xE0)
-          goto yy876;
-        goto yy869;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy880;
-        if (yych <= 0xEF)
-          goto yy869;
-        goto yy877;
-      } else {
-        if (yych <= 0xF3)
-          goto yy878;
-        if (yych <= 0xF4)
-          goto yy879;
-      }
-    }
-  yy882 : { return (bufsize_t)(p - start); }
-  }
-}
-
-// Try to match an HTML block end line of type 4
-bufsize_t _scan_html_block_end_4(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    unsigned int yyaccept = 0;
-    static const unsigned char yybm[] = {
-        0,  64, 64, 64, 64, 64, 64, 64, 64,  64, 0,  64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64, 64, 64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,
-    };
-    yych = *p;
-    if (yych <= 0xDF) {
-      if (yych <= '=') {
-        if (yych <= 0x00)
-          goto yy885;
-        if (yych != '\n')
-          goto yy887;
-      } else {
-        if (yych <= '>')
-          goto yy888;
-        if (yych <= 0x7F)
-          goto yy887;
-        if (yych >= 0xC2)
-          goto yy890;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy891;
-        if (yych == 0xED)
-          goto yy893;
-        goto yy892;
-      } else {
-        if (yych <= 0xF0)
-          goto yy894;
-        if (yych <= 0xF3)
-          goto yy895;
-        if (yych <= 0xF4)
-          goto yy896;
-      }
-    }
-  yy885:
-    ++p;
-  yy886 : { return 0; }
-  yy887:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= '\n') {
-      if (yych <= 0x00)
-        goto yy886;
-      if (yych <= '\t')
-        goto yy901;
-      goto yy886;
-    } else {
-      if (yych <= 0x7F)
-        goto yy901;
-      if (yych <= 0xC1)
-        goto yy886;
-      if (yych <= 0xF4)
-        goto yy901;
-      goto yy886;
-    }
-  yy888:
-    yyaccept = 1;
-    yych = *(marker = ++p);
-    if (yych <= '\n') {
-      if (yych <= 0x00)
-        goto yy889;
-      if (yych <= '\t')
-        goto yy901;
-    } else {
-      if (yych <= 0x7F)
-        goto yy901;
-      if (yych <= 0xC1)
-        goto yy889;
-      if (yych <= 0xF4)
-        goto yy901;
-    }
-  yy889 : { return (bufsize_t)(p - start); }
-  yy890:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy886;
-    if (yych <= 0xBF)
-      goto yy900;
-    goto yy886;
-  yy891:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x9F)
-      goto yy886;
-    if (yych <= 0xBF)
-      goto yy899;
-    goto yy886;
-  yy892:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy886;
-    if (yych <= 0xBF)
-      goto yy899;
-    goto yy886;
-  yy893:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy886;
-    if (yych <= 0x9F)
-      goto yy899;
-    goto yy886;
-  yy894:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x8F)
-      goto yy886;
-    if (yych <= 0xBF)
-      goto yy897;
-    goto yy886;
-  yy895:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy886;
-    if (yych <= 0xBF)
-      goto yy897;
-    goto yy886;
-  yy896:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy886;
-    if (yych >= 0x90)
-      goto yy886;
-  yy897:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy898;
-    if (yych <= 0xBF)
-      goto yy899;
-  yy898:
-    p = marker;
-    if (yyaccept == 0) {
-      goto yy886;
-    } else {
-      goto yy889;
-    }
-  yy899:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy898;
-    if (yych >= 0xC0)
-      goto yy898;
-  yy900:
-    ++p;
-    yych = *p;
-  yy901:
-    if (yybm[0 + yych] & 64) {
-      goto yy900;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy898;
-        if (yych >= '?')
-          goto yy898;
-      } else {
-        if (yych <= 0xDF)
-          goto yy899;
-        if (yych <= 0xE0)
-          goto yy904;
-        goto yy897;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy908;
-        if (yych <= 0xEF)
-          goto yy897;
-        goto yy905;
-      } else {
-        if (yych <= 0xF3)
-          goto yy906;
-        if (yych <= 0xF4)
-          goto yy907;
-        goto yy898;
-      }
-    }
-  yy902:
-    yyaccept = 1;
-    marker = ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy900;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy889;
-        if (yych <= '>')
-          goto yy902;
-        goto yy889;
-      } else {
-        if (yych <= 0xDF)
-          goto yy899;
-        if (yych >= 0xE1)
-          goto yy897;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy908;
-        if (yych <= 0xEF)
-          goto yy897;
-        goto yy905;
-      } else {
-        if (yych <= 0xF3)
-          goto yy906;
-        if (yych <= 0xF4)
-          goto yy907;
-        goto yy889;
-      }
-    }
-  yy904:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy898;
-    if (yych <= 0xBF)
-      goto yy899;
-    goto yy898;
-  yy905:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy898;
-    if (yych <= 0xBF)
-      goto yy897;
-    goto yy898;
-  yy906:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy898;
-    if (yych <= 0xBF)
-      goto yy897;
-    goto yy898;
-  yy907:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy898;
-    if (yych <= 0x8F)
-      goto yy897;
-    goto yy898;
-  yy908:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy898;
-    if (yych <= 0x9F)
-      goto yy899;
-    goto yy898;
-  }
-}
-
-// Try to match an HTML block end line of type 5
-bufsize_t _scan_html_block_end_5(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    unsigned int yyaccept = 0;
-    static const unsigned char yybm[] = {
-        0,  64, 64, 64,  64, 64, 64, 64, 64, 64, 0,  64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 64, 64,  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-        64, 64, 0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-        0,  0,  0,  0,
-    };
-    yych = *p;
-    if (yych <= 0xDF) {
-      if (yych <= '\\') {
-        if (yych <= 0x00)
-          goto yy911;
-        if (yych != '\n')
-          goto yy913;
-      } else {
-        if (yych <= ']')
-          goto yy914;
-        if (yych <= 0x7F)
-          goto yy913;
-        if (yych >= 0xC2)
-          goto yy915;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy916;
-        if (yych == 0xED)
-          goto yy918;
-        goto yy917;
-      } else {
-        if (yych <= 0xF0)
-          goto yy919;
-        if (yych <= 0xF3)
-          goto yy920;
-        if (yych <= 0xF4)
-          goto yy921;
-      }
-    }
-  yy911:
-    ++p;
-  yy912 : { return 0; }
-  yy913:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= '\n') {
-      if (yych <= 0x00)
-        goto yy912;
-      if (yych <= '\t')
-        goto yy926;
-      goto yy912;
-    } else {
-      if (yych <= 0x7F)
-        goto yy926;
-      if (yych <= 0xC1)
-        goto yy912;
-      if (yych <= 0xF4)
-        goto yy926;
-      goto yy912;
-    }
-  yy914:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yybm[0 + yych] & 128) {
-      goto yy933;
-    }
-    if (yych <= '\n') {
-      if (yych <= 0x00)
-        goto yy912;
-      if (yych <= '\t')
-        goto yy926;
-      goto yy912;
-    } else {
-      if (yych <= 0x7F)
-        goto yy926;
-      if (yych <= 0xC1)
-        goto yy912;
-      if (yych <= 0xF4)
-        goto yy926;
-      goto yy912;
-    }
-  yy915:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy912;
-    if (yych <= 0xBF)
-      goto yy925;
-    goto yy912;
-  yy916:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x9F)
-      goto yy912;
-    if (yych <= 0xBF)
-      goto yy924;
-    goto yy912;
-  yy917:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy912;
-    if (yych <= 0xBF)
-      goto yy924;
-    goto yy912;
-  yy918:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy912;
-    if (yych <= 0x9F)
-      goto yy924;
-    goto yy912;
-  yy919:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x8F)
-      goto yy912;
-    if (yych <= 0xBF)
-      goto yy922;
-    goto yy912;
-  yy920:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy912;
-    if (yych <= 0xBF)
-      goto yy922;
-    goto yy912;
-  yy921:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x7F)
-      goto yy912;
-    if (yych >= 0x90)
-      goto yy912;
-  yy922:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy923;
-    if (yych <= 0xBF)
-      goto yy924;
-  yy923:
-    p = marker;
-    if (yyaccept == 0) {
-      goto yy912;
-    } else {
-      goto yy936;
-    }
-  yy924:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy923;
-    if (yych >= 0xC0)
-      goto yy923;
-  yy925:
-    ++p;
-    yych = *p;
-  yy926:
-    if (yybm[0 + yych] & 64) {
-      goto yy925;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy923;
-        if (yych >= '^')
-          goto yy923;
-      } else {
-        if (yych <= 0xDF)
-          goto yy924;
-        if (yych <= 0xE0)
-          goto yy928;
-        goto yy922;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy932;
-        if (yych <= 0xEF)
-          goto yy922;
-        goto yy929;
-      } else {
-        if (yych <= 0xF3)
-          goto yy930;
-        if (yych <= 0xF4)
-          goto yy931;
-        goto yy923;
-      }
-    }
-  yy927:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy925;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy923;
-        if (yych <= ']')
-          goto yy933;
-        goto yy923;
-      } else {
-        if (yych <= 0xDF)
-          goto yy924;
-        if (yych >= 0xE1)
-          goto yy922;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy932;
-        if (yych <= 0xEF)
-          goto yy922;
-        goto yy929;
-      } else {
-        if (yych <= 0xF3)
-          goto yy930;
-        if (yych <= 0xF4)
-          goto yy931;
-        goto yy923;
-      }
-    }
-  yy928:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy923;
-    if (yych <= 0xBF)
-      goto yy924;
-    goto yy923;
-  yy929:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy923;
-    if (yych <= 0xBF)
-      goto yy922;
-    goto yy923;
-  yy930:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy923;
-    if (yych <= 0xBF)
-      goto yy922;
-    goto yy923;
-  yy931:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy923;
-    if (yych <= 0x8F)
-      goto yy922;
-    goto yy923;
-  yy932:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy923;
-    if (yych <= 0x9F)
-      goto yy924;
-    goto yy923;
-  yy933:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy933;
-    }
-    if (yych <= 0xDF) {
-      if (yych <= '=') {
-        if (yych <= 0x00)
-          goto yy923;
-        if (yych == '\n')
-          goto yy923;
-        goto yy925;
-      } else {
-        if (yych <= '>')
-          goto yy935;
-        if (yych <= 0x7F)
-          goto yy925;
-        if (yych <= 0xC1)
-          goto yy923;
-        goto yy924;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych <= 0xE0)
-          goto yy928;
-        if (yych == 0xED)
-          goto yy932;
-        goto yy922;
-      } else {
-        if (yych <= 0xF0)
-          goto yy929;
-        if (yych <= 0xF3)
-          goto yy930;
-        if (yych <= 0xF4)
-          goto yy931;
-        goto yy923;
-      }
-    }
-  yy935:
-    yyaccept = 1;
-    marker = ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy925;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= '\n')
-          goto yy936;
-        if (yych <= ']')
-          goto yy927;
-      } else {
-        if (yych <= 0xDF)
-          goto yy924;
-        if (yych <= 0xE0)
-          goto yy928;
-        goto yy922;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy932;
-        if (yych <= 0xEF)
-          goto yy922;
-        goto yy929;
-      } else {
-        if (yych <= 0xF3)
-          goto yy930;
-        if (yych <= 0xF4)
-          goto yy931;
-      }
-    }
-  yy936 : { 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,   224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
-        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
-        224, 224, 224, 224, 224, 224, 96,  224, 224, 224, 224, 160, 224, 192,
-        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
-        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
-        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
-        224, 224, 224, 224, 224, 224, 224, 224, 16,  224, 224, 224, 224, 224,
-        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
-        224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
-        224, 224, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,
-    };
-    yych = *p;
-    if (yych <= '&') {
-      if (yych == '"')
-        goto yy941;
-    } else {
-      if (yych <= '\'')
-        goto yy942;
-      if (yych <= '(')
-        goto yy943;
-    }
-    ++p;
-  yy940 : { return 0; }
-  yy941:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x00)
-      goto yy940;
-    if (yych <= 0x7F)
-      goto yy976;
-    if (yych <= 0xC1)
-      goto yy940;
-    if (yych <= 0xF4)
-      goto yy976;
-    goto yy940;
-  yy942:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x00)
-      goto yy940;
-    if (yych <= 0x7F)
-      goto yy962;
-    if (yych <= 0xC1)
-      goto yy940;
-    if (yych <= 0xF4)
-      goto yy962;
-    goto yy940;
-  yy943:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych <= 0x00)
-      goto yy940;
-    if (yych <= 0x7F)
-      goto yy948;
-    if (yych <= 0xC1)
-      goto yy940;
-    if (yych <= 0xF4)
-      goto yy948;
-    goto yy940;
-  yy944:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 32) {
-      goto yy947;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '\\') {
-        if (yych <= 0x00)
-          goto yy946;
-        if (yych <= ')')
-          goto yy958;
-        goto yy944;
-      } else {
-        if (yych <= 0xC1)
-          goto yy946;
-        if (yych <= 0xDF)
-          goto yy949;
-        goto yy950;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy955;
-        goto yy951;
-      } else {
-        if (yych <= 0xF0)
-          goto yy952;
-        if (yych <= 0xF3)
-          goto yy953;
-        if (yych <= 0xF4)
-          goto yy954;
-      }
-    }
-  yy946:
-    p = marker;
-    if (yyaccept <= 1) {
-      if (yyaccept == 0) {
-        goto yy940;
-      } else {
-        goto yy957;
-      }
-    } else {
-      if (yyaccept == 2) {
-        goto yy971;
-      } else {
-        goto yy985;
-      }
-    }
-  yy947:
-    ++p;
-    yych = *p;
-  yy948:
-    if (yybm[0 + yych] & 32) {
-      goto yy947;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '\\') {
-        if (yych <= 0x00)
-          goto yy946;
-        if (yych <= ')')
-          goto yy956;
-        goto yy944;
-      } else {
-        if (yych <= 0xC1)
-          goto yy946;
-        if (yych >= 0xE0)
-          goto yy950;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy955;
-        goto yy951;
-      } else {
-        if (yych <= 0xF0)
-          goto yy952;
-        if (yych <= 0xF3)
-          goto yy953;
-        if (yych <= 0xF4)
-          goto yy954;
-        goto yy946;
-      }
-    }
-  yy949:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy947;
-    goto yy946;
-  yy950:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy949;
-    goto yy946;
-  yy951:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy949;
-    goto yy946;
-  yy952:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy951;
-    goto yy946;
-  yy953:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy951;
-    goto yy946;
-  yy954:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0x8F)
-      goto yy951;
-    goto yy946;
-  yy955:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0x9F)
-      goto yy949;
-    goto yy946;
-  yy956:
-    ++p;
-  yy957 : { return (bufsize_t)(p - start); }
-  yy958:
-    yyaccept = 1;
-    marker = ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 32) {
-      goto yy947;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '\\') {
-        if (yych <= 0x00)
-          goto yy957;
-        if (yych <= ')')
-          goto yy956;
-        goto yy944;
-      } else {
-        if (yych <= 0xC1)
-          goto yy957;
-        if (yych <= 0xDF)
-          goto yy949;
-        goto yy950;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy955;
-        goto yy951;
-      } else {
-        if (yych <= 0xF0)
-          goto yy952;
-        if (yych <= 0xF3)
-          goto yy953;
-        if (yych <= 0xF4)
-          goto yy954;
-        goto yy957;
-      }
-    }
-  yy959:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy961;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '\\') {
-        if (yych <= 0x00)
-          goto yy946;
-        if (yych <= '\'')
-          goto yy972;
-        goto yy959;
-      } else {
-        if (yych <= 0xC1)
-          goto yy946;
-        if (yych <= 0xDF)
-          goto yy963;
-        goto yy964;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy969;
-        goto yy965;
-      } else {
-        if (yych <= 0xF0)
-          goto yy966;
-        if (yych <= 0xF3)
-          goto yy967;
-        if (yych <= 0xF4)
-          goto yy968;
-        goto yy946;
-      }
-    }
-  yy961:
-    ++p;
-    yych = *p;
-  yy962:
-    if (yybm[0 + yych] & 64) {
-      goto yy961;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '\\') {
-        if (yych <= 0x00)
-          goto yy946;
-        if (yych <= '\'')
-          goto yy970;
-        goto yy959;
-      } else {
-        if (yych <= 0xC1)
-          goto yy946;
-        if (yych >= 0xE0)
-          goto yy964;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy969;
-        goto yy965;
-      } else {
-        if (yych <= 0xF0)
-          goto yy966;
-        if (yych <= 0xF3)
-          goto yy967;
-        if (yych <= 0xF4)
-          goto yy968;
-        goto yy946;
-      }
-    }
-  yy963:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy961;
-    goto yy946;
-  yy964:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy963;
-    goto yy946;
-  yy965:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy963;
-    goto yy946;
-  yy966:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy965;
-    goto yy946;
-  yy967:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy965;
-    goto yy946;
-  yy968:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0x8F)
-      goto yy965;
-    goto yy946;
-  yy969:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0x9F)
-      goto yy963;
-    goto yy946;
-  yy970:
-    ++p;
-  yy971 : { return (bufsize_t)(p - start); }
-  yy972:
-    yyaccept = 2;
-    marker = ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy961;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '\\') {
-        if (yych <= 0x00)
-          goto yy971;
-        if (yych <= '\'')
-          goto yy970;
-        goto yy959;
-      } else {
-        if (yych <= 0xC1)
-          goto yy971;
-        if (yych <= 0xDF)
-          goto yy963;
-        goto yy964;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy969;
-        goto yy965;
-      } else {
-        if (yych <= 0xF0)
-          goto yy966;
-        if (yych <= 0xF3)
-          goto yy967;
-        if (yych <= 0xF4)
-          goto yy968;
-        goto yy971;
-      }
-    }
-  yy973:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy975;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '\\') {
-        if (yych <= 0x00)
-          goto yy946;
-        if (yych <= '"')
-          goto yy986;
-        goto yy973;
-      } else {
-        if (yych <= 0xC1)
-          goto yy946;
-        if (yych <= 0xDF)
-          goto yy977;
-        goto yy978;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy983;
-        goto yy979;
-      } else {
-        if (yych <= 0xF0)
-          goto yy980;
-        if (yych <= 0xF3)
-          goto yy981;
-        if (yych <= 0xF4)
-          goto yy982;
-        goto yy946;
-      }
-    }
-  yy975:
-    ++p;
-    yych = *p;
-  yy976:
-    if (yybm[0 + yych] & 128) {
-      goto yy975;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '\\') {
-        if (yych <= 0x00)
-          goto yy946;
-        if (yych <= '"')
-          goto yy984;
-        goto yy973;
-      } else {
-        if (yych <= 0xC1)
-          goto yy946;
-        if (yych >= 0xE0)
-          goto yy978;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy983;
-        goto yy979;
-      } else {
-        if (yych <= 0xF0)
-          goto yy980;
-        if (yych <= 0xF3)
-          goto yy981;
-        if (yych <= 0xF4)
-          goto yy982;
-        goto yy946;
-      }
-    }
-  yy977:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy975;
-    goto yy946;
-  yy978:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy977;
-    goto yy946;
-  yy979:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy977;
-    goto yy946;
-  yy980:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy979;
-    goto yy946;
-  yy981:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0xBF)
-      goto yy979;
-    goto yy946;
-  yy982:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0x8F)
-      goto yy979;
-    goto yy946;
-  yy983:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy946;
-    if (yych <= 0x9F)
-      goto yy977;
-    goto yy946;
-  yy984:
-    ++p;
-  yy985 : { return (bufsize_t)(p - start); }
-  yy986:
-    yyaccept = 3;
-    marker = ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy975;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '\\') {
-        if (yych <= 0x00)
-          goto yy985;
-        if (yych <= '"')
-          goto yy984;
-        goto yy973;
-      } else {
-        if (yych <= 0xC1)
-          goto yy985;
-        if (yych <= 0xDF)
-          goto yy977;
-        goto yy978;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy983;
-        goto yy979;
-      } else {
-        if (yych <= 0xF0)
-          goto yy980;
-        if (yych <= 0xF3)
-          goto yy981;
-        if (yych <= 0xF4)
-          goto yy982;
-        goto yy985;
-      }
-    }
-  }
-}
-
-// 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 (yych <= 0x08)
-      goto yy989;
-    if (yych <= '\r')
-      goto yy991;
-    if (yych == ' ')
-      goto yy991;
-  yy989:
-    ++p;
-    { return 0; }
-  yy991:
-    ++p;
-    yych = *p;
-    goto yy994;
-  yy992 : { return (bufsize_t)(p - start); }
-  yy993:
-    ++p;
-    yych = *p;
-  yy994:
-    if (yybm[0 + yych] & 128) {
-      goto yy993;
-    }
-    goto yy992;
-  }
-}
-
-// 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 yy999;
-    ++p;
-  yy998 : { return 0; }
-  yy999:
-    yych = *(marker = ++p);
-    if (yybm[0 + yych] & 128) {
-      goto yy1002;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy998;
-      if (yych >= '\v')
-        goto yy998;
-    } else {
-      if (yych <= '\r')
-        goto yy1000;
-      if (yych == '#')
-        goto yy1004;
-      goto yy998;
-    }
-  yy1000:
-    ++p;
-  yy1001 : { return (bufsize_t)(p - start); }
-  yy1002:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1002;
-    }
-    goto yy1001;
-  yy1004:
-    yych = *++p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1002;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1005;
-      if (yych <= '\n')
-        goto yy1000;
-    } else {
-      if (yych <= '\r')
-        goto yy1000;
-      if (yych == '#')
-        goto yy1006;
-    }
-  yy1005:
-    p = marker;
-    goto yy998;
-  yy1006:
-    yych = *++p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1002;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1005;
-      if (yych <= '\n')
-        goto yy1000;
-      goto yy1005;
-    } else {
-      if (yych <= '\r')
-        goto yy1000;
-      if (yych != '#')
-        goto yy1005;
-    }
-    yych = *++p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1002;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1005;
-      if (yych <= '\n')
-        goto yy1000;
-      goto yy1005;
-    } else {
-      if (yych <= '\r')
-        goto yy1000;
-      if (yych != '#')
-        goto yy1005;
-    }
-    yych = *++p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1002;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1005;
-      if (yych <= '\n')
-        goto yy1000;
-      goto yy1005;
-    } else {
-      if (yych <= '\r')
-        goto yy1000;
-      if (yych != '#')
-        goto yy1005;
-    }
-    ++p;
-    if (yybm[0 + (yych = *p)] & 128) {
-      goto yy1002;
-    }
-    if (yych <= 0x08)
-      goto yy1005;
-    if (yych <= '\n')
-      goto yy1000;
-    if (yych == '\r')
-      goto yy1000;
-    goto yy1005;
-  }
-}
-
-// Match setext heading line.  Return 1 for level-1 heading,
-// 2 for level-2, 0 for no match.
-bufsize_t _scan_setext_heading_line(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-
-  {
-    unsigned char yych;
-    static const unsigned char yybm[] = {
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 32, 0,  0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 0,  32, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
-        0, 128, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0,
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
-        0, 0,   0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0,
-    };
-    yych = *p;
-    if (yych == '-')
-      goto yy1014;
-    if (yych == '=')
-      goto yy1015;
-    ++p;
-  yy1013 : { return 0; }
-  yy1014:
-    yych = *(marker = ++p);
-    if (yybm[0 + yych] & 128) {
-      goto yy1027;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1013;
-      if (yych <= '\n')
-        goto yy1024;
-      goto yy1013;
-    } else {
-      if (yych <= '\r')
-        goto yy1024;
-      if (yych == ' ')
-        goto yy1024;
-      goto yy1013;
-    }
-  yy1015:
-    yych = *(marker = ++p);
-    if (yybm[0 + yych] & 64) {
-      goto yy1021;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1013;
-      if (yych <= '\n')
-        goto yy1017;
-      goto yy1013;
-    } else {
-      if (yych <= '\r')
-        goto yy1017;
-      if (yych == ' ')
-        goto yy1017;
-      goto yy1013;
-    }
-  yy1016:
-    ++p;
-    yych = *p;
-  yy1017:
-    if (yybm[0 + yych] & 32) {
-      goto yy1016;
-    }
-    if (yych <= 0x08)
-      goto yy1018;
-    if (yych <= '\n')
-      goto yy1019;
-    if (yych == '\r')
-      goto yy1019;
-  yy1018:
-    p = marker;
-    goto yy1013;
-  yy1019:
-    ++p;
-    { return 1; }
-  yy1021:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 32) {
-      goto yy1016;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1018;
-      if (yych <= '\n')
-        goto yy1019;
-      goto yy1018;
-    } else {
-      if (yych <= '\r')
-        goto yy1019;
-      if (yych == '=')
-        goto yy1021;
-      goto yy1018;
-    }
-  yy1023:
-    ++p;
-    yych = *p;
-  yy1024:
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1018;
-      if (yych <= '\t')
-        goto yy1023;
-      if (yych >= '\v')
-        goto yy1018;
-    } else {
-      if (yych <= '\r')
-        goto yy1025;
-      if (yych == ' ')
-        goto yy1023;
-      goto yy1018;
-    }
-  yy1025:
-    ++p;
-    { return 2; }
-  yy1027:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1027;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1018;
-      if (yych <= '\t')
-        goto yy1023;
-      if (yych <= '\n')
-        goto yy1025;
-      goto yy1018;
-    } else {
-      if (yych <= '\r')
-        goto yy1025;
-      if (yych == ' ')
-        goto yy1023;
-      goto yy1018;
-    }
-  }
-}
-
-// Scan a thematic break line: "...three or more hyphens, asterisks,
-// or underscores on a line by themselves. If you wish, you may use
-// spaces between the hyphens or asterisks."
-bufsize_t _scan_thematic_break(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    static const unsigned char yybm[] = {
-        0, 0, 0,   0, 0, 0,  0, 0, 0, 240, 0, 0, 0,   0, 0, 0,  0, 0, 0, 0,
-        0, 0, 0,   0, 0, 0,  0, 0, 0, 0,   0, 0, 240, 0, 0, 0,  0, 0, 0, 0,
-        0, 0, 128, 0, 0, 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, 32, 0, 0, 0, 0,
-        0, 0, 0,   0, 0, 0,  0, 0, 0, 0,   0, 0, 0,   0, 0, 0,  0, 0, 0, 0,
-        0, 0, 0,   0, 0, 0,  0, 0, 0, 0,   0, 0, 0,   0, 0, 0,  0, 0, 0, 0,
-        0, 0, 0,   0, 0, 0,  0, 0, 0, 0,   0, 0, 0,   0, 0, 0,  0, 0, 0, 0,
-        0, 0, 0,   0, 0, 0,  0, 0, 0, 0,   0, 0, 0,   0, 0, 0,  0, 0, 0, 0,
-        0, 0, 0,   0, 0, 0,  0, 0, 0, 0,   0, 0, 0,   0, 0, 0,  0, 0, 0, 0,
-        0, 0, 0,   0, 0, 0,  0, 0, 0, 0,   0, 0, 0,   0, 0, 0,  0, 0, 0, 0,
-        0, 0, 0,   0, 0, 0,  0, 0, 0, 0,   0, 0, 0,   0, 0, 0,  0, 0, 0, 0,
-        0, 0, 0,   0, 0, 0,  0, 0, 0, 0,   0, 0, 0,   0, 0, 0,
-    };
-    yych = *p;
-    if (yych <= ',') {
-      if (yych == '*')
-        goto yy1033;
-    } else {
-      if (yych <= '-')
-        goto yy1034;
-      if (yych == '_')
-        goto yy1035;
-    }
-    ++p;
-  yy1032 : { return 0; }
-  yy1033:
-    yych = *(marker = ++p);
-    if (yych <= 0x1F) {
-      if (yych == '\t')
-        goto yy1057;
-      goto yy1032;
-    } else {
-      if (yych <= ' ')
-        goto yy1057;
-      if (yych == '*')
-        goto yy1059;
-      goto yy1032;
-    }
-  yy1034:
-    yych = *(marker = ++p);
-    if (yych <= 0x1F) {
-      if (yych == '\t')
-        goto yy1047;
-      goto yy1032;
-    } else {
-      if (yych <= ' ')
-        goto yy1047;
-      if (yych == '-')
-        goto yy1049;
-      goto yy1032;
-    }
-  yy1035:
-    yych = *(marker = ++p);
-    if (yybm[0 + yych] & 16) {
-      goto yy1036;
-    }
-    if (yych == '_')
-      goto yy1039;
-    goto yy1032;
-  yy1036:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 16) {
-      goto yy1036;
-    }
-    if (yych == '_')
-      goto yy1039;
-  yy1038:
-    p = marker;
-    goto yy1032;
-  yy1039:
-    ++p;
-    yych = *p;
-    if (yych <= 0x1F) {
-      if (yych == '\t')
-        goto yy1039;
-      goto yy1038;
-    } else {
-      if (yych <= ' ')
-        goto yy1039;
-      if (yych != '_')
-        goto yy1038;
-    }
-  yy1041:
-    ++p;
-    yych = *p;
-    if (yych <= '\r') {
-      if (yych <= '\t') {
-        if (yych <= 0x08)
-          goto yy1038;
-        goto yy1041;
-      } else {
-        if (yych <= '\n')
-          goto yy1043;
-        if (yych <= '\f')
-          goto yy1038;
-      }
-    } else {
-      if (yych <= ' ') {
-        if (yych <= 0x1F)
-          goto yy1038;
-        goto yy1041;
-      } else {
-        if (yych == '_')
-          goto yy1045;
-        goto yy1038;
-      }
-    }
-  yy1043:
-    ++p;
-    { return (bufsize_t)(p - start); }
-  yy1045:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 32) {
-      goto yy1045;
-    }
-    if (yych <= 0x08)
-      goto yy1038;
-    if (yych <= '\n')
-      goto yy1043;
-    if (yych == '\r')
-      goto yy1043;
-    goto yy1038;
-  yy1047:
-    ++p;
-    yych = *p;
-    if (yych <= 0x1F) {
-      if (yych == '\t')
-        goto yy1047;
-      goto yy1038;
-    } else {
-      if (yych <= ' ')
-        goto yy1047;
-      if (yych != '-')
-        goto yy1038;
-    }
-  yy1049:
-    ++p;
-    yych = *p;
-    if (yych <= 0x1F) {
-      if (yych == '\t')
-        goto yy1049;
-      goto yy1038;
-    } else {
-      if (yych <= ' ')
-        goto yy1049;
-      if (yych != '-')
-        goto yy1038;
-    }
-  yy1051:
-    ++p;
-    yych = *p;
-    if (yych <= '\r') {
-      if (yych <= '\t') {
-        if (yych <= 0x08)
-          goto yy1038;
-        goto yy1051;
-      } else {
-        if (yych <= '\n')
-          goto yy1053;
-        if (yych <= '\f')
-          goto yy1038;
-      }
-    } else {
-      if (yych <= ' ') {
-        if (yych <= 0x1F)
-          goto yy1038;
-        goto yy1051;
-      } else {
-        if (yych == '-')
-          goto yy1055;
-        goto yy1038;
-      }
-    }
-  yy1053:
-    ++p;
-    { return (bufsize_t)(p - start); }
-  yy1055:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy1055;
-    }
-    if (yych <= 0x08)
-      goto yy1038;
-    if (yych <= '\n')
-      goto yy1053;
-    if (yych == '\r')
-      goto yy1053;
-    goto yy1038;
-  yy1057:
-    ++p;
-    yych = *p;
-    if (yych <= 0x1F) {
-      if (yych == '\t')
-        goto yy1057;
-      goto yy1038;
-    } else {
-      if (yych <= ' ')
-        goto yy1057;
-      if (yych != '*')
-        goto yy1038;
-    }
-  yy1059:
-    ++p;
-    yych = *p;
-    if (yych <= 0x1F) {
-      if (yych == '\t')
-        goto yy1059;
-      goto yy1038;
-    } else {
-      if (yych <= ' ')
-        goto yy1059;
-      if (yych != '*')
-        goto yy1038;
-    }
-  yy1061:
-    ++p;
-    yych = *p;
-    if (yych <= '\r') {
-      if (yych <= '\t') {
-        if (yych <= 0x08)
-          goto yy1038;
-        goto yy1061;
-      } else {
-        if (yych <= '\n')
-          goto yy1063;
-        if (yych <= '\f')
-          goto yy1038;
-      }
-    } else {
-      if (yych <= ' ') {
-        if (yych <= 0x1F)
-          goto yy1038;
-        goto yy1061;
-      } else {
-        if (yych == '*')
-          goto yy1065;
-        goto yy1038;
-      }
-    }
-  yy1063:
-    ++p;
-    { return (bufsize_t)(p - start); }
-  yy1065:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1065;
-    }
-    if (yych <= 0x08)
-      goto yy1038;
-    if (yych <= '\n')
-      goto yy1063;
-    if (yych == '\r')
-      goto yy1063;
-    goto yy1038;
-  }
-}
-
-// 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,   160, 160, 160, 160, 160, 160, 160, 160, 160, 0,   160, 160, 0,
-        160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 96,  160,
-        160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
-        144, 160, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,
-    };
-    yych = *p;
-    if (yych == '`')
-      goto yy1071;
-    if (yych == '~')
-      goto yy1072;
-    ++p;
-  yy1070 : { return 0; }
-  yy1071:
-    yych = *(marker = ++p);
-    if (yych == '`')
-      goto yy1088;
-    goto yy1070;
-  yy1072:
-    yych = *(marker = ++p);
-    if (yych != '~')
-      goto yy1070;
-    yych = *++p;
-    if (yybm[0 + yych] & 16) {
-      goto yy1075;
-    }
-  yy1074:
-    p = marker;
-    goto yy1070;
-  yy1075:
-    ++p;
-    yych = *p;
-    marker = p;
-    if (yybm[0 + yych] & 32) {
-      goto yy1077;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '~') {
-        if (yych <= 0x00)
-          goto yy1074;
-        if (yych <= '\r')
-          goto yy1086;
-        goto yy1075;
-      } else {
-        if (yych <= 0xC1)
-          goto yy1074;
-        if (yych <= 0xDF)
-          goto yy1079;
-        goto yy1080;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy1085;
-        goto yy1081;
-      } else {
-        if (yych <= 0xF0)
-          goto yy1082;
-        if (yych <= 0xF3)
-          goto yy1083;
-        if (yych <= 0xF4)
-          goto yy1084;
-        goto yy1074;
-      }
-    }
-  yy1077:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 32) {
-      goto yy1077;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy1074;
-        if (yych <= '\r')
-          goto yy1086;
-        goto yy1074;
-      } else {
-        if (yych <= 0xDF)
-          goto yy1079;
-        if (yych <= 0xE0)
-          goto yy1080;
-        goto yy1081;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy1085;
-        if (yych <= 0xEF)
-          goto yy1081;
-        goto yy1082;
-      } else {
-        if (yych <= 0xF3)
-          goto yy1083;
-        if (yych <= 0xF4)
-          goto yy1084;
-        goto yy1074;
-      }
-    }
-  yy1079:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy1074;
-    if (yych <= 0xBF)
-      goto yy1077;
-    goto yy1074;
-  yy1080:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy1074;
-    if (yych <= 0xBF)
-      goto yy1079;
-    goto yy1074;
-  yy1081:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy1074;
-    if (yych <= 0xBF)
-      goto yy1079;
-    goto yy1074;
-  yy1082:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy1074;
-    if (yych <= 0xBF)
-      goto yy1081;
-    goto yy1074;
-  yy1083:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy1074;
-    if (yych <= 0xBF)
-      goto yy1081;
-    goto yy1074;
-  yy1084:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy1074;
-    if (yych <= 0x8F)
-      goto yy1081;
-    goto yy1074;
-  yy1085:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy1074;
-    if (yych <= 0x9F)
-      goto yy1079;
-    goto yy1074;
-  yy1086:
-    ++p;
-    p = marker;
-    { return (bufsize_t)(p - start); }
-  yy1088:
-    yych = *++p;
-    if (yybm[0 + yych] & 64) {
-      goto yy1089;
-    }
-    goto yy1074;
-  yy1089:
-    ++p;
-    yych = *p;
-    marker = p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1091;
-    }
-    if (yych <= 0xE0) {
-      if (yych <= '`') {
-        if (yych <= 0x00)
-          goto yy1074;
-        if (yych <= '\r')
-          goto yy1100;
-        goto yy1089;
-      } else {
-        if (yych <= 0xC1)
-          goto yy1074;
-        if (yych <= 0xDF)
-          goto yy1093;
-        goto yy1094;
-      }
-    } else {
-      if (yych <= 0xEF) {
-        if (yych == 0xED)
-          goto yy1099;
-        goto yy1095;
-      } else {
-        if (yych <= 0xF0)
-          goto yy1096;
-        if (yych <= 0xF3)
-          goto yy1097;
-        if (yych <= 0xF4)
-          goto yy1098;
-        goto yy1074;
-      }
-    }
-  yy1091:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1091;
-    }
-    if (yych <= 0xEC) {
-      if (yych <= 0xC1) {
-        if (yych <= 0x00)
-          goto yy1074;
-        if (yych <= '\r')
-          goto yy1100;
-        goto yy1074;
-      } else {
-        if (yych <= 0xDF)
-          goto yy1093;
-        if (yych <= 0xE0)
-          goto yy1094;
-        goto yy1095;
-      }
-    } else {
-      if (yych <= 0xF0) {
-        if (yych <= 0xED)
-          goto yy1099;
-        if (yych <= 0xEF)
-          goto yy1095;
-        goto yy1096;
-      } else {
-        if (yych <= 0xF3)
-          goto yy1097;
-        if (yych <= 0xF4)
-          goto yy1098;
-        goto yy1074;
-      }
-    }
-  yy1093:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy1074;
-    if (yych <= 0xBF)
-      goto yy1091;
-    goto yy1074;
-  yy1094:
-    ++p;
-    yych = *p;
-    if (yych <= 0x9F)
-      goto yy1074;
-    if (yych <= 0xBF)
-      goto yy1093;
-    goto yy1074;
-  yy1095:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy1074;
-    if (yych <= 0xBF)
-      goto yy1093;
-    goto yy1074;
-  yy1096:
-    ++p;
-    yych = *p;
-    if (yych <= 0x8F)
-      goto yy1074;
-    if (yych <= 0xBF)
-      goto yy1095;
-    goto yy1074;
-  yy1097:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy1074;
-    if (yych <= 0xBF)
-      goto yy1095;
-    goto yy1074;
-  yy1098:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy1074;
-    if (yych <= 0x8F)
-      goto yy1095;
-    goto yy1074;
-  yy1099:
-    ++p;
-    yych = *p;
-    if (yych <= 0x7F)
-      goto yy1074;
-    if (yych <= 0x9F)
-      goto yy1093;
-    goto yy1074;
-  yy1100:
-    ++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,   64, 0,  0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,   0,  64, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,   0,  0,  0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,   0,  0,  0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 128, 0,  0,  0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,   0,  0,  0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,   0,  0,  0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,   0,  0,  0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,   0,  0,  0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,   0,  0,  0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,   0,  0,  0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,   0,  0,  0, 0, 0,
-    };
-    yych = *p;
-    if (yych == '`')
-      goto yy1106;
-    if (yych == '~')
-      goto yy1107;
-    ++p;
-  yy1105 : { return 0; }
-  yy1106:
-    yych = *(marker = ++p);
-    if (yych == '`')
-      goto yy1116;
-    goto yy1105;
-  yy1107:
-    yych = *(marker = ++p);
-    if (yych != '~')
-      goto yy1105;
-    yych = *++p;
-    if (yybm[0 + yych] & 32) {
-      goto yy1110;
-    }
-  yy1109:
-    p = marker;
-    goto yy1105;
-  yy1110:
-    ++p;
-    yych = *p;
-    marker = p;
-    if (yybm[0 + yych] & 64) {
-      goto yy1112;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1109;
-      if (yych <= '\n')
-        goto yy1114;
-      goto yy1109;
-    } else {
-      if (yych <= '\r')
-        goto yy1114;
-      if (yych == '~')
-        goto yy1110;
-      goto yy1109;
-    }
-  yy1112:
-    ++p;
-    yych = *p;
-    if (yybm[0 + yych] & 64) {
-      goto yy1112;
-    }
-    if (yych <= 0x08)
-      goto yy1109;
-    if (yych <= '\n')
-      goto yy1114;
-    if (yych != '\r')
-      goto yy1109;
-  yy1114:
-    ++p;
-    p = marker;
-    { return (bufsize_t)(p - start); }
-  yy1116:
-    yych = *++p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1117;
-    }
-    goto yy1109;
-  yy1117:
-    ++p;
-    yych = *p;
-    marker = p;
-    if (yybm[0 + yych] & 128) {
-      goto yy1117;
-    }
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1109;
-      if (yych <= '\t')
-        goto yy1119;
-      if (yych <= '\n')
-        goto yy1121;
-      goto yy1109;
-    } else {
-      if (yych <= '\r')
-        goto yy1121;
-      if (yych != ' ')
-        goto yy1109;
-    }
-  yy1119:
-    ++p;
-    yych = *p;
-    if (yych <= '\f') {
-      if (yych <= 0x08)
-        goto yy1109;
-      if (yych <= '\t')
-        goto yy1119;
-      if (yych >= '\v')
-        goto yy1109;
-    } else {
-      if (yych <= '\r')
-        goto yy1121;
-      if (yych == ' ')
-        goto yy1119;
-      goto yy1109;
-    }
-  yy1121:
-    ++p;
-    p = marker;
-    { return (bufsize_t)(p - start); }
-  }
-}
-
-// Scans an entity.
-// Returns number of chars matched.
-bufsize_t _scan_entity(const unsigned char *p) {
-  const unsigned char *marker = NULL;
-  const unsigned char *start = p;
-
-  {
-    unsigned char yych;
-    yych = *p;
-    if (yych == '&')
-      goto yy1127;
-    ++p;
-  yy1126 : { return 0; }
-  yy1127:
-    yych = *(marker = ++p);
-    if (yych <= '@') {
-      if (yych != '#')
-        goto yy1126;
-    } else {
-      if (yych <= 'Z')
-        goto yy1130;
-      if (yych <= '`')
-        goto yy1126;
-      if (yych <= 'z')
-        goto yy1130;
-      goto yy1126;
-    }
-    yych = *++p;
-    if (yych <= 'W') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1165;
-    } else {
-      if (yych <= 'X')
-        goto yy1164;
-      if (yych == 'x')
-        goto yy1164;
-    }
-  yy1129:
-    p = marker;
-    goto yy1126;
-  yy1130:
-    yych = *++p;
-    if (yych <= '@') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych >= ':')
-        goto yy1129;
-    } else {
-      if (yych <= 'Z')
-        goto yy1131;
-      if (yych <= '`')
-        goto yy1129;
-      if (yych >= '{')
-        goto yy1129;
-    }
-  yy1131:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1134;
-      if (yych <= ':')
-        goto yy1129;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-        goto yy1134;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych <= 'z')
-          goto yy1134;
-        goto yy1129;
-      }
-    }
-  yy1132:
-    ++p;
-    { return (bufsize_t)(p - start); }
-  yy1134:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1135;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1135:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1136;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1136:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1137;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1137:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1138;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1138:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1139;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1139:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1140;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1140:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1141;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1141:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1142;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1142:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1143;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1143:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1144;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1144:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1145;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1145:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1146;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1146:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1147;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1147:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1148;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1148:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1149;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1149:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1150;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1150:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1151;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1151:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1152;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1152:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1153;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1153:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1154;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1154:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1155;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1155:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1156;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1156:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1157;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1157:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1158;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1158:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1159;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1159:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1160;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1160:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1161;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1161:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1162;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1162:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1163;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'Z') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= '{')
-          goto yy1129;
-      }
-    }
-  yy1163:
-    yych = *++p;
-    if (yych == ';')
-      goto yy1132;
-    goto yy1129;
-  yy1164:
-    yych = *++p;
-    if (yych <= '@') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1172;
-      goto yy1129;
-    } else {
-      if (yych <= 'F')
-        goto yy1172;
-      if (yych <= '`')
-        goto yy1129;
-      if (yych <= 'f')
-        goto yy1172;
-      goto yy1129;
-    }
-  yy1165:
-    yych = *++p;
-    if (yych <= '/')
-      goto yy1129;
-    if (yych <= '9')
-      goto yy1166;
-    if (yych == ';')
-      goto yy1132;
-    goto yy1129;
-  yy1166:
-    yych = *++p;
-    if (yych <= '/')
-      goto yy1129;
-    if (yych <= '9')
-      goto yy1167;
-    if (yych == ';')
-      goto yy1132;
-    goto yy1129;
-  yy1167:
-    yych = *++p;
-    if (yych <= '/')
-      goto yy1129;
-    if (yych <= '9')
-      goto yy1168;
-    if (yych == ';')
-      goto yy1132;
-    goto yy1129;
-  yy1168:
-    yych = *++p;
-    if (yych <= '/')
-      goto yy1129;
-    if (yych <= '9')
-      goto yy1169;
-    if (yych == ';')
-      goto yy1132;
-    goto yy1129;
-  yy1169:
-    yych = *++p;
-    if (yych <= '/')
-      goto yy1129;
-    if (yych <= '9')
-      goto yy1170;
-    if (yych == ';')
-      goto yy1132;
-    goto yy1129;
-  yy1170:
-    yych = *++p;
-    if (yych <= '/')
-      goto yy1129;
-    if (yych <= '9')
-      goto yy1171;
-    if (yych == ';')
-      goto yy1132;
-    goto yy1129;
-  yy1171:
-    yych = *++p;
-    if (yych <= '/')
-      goto yy1129;
-    if (yych <= '9')
-      goto yy1163;
-    if (yych == ';')
-      goto yy1132;
-    goto yy1129;
-  yy1172:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1173;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'F') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= 'g')
-          goto yy1129;
-      }
-    }
-  yy1173:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1174;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'F') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= 'g')
-          goto yy1129;
-      }
-    }
-  yy1174:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1175;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'F') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= 'g')
-          goto yy1129;
-      }
-    }
-  yy1175:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1176;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'F') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= 'g')
-          goto yy1129;
-      }
-    }
-  yy1176:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1177;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'F') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= 'g')
-          goto yy1129;
-      }
-    }
-  yy1177:
-    yych = *++p;
-    if (yych <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1178;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'F') {
-        if (yych <= '@')
-          goto yy1129;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych >= 'g')
-          goto yy1129;
-      }
-    }
-  yy1178:
-    ++p;
-    if ((yych = *p) <= ';') {
-      if (yych <= '/')
-        goto yy1129;
-      if (yych <= '9')
-        goto yy1163;
-      if (yych <= ':')
-        goto yy1129;
-      goto yy1132;
-    } else {
-      if (yych <= 'F') {
-        if (yych <= '@')
-          goto yy1129;
-        goto yy1163;
-      } else {
-        if (yych <= '`')
-          goto yy1129;
-        if (yych <= 'f')
-          goto yy1163;
-        goto yy1129;
-      }
-    }
-  }
-}
-
-// 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 yy1183;
-        if (yych >= 'F')
-          goto yy1184;
-      } else {
-        if (yych == 'J')
-          goto yy1185;
-        if (yych >= 'V')
-          goto yy1186;
-      }
-    } else {
-      if (yych <= 'f') {
-        if (yych == 'd')
-          goto yy1183;
-        if (yych >= 'f')
-          goto yy1184;
-      } else {
-        if (yych <= 'j') {
-          if (yych >= 'j')
-            goto yy1185;
-        } else {
-          if (yych == 'v')
-            goto yy1186;
-        }
-      }
-    }
-    ++p;
-  yy1182 : { return 0; }
-  yy1183:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych == 'A')
-      goto yy1209;
-    if (yych == 'a')
-      goto yy1209;
-    goto yy1182;
-  yy1184:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych == 'I')
-      goto yy1206;
-    if (yych == 'i')
-      goto yy1206;
-    goto yy1182;
-  yy1185:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych == 'A')
-      goto yy1197;
-    if (yych == 'a')
-      goto yy1197;
-    goto yy1182;
-  yy1186:
-    yyaccept = 0;
-    yych = *(marker = ++p);
-    if (yych == 'B')
-      goto yy1187;
-    if (yych != 'b')
-      goto yy1182;
-  yy1187:
-    yych = *++p;
-    if (yych == 'S')
-      goto yy1189;
-    if (yych == 's')
-      goto yy1189;
-  yy1188:
-    p = marker;
-    if (yyaccept == 0) {
-      goto yy1182;
-    } else {
-      goto yy1196;
-    }
-  yy1189:
-    yych = *++p;
-    if (yych == 'C')
-      goto yy1190;
-    if (yych != 'c')
-      goto yy1188;
-  yy1190:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy1191;
-    if (yych != 'r')
-      goto yy1188;
-  yy1191:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy1192;
-    if (yych != 'i')
-      goto yy1188;
-  yy1192:
-    yych = *++p;
-    if (yych == 'P')
-      goto yy1193;
-    if (yych != 'p')
-      goto yy1188;
-  yy1193:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy1194;
-    if (yych != 't')
-      goto yy1188;
-  yy1194:
-    yych = *++p;
-    if (yych != ':')
-      goto yy1188;
-  yy1195:
-    ++p;
-  yy1196 : { return (bufsize_t)(p - start); }
-  yy1197:
-    yych = *++p;
-    if (yych == 'V')
-      goto yy1198;
-    if (yych != 'v')
-      goto yy1188;
-  yy1198:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy1199;
-    if (yych != 'a')
-      goto yy1188;
-  yy1199:
-    yych = *++p;
-    if (yych == 'S')
-      goto yy1200;
-    if (yych != 's')
-      goto yy1188;
-  yy1200:
-    yych = *++p;
-    if (yych == 'C')
-      goto yy1201;
-    if (yych != 'c')
-      goto yy1188;
-  yy1201:
-    yych = *++p;
-    if (yych == 'R')
-      goto yy1202;
-    if (yych != 'r')
-      goto yy1188;
-  yy1202:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy1203;
-    if (yych != 'i')
-      goto yy1188;
-  yy1203:
-    yych = *++p;
-    if (yych == 'P')
-      goto yy1204;
-    if (yych != 'p')
-      goto yy1188;
-  yy1204:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy1205;
-    if (yych != 't')
-      goto yy1188;
-  yy1205:
-    yych = *++p;
-    if (yych == ':')
-      goto yy1195;
-    goto yy1188;
-  yy1206:
-    yych = *++p;
-    if (yych == 'L')
-      goto yy1207;
-    if (yych != 'l')
-      goto yy1188;
-  yy1207:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy1208;
-    if (yych != 'e')
-      goto yy1188;
-  yy1208:
-    yych = *++p;
-    if (yych == ':')
-      goto yy1195;
-    goto yy1188;
-  yy1209:
-    yych = *++p;
-    if (yych == 'T')
-      goto yy1210;
-    if (yych != 't')
-      goto yy1188;
-  yy1210:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy1211;
-    if (yych != 'a')
-      goto yy1188;
-  yy1211:
-    yych = *++p;
-    if (yych != ':')
-      goto yy1188;
-    yyaccept = 1;
-    yych = *(marker = ++p);
-    if (yych == 'I')
-      goto yy1213;
-    if (yych != 'i')
-      goto yy1196;
-  yy1213:
-    yych = *++p;
-    if (yych == 'M')
-      goto yy1214;
-    if (yych != 'm')
-      goto yy1188;
-  yy1214:
-    yych = *++p;
-    if (yych == 'A')
-      goto yy1215;
-    if (yych != 'a')
-      goto yy1188;
-  yy1215:
-    yych = *++p;
-    if (yych == 'G')
-      goto yy1216;
-    if (yych != 'g')
-      goto yy1188;
-  yy1216:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy1217;
-    if (yych != 'e')
-      goto yy1188;
-  yy1217:
-    yych = *++p;
-    if (yych != '/')
-      goto yy1188;
-    yych = *++p;
-    if (yych <= 'W') {
-      if (yych <= 'J') {
-        if (yych == 'G')
-          goto yy1220;
-        if (yych <= 'I')
-          goto yy1188;
-        goto yy1221;
-      } else {
-        if (yych == 'P')
-          goto yy1219;
-        if (yych <= 'V')
-          goto yy1188;
-        goto yy1222;
-      }
-    } else {
-      if (yych <= 'j') {
-        if (yych == 'g')
-          goto yy1220;
-        if (yych <= 'i')
-          goto yy1188;
-        goto yy1221;
-      } else {
-        if (yych <= 'p') {
-          if (yych <= 'o')
-            goto yy1188;
-        } else {
-          if (yych == 'w')
-            goto yy1222;
-          goto yy1188;
-        }
-      }
-    }
-  yy1219:
-    yych = *++p;
-    if (yych == 'N')
-      goto yy1230;
-    if (yych == 'n')
-      goto yy1230;
-    goto yy1188;
-  yy1220:
-    yych = *++p;
-    if (yych == 'I')
-      goto yy1229;
-    if (yych == 'i')
-      goto yy1229;
-    goto yy1188;
-  yy1221:
-    yych = *++p;
-    if (yych == 'P')
-      goto yy1227;
-    if (yych == 'p')
-      goto yy1227;
-    goto yy1188;
-  yy1222:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy1223;
-    if (yych != 'e')
-      goto yy1188;
-  yy1223:
-    yych = *++p;
-    if (yych == 'B')
-      goto yy1224;
-    if (yych != 'b')
-      goto yy1188;
-  yy1224:
-    yych = *++p;
-    if (yych == 'P')
-      goto yy1225;
-    if (yych != 'p')
-      goto yy1188;
-  yy1225:
-    ++p;
-    { return 0; }
-  yy1227:
-    yych = *++p;
-    if (yych == 'E')
-      goto yy1228;
-    if (yych != 'e')
-      goto yy1188;
-  yy1228:
-    yych = *++p;
-    if (yych == 'G')
-      goto yy1225;
-    if (yych == 'g')
-      goto yy1225;
-    goto yy1188;
-  yy1229:
-    yych = *++p;
-    if (yych == 'F')
-      goto yy1225;
-    if (yych == 'f')
-      goto yy1225;
-    goto yy1188;
-  yy1230:
-    ++p;
-    if ((yych = *p) == 'G')
-      goto yy1225;
-    if (yych == 'g')
-      goto yy1225;
-    goto yy1188;
-  }
+/* Generated by re2c 1.0.3 */
+#include <stdlib.h>
+#include "chunk.h"
+#include "scanners.h"
+
+bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, bufsize_t offset)
+{
+	bufsize_t res;
+	unsigned char *ptr = (unsigned char *)c->data;
+
+        if (ptr == NULL || offset > c->len) {
+          return 0;
+        } else {
+	  unsigned char lim = ptr[c->len];
+
+	  ptr[c->len] = '\0';
+	  res = scanner(ptr + offset);
+	  ptr[c->len] = lim;
+        }
+
+	return res;
+}
+
+
+
+// Try to match a scheme including colon.
+bufsize_t _scan_scheme(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	yych = *p;
+	if (yych <= '@') goto yy2;
+	if (yych <= 'Z') goto yy4;
+	if (yych <= '`') goto yy2;
+	if (yych <= 'z') goto yy4;
+yy2:
+	++p;
+yy3:
+	{ return 0; }
+yy4:
+	yych = *(marker = ++p);
+	if (yych <= '/') {
+		if (yych <= '+') {
+			if (yych <= '*') goto yy3;
+		} else {
+			if (yych <= ',') goto yy3;
+			if (yych >= '/') goto yy3;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '9') goto yy5;
+			if (yych <= '@') goto yy3;
+		} else {
+			if (yych <= '`') goto yy3;
+			if (yych >= '{') goto yy3;
+		}
+	}
+yy5:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych == '+') goto yy7;
+		} else {
+			if (yych != '/') goto yy7;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych >= 'A') goto yy7;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych <= 'z') goto yy7;
+		}
+	}
+yy6:
+	p = marker;
+	goto yy3;
+yy7:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych == '+') goto yy10;
+			goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+			goto yy10;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+			goto yy10;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych <= 'z') goto yy10;
+			goto yy6;
+		}
+	}
+yy8:
+	++p;
+	{ return (bufsize_t)(p - start); }
+yy10:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy6;
+		} else {
+			if (yych == '/') goto yy6;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy8;
+			if (yych <= '@') goto yy6;
+		} else {
+			if (yych <= '`') goto yy6;
+			if (yych >= '{') goto yy6;
+		}
+	}
+	yych = *++p;
+	if (yych == ':') goto yy8;
+	goto yy6;
+}
+
+}
+
+// Try to match URI autolink after first <, returning number of chars matched.
+bufsize_t _scan_autolink_uri(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	static const unsigned char yybm[] = {
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128,   0, 128,   0, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych <= '@') goto yy41;
+	if (yych <= 'Z') goto yy43;
+	if (yych <= '`') goto yy41;
+	if (yych <= 'z') goto yy43;
+yy41:
+	++p;
+yy42:
+	{ return 0; }
+yy43:
+	yych = *(marker = ++p);
+	if (yych <= '/') {
+		if (yych <= '+') {
+			if (yych <= '*') goto yy42;
+		} else {
+			if (yych <= ',') goto yy42;
+			if (yych >= '/') goto yy42;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '9') goto yy44;
+			if (yych <= '@') goto yy42;
+		} else {
+			if (yych <= '`') goto yy42;
+			if (yych >= '{') goto yy42;
+		}
+	}
+yy44:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych == '+') goto yy46;
+		} else {
+			if (yych != '/') goto yy46;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych >= 'A') goto yy46;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych <= 'z') goto yy46;
+		}
+	}
+yy45:
+	p = marker;
+	goto yy42;
+yy46:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych == '+') goto yy49;
+			goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+			goto yy49;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+			goto yy49;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych <= 'z') goto yy49;
+			goto yy45;
+		}
+	}
+yy47:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy47;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '<') goto yy45;
+			if (yych <= '>') goto yy50;
+			goto yy45;
+		} else {
+			if (yych <= 0xDF) goto yy52;
+			if (yych <= 0xE0) goto yy53;
+			goto yy54;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy55;
+			if (yych <= 0xEF) goto yy54;
+			goto yy56;
+		} else {
+			if (yych <= 0xF3) goto yy57;
+			if (yych <= 0xF4) goto yy58;
+			goto yy45;
+		}
+	}
+yy49:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych == '+') goto yy59;
+			goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+			goto yy59;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+			goto yy59;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych <= 'z') goto yy59;
+			goto yy45;
+		}
+	}
+yy50:
+	++p;
+	{ return (bufsize_t)(p - start); }
+yy52:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy45;
+	if (yych <= 0xBF) goto yy47;
+	goto yy45;
+yy53:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy45;
+	if (yych <= 0xBF) goto yy52;
+	goto yy45;
+yy54:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy45;
+	if (yych <= 0xBF) goto yy52;
+	goto yy45;
+yy55:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy45;
+	if (yych <= 0x9F) goto yy52;
+	goto yy45;
+yy56:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy45;
+	if (yych <= 0xBF) goto yy54;
+	goto yy45;
+yy57:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy45;
+	if (yych <= 0xBF) goto yy54;
+	goto yy45;
+yy58:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy45;
+	if (yych <= 0x8F) goto yy54;
+	goto yy45;
+yy59:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych <= ',') {
+			if (yych != '+') goto yy45;
+		} else {
+			if (yych == '/') goto yy45;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= ':') goto yy47;
+			if (yych <= '@') goto yy45;
+		} else {
+			if (yych <= '`') goto yy45;
+			if (yych >= '{') goto yy45;
+		}
+	}
+	yych = *++p;
+	if (yych == ':') goto yy47;
+	goto yy45;
+}
+
+}
+
+// Try to match email autolink after first <, returning num of chars matched.
+bufsize_t _scan_autolink_email(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	static const unsigned char yybm[] = {
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0, 128,   0, 128, 128, 128, 128, 128, 
+		  0,   0, 128, 128,   0, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128,   0,   0,   0, 128,   0, 128, 
+		  0, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128,   0,   0,   0, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych <= '9') {
+		if (yych <= '\'') {
+			if (yych == '!') goto yy91;
+			if (yych >= '#') goto yy91;
+		} else {
+			if (yych <= ')') goto yy89;
+			if (yych != ',') goto yy91;
+		}
+	} else {
+		if (yych <= '?') {
+			if (yych == '=') goto yy91;
+			if (yych >= '?') goto yy91;
+		} else {
+			if (yych <= 'Z') {
+				if (yych >= 'A') goto yy91;
+			} else {
+				if (yych <= ']') goto yy89;
+				if (yych <= '~') goto yy91;
+			}
+		}
+	}
+yy89:
+	++p;
+yy90:
+	{ return 0; }
+yy91:
+	yych = *(marker = ++p);
+	if (yych <= ',') {
+		if (yych <= '"') {
+			if (yych == '!') goto yy93;
+			goto yy90;
+		} else {
+			if (yych <= '\'') goto yy93;
+			if (yych <= ')') goto yy90;
+			if (yych <= '+') goto yy93;
+			goto yy90;
+		}
+	} else {
+		if (yych <= '>') {
+			if (yych <= '9') goto yy93;
+			if (yych == '=') goto yy93;
+			goto yy90;
+		} else {
+			if (yych <= 'Z') goto yy93;
+			if (yych <= ']') goto yy90;
+			if (yych <= '~') goto yy93;
+			goto yy90;
+		}
+	}
+yy92:
+	yych = *++p;
+yy93:
+	if (yybm[0+yych] & 128) {
+		goto yy92;
+	}
+	if (yych <= '>') goto yy94;
+	if (yych <= '@') goto yy95;
+yy94:
+	p = marker;
+	goto yy90;
+yy95:
+	yych = *++p;
+	if (yych <= '@') {
+		if (yych <= '/') goto yy94;
+		if (yych >= ':') goto yy94;
+	} else {
+		if (yych <= 'Z') goto yy96;
+		if (yych <= '`') goto yy94;
+		if (yych >= '{') goto yy94;
+	}
+yy96:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy98;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy98;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy98;
+			goto yy94;
+		}
+	}
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy101;
+		if (yych <= '/') goto yy94;
+		goto yy102;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy102;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy102;
+			goto yy94;
+		}
+	}
+yy98:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych <= '-') goto yy101;
+			goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy102;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy102;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy102;
+			goto yy94;
+		}
+	}
+yy99:
+	++p;
+	{ return (bufsize_t)(p - start); }
+yy101:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy103;
+		if (yych <= '/') goto yy94;
+		goto yy104;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy104;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy104;
+			goto yy94;
+		}
+	}
+yy102:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy104;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy104;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy104;
+			goto yy94;
+		}
+	}
+yy103:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy105;
+		if (yych <= '/') goto yy94;
+		goto yy106;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy106;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy106;
+			goto yy94;
+		}
+	}
+yy104:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy106;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy106;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy106;
+			goto yy94;
+		}
+	}
+yy105:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy107;
+		if (yych <= '/') goto yy94;
+		goto yy108;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy108;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy108;
+			goto yy94;
+		}
+	}
+yy106:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy108;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy108;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy108;
+			goto yy94;
+		}
+	}
+yy107:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy109;
+		if (yych <= '/') goto yy94;
+		goto yy110;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy110;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy110;
+			goto yy94;
+		}
+	}
+yy108:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy110;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy110;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy110;
+			goto yy94;
+		}
+	}
+yy109:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy111;
+		if (yych <= '/') goto yy94;
+		goto yy112;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy112;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy112;
+			goto yy94;
+		}
+	}
+yy110:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy112;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy112;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy112;
+			goto yy94;
+		}
+	}
+yy111:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy113;
+		if (yych <= '/') goto yy94;
+		goto yy114;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy114;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy114;
+			goto yy94;
+		}
+	}
+yy112:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy114;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy114;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy114;
+			goto yy94;
+		}
+	}
+yy113:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy115;
+		if (yych <= '/') goto yy94;
+		goto yy116;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy116;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy116;
+			goto yy94;
+		}
+	}
+yy114:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy116;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy116;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy116;
+			goto yy94;
+		}
+	}
+yy115:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy117;
+		if (yych <= '/') goto yy94;
+		goto yy118;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy118;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy118;
+			goto yy94;
+		}
+	}
+yy116:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy118;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy118;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy118;
+			goto yy94;
+		}
+	}
+yy117:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy119;
+		if (yych <= '/') goto yy94;
+		goto yy120;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy120;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy120;
+			goto yy94;
+		}
+	}
+yy118:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy120;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy120;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy120;
+			goto yy94;
+		}
+	}
+yy119:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy121;
+		if (yych <= '/') goto yy94;
+		goto yy122;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy122;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy122;
+			goto yy94;
+		}
+	}
+yy120:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy122;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy122;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy122;
+			goto yy94;
+		}
+	}
+yy121:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy123;
+		if (yych <= '/') goto yy94;
+		goto yy124;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy124;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy124;
+			goto yy94;
+		}
+	}
+yy122:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy124;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy124;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy124;
+			goto yy94;
+		}
+	}
+yy123:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy125;
+		if (yych <= '/') goto yy94;
+		goto yy126;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy126;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy126;
+			goto yy94;
+		}
+	}
+yy124:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy126;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy126;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy126;
+			goto yy94;
+		}
+	}
+yy125:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy127;
+		if (yych <= '/') goto yy94;
+		goto yy128;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy128;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy128;
+			goto yy94;
+		}
+	}
+yy126:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy128;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy128;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy128;
+			goto yy94;
+		}
+	}
+yy127:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy129;
+		if (yych <= '/') goto yy94;
+		goto yy130;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy130;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy130;
+			goto yy94;
+		}
+	}
+yy128:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy130;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy130;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy130;
+			goto yy94;
+		}
+	}
+yy129:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy131;
+		if (yych <= '/') goto yy94;
+		goto yy132;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy132;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy132;
+			goto yy94;
+		}
+	}
+yy130:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy132;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy132;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy132;
+			goto yy94;
+		}
+	}
+yy131:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy133;
+		if (yych <= '/') goto yy94;
+		goto yy134;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy134;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy134;
+			goto yy94;
+		}
+	}
+yy132:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy134;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy134;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy134;
+			goto yy94;
+		}
+	}
+yy133:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy135;
+		if (yych <= '/') goto yy94;
+		goto yy136;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy136;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy136;
+			goto yy94;
+		}
+	}
+yy134:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy136;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy136;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy136;
+			goto yy94;
+		}
+	}
+yy135:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy137;
+		if (yych <= '/') goto yy94;
+		goto yy138;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy138;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy138;
+			goto yy94;
+		}
+	}
+yy136:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy138;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy138;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy138;
+			goto yy94;
+		}
+	}
+yy137:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy139;
+		if (yych <= '/') goto yy94;
+		goto yy140;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy140;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy140;
+			goto yy94;
+		}
+	}
+yy138:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy140;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy140;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy140;
+			goto yy94;
+		}
+	}
+yy139:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy141;
+		if (yych <= '/') goto yy94;
+		goto yy142;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy142;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy142;
+			goto yy94;
+		}
+	}
+yy140:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy142;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy142;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy142;
+			goto yy94;
+		}
+	}
+yy141:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy143;
+		if (yych <= '/') goto yy94;
+		goto yy144;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy144;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy144;
+			goto yy94;
+		}
+	}
+yy142:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy144;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy144;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy144;
+			goto yy94;
+		}
+	}
+yy143:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy145;
+		if (yych <= '/') goto yy94;
+		goto yy146;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy146;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy146;
+			goto yy94;
+		}
+	}
+yy144:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy146;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy146;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy146;
+			goto yy94;
+		}
+	}
+yy145:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy147;
+		if (yych <= '/') goto yy94;
+		goto yy148;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy148;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy148;
+			goto yy94;
+		}
+	}
+yy146:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy148;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy148;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy148;
+			goto yy94;
+		}
+	}
+yy147:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy149;
+		if (yych <= '/') goto yy94;
+		goto yy150;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy150;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy150;
+			goto yy94;
+		}
+	}
+yy148:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy150;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy150;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy150;
+			goto yy94;
+		}
+	}
+yy149:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy151;
+		if (yych <= '/') goto yy94;
+		goto yy152;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy152;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy152;
+			goto yy94;
+		}
+	}
+yy150:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy152;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy152;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy152;
+			goto yy94;
+		}
+	}
+yy151:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy153;
+		if (yych <= '/') goto yy94;
+		goto yy154;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy154;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy154;
+			goto yy94;
+		}
+	}
+yy152:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy154;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy154;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy154;
+			goto yy94;
+		}
+	}
+yy153:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy155;
+		if (yych <= '/') goto yy94;
+		goto yy156;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy156;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy156;
+			goto yy94;
+		}
+	}
+yy154:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy156;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy156;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy156;
+			goto yy94;
+		}
+	}
+yy155:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy157;
+		if (yych <= '/') goto yy94;
+		goto yy158;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy158;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy158;
+			goto yy94;
+		}
+	}
+yy156:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy158;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy158;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy158;
+			goto yy94;
+		}
+	}
+yy157:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy159;
+		if (yych <= '/') goto yy94;
+		goto yy160;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy160;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy160;
+			goto yy94;
+		}
+	}
+yy158:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy160;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy160;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy160;
+			goto yy94;
+		}
+	}
+yy159:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy161;
+		if (yych <= '/') goto yy94;
+		goto yy162;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy162;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy162;
+			goto yy94;
+		}
+	}
+yy160:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy162;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy162;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy162;
+			goto yy94;
+		}
+	}
+yy161:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy163;
+		if (yych <= '/') goto yy94;
+		goto yy164;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy164;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy164;
+			goto yy94;
+		}
+	}
+yy162:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy164;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy164;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy164;
+			goto yy94;
+		}
+	}
+yy163:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy165;
+		if (yych <= '/') goto yy94;
+		goto yy166;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy166;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy166;
+			goto yy94;
+		}
+	}
+yy164:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy166;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy166;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy166;
+			goto yy94;
+		}
+	}
+yy165:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy167;
+		if (yych <= '/') goto yy94;
+		goto yy168;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy168;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy168;
+			goto yy94;
+		}
+	}
+yy166:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy168;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy168;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy168;
+			goto yy94;
+		}
+	}
+yy167:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy169;
+		if (yych <= '/') goto yy94;
+		goto yy170;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy170;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy170;
+			goto yy94;
+		}
+	}
+yy168:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy170;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy170;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy170;
+			goto yy94;
+		}
+	}
+yy169:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy171;
+		if (yych <= '/') goto yy94;
+		goto yy172;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy172;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy172;
+			goto yy94;
+		}
+	}
+yy170:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy172;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy172;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy172;
+			goto yy94;
+		}
+	}
+yy171:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy173;
+		if (yych <= '/') goto yy94;
+		goto yy174;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy174;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy174;
+			goto yy94;
+		}
+	}
+yy172:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy174;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy174;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy174;
+			goto yy94;
+		}
+	}
+yy173:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy175;
+		if (yych <= '/') goto yy94;
+		goto yy176;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy176;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy176;
+			goto yy94;
+		}
+	}
+yy174:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy176;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy176;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy176;
+			goto yy94;
+		}
+	}
+yy175:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy177;
+		if (yych <= '/') goto yy94;
+		goto yy178;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy178;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy178;
+			goto yy94;
+		}
+	}
+yy176:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy178;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy178;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy178;
+			goto yy94;
+		}
+	}
+yy177:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy179;
+		if (yych <= '/') goto yy94;
+		goto yy180;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy180;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy180;
+			goto yy94;
+		}
+	}
+yy178:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy180;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy180;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy180;
+			goto yy94;
+		}
+	}
+yy179:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy181;
+		if (yych <= '/') goto yy94;
+		goto yy182;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy182;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy182;
+			goto yy94;
+		}
+	}
+yy180:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy182;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy182;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy182;
+			goto yy94;
+		}
+	}
+yy181:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy183;
+		if (yych <= '/') goto yy94;
+		goto yy184;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy184;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy184;
+			goto yy94;
+		}
+	}
+yy182:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy184;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy184;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy184;
+			goto yy94;
+		}
+	}
+yy183:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy185;
+		if (yych <= '/') goto yy94;
+		goto yy186;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy186;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy186;
+			goto yy94;
+		}
+	}
+yy184:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy186;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy186;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy186;
+			goto yy94;
+		}
+	}
+yy185:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy187;
+		if (yych <= '/') goto yy94;
+		goto yy188;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy188;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy188;
+			goto yy94;
+		}
+	}
+yy186:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy188;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy188;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy188;
+			goto yy94;
+		}
+	}
+yy187:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy189;
+		if (yych <= '/') goto yy94;
+		goto yy190;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy190;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy190;
+			goto yy94;
+		}
+	}
+yy188:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy190;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy190;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy190;
+			goto yy94;
+		}
+	}
+yy189:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy191;
+		if (yych <= '/') goto yy94;
+		goto yy192;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy192;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy192;
+			goto yy94;
+		}
+	}
+yy190:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy192;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy192;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy192;
+			goto yy94;
+		}
+	}
+yy191:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy193;
+		if (yych <= '/') goto yy94;
+		goto yy194;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy194;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy194;
+			goto yy94;
+		}
+	}
+yy192:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy194;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy194;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy194;
+			goto yy94;
+		}
+	}
+yy193:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy195;
+		if (yych <= '/') goto yy94;
+		goto yy196;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy196;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy196;
+			goto yy94;
+		}
+	}
+yy194:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy196;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy196;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy196;
+			goto yy94;
+		}
+	}
+yy195:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy197;
+		if (yych <= '/') goto yy94;
+		goto yy198;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy198;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy198;
+			goto yy94;
+		}
+	}
+yy196:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy198;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy198;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy198;
+			goto yy94;
+		}
+	}
+yy197:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy199;
+		if (yych <= '/') goto yy94;
+		goto yy200;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy200;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy200;
+			goto yy94;
+		}
+	}
+yy198:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy200;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy200;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy200;
+			goto yy94;
+		}
+	}
+yy199:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy201;
+		if (yych <= '/') goto yy94;
+		goto yy202;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy202;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy202;
+			goto yy94;
+		}
+	}
+yy200:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy202;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy202;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy202;
+			goto yy94;
+		}
+	}
+yy201:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy203;
+		if (yych <= '/') goto yy94;
+		goto yy204;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy204;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy204;
+			goto yy94;
+		}
+	}
+yy202:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy204;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy204;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy204;
+			goto yy94;
+		}
+	}
+yy203:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy205;
+		if (yych <= '/') goto yy94;
+		goto yy206;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy206;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy206;
+			goto yy94;
+		}
+	}
+yy204:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy206;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy206;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy206;
+			goto yy94;
+		}
+	}
+yy205:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy207;
+		if (yych <= '/') goto yy94;
+		goto yy208;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy208;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy208;
+			goto yy94;
+		}
+	}
+yy206:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy208;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy208;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy208;
+			goto yy94;
+		}
+	}
+yy207:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy209;
+		if (yych <= '/') goto yy94;
+		goto yy210;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy210;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy210;
+			goto yy94;
+		}
+	}
+yy208:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy210;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy210;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy210;
+			goto yy94;
+		}
+	}
+yy209:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy211;
+		if (yych <= '/') goto yy94;
+		goto yy212;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy212;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy212;
+			goto yy94;
+		}
+	}
+yy210:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy212;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy212;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy212;
+			goto yy94;
+		}
+	}
+yy211:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy213;
+		if (yych <= '/') goto yy94;
+		goto yy214;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy214;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy214;
+			goto yy94;
+		}
+	}
+yy212:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy214;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy214;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy214;
+			goto yy94;
+		}
+	}
+yy213:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy215;
+		if (yych <= '/') goto yy94;
+		goto yy216;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy216;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy216;
+			goto yy94;
+		}
+	}
+yy214:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy216;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy216;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy216;
+			goto yy94;
+		}
+	}
+yy215:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy217;
+		if (yych <= '/') goto yy94;
+		goto yy218;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy218;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy218;
+			goto yy94;
+		}
+	}
+yy216:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy218;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy218;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy218;
+			goto yy94;
+		}
+	}
+yy217:
+	yych = *++p;
+	if (yych <= '9') {
+		if (yych == '-') goto yy219;
+		if (yych <= '/') goto yy94;
+		goto yy220;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy94;
+			goto yy220;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy220;
+			goto yy94;
+		}
+	}
+yy218:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= ',') goto yy94;
+			if (yych >= '.') goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych <= '9') goto yy220;
+			goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+			goto yy220;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych <= 'z') goto yy220;
+			goto yy94;
+		}
+	}
+yy219:
+	yych = *++p;
+	if (yych <= '@') {
+		if (yych <= '/') goto yy94;
+		if (yych <= '9') goto yy221;
+		goto yy94;
+	} else {
+		if (yych <= 'Z') goto yy221;
+		if (yych <= '`') goto yy94;
+		if (yych <= 'z') goto yy221;
+		goto yy94;
+	}
+yy220:
+	yych = *++p;
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych <= '-') goto yy94;
+			goto yy95;
+		} else {
+			if (yych <= '/') goto yy94;
+			if (yych >= ':') goto yy94;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy99;
+			if (yych <= '@') goto yy94;
+		} else {
+			if (yych <= '`') goto yy94;
+			if (yych >= '{') goto yy94;
+		}
+	}
+yy221:
+	yych = *++p;
+	if (yych == '.') goto yy95;
+	if (yych == '>') goto yy99;
+	goto yy94;
+}
+
+}
+
+// Try to match an HTML tag after first <, returning num of chars matched.
+bufsize_t _scan_html_tag(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	static const unsigned char yybm[] = {
+		/* table 1 .. 8: 0 */
+		  0, 250, 250, 250, 250, 250, 250, 250, 
+		250, 235, 235, 235, 235, 235, 250, 250, 
+		250, 250, 250, 250, 250, 250, 250, 250, 
+		250, 250, 250, 250, 250, 250, 250, 250, 
+		235, 250, 202, 250, 250, 250, 250, 170, 
+		250, 250, 250, 250, 250, 246, 254, 250, 
+		254, 254, 254, 254, 254, 254, 254, 254, 
+		254, 254, 254, 250, 234, 234, 232, 250, 
+		250, 254, 254, 254, 254, 254, 254, 254, 
+		254, 254, 254, 254, 254, 254, 254, 254, 
+		254, 254, 254, 254, 254, 254, 254, 254, 
+		254, 254, 254, 250, 250, 122, 250, 254, 
+		234, 254, 254, 254, 254, 254, 254, 254, 
+		254, 254, 254, 254, 254, 254, 254, 254, 
+		254, 254, 254, 254, 254, 254, 254, 254, 
+		254, 254, 254, 250, 250, 250, 250, 250, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		/* table 9 .. 11: 256 */
+		  0, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 192, 128, 128, 
+		192, 192, 192, 192, 192, 192, 192, 192, 
+		192, 192, 128, 128, 128, 128, 128,   0, 
+		128, 224, 224, 224, 224, 224, 224, 224, 
+		224, 224, 224, 224, 224, 224, 224, 224, 
+		224, 224, 224, 224, 224, 224, 224, 224, 
+		224, 224, 224, 128, 128, 128, 128, 128, 
+		128, 192, 192, 192, 192, 192, 192, 192, 
+		192, 192, 192, 192, 192, 192, 192, 192, 
+		192, 192, 192, 192, 192, 192, 192, 192, 
+		192, 192, 192, 128, 128, 128, 128, 128, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych <= '>') {
+		if (yych <= '!') {
+			if (yych >= '!') goto yy226;
+		} else {
+			if (yych == '/') goto yy227;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '?') goto yy228;
+			if (yych >= 'A') goto yy229;
+		} else {
+			if (yych <= '`') goto yy224;
+			if (yych <= 'z') goto yy229;
+		}
+	}
+yy224:
+	++p;
+yy225:
+	{ return 0; }
+yy226:
+	yych = *(marker = ++p);
+	if (yybm[256+yych] & 32) {
+		goto yy232;
+	}
+	if (yych == '-') goto yy230;
+	if (yych <= '@') goto yy225;
+	if (yych <= '[') goto yy234;
+	goto yy225;
+yy227:
+	yych = *(marker = ++p);
+	if (yych <= '@') goto yy225;
+	if (yych <= 'Z') goto yy235;
+	if (yych <= '`') goto yy225;
+	if (yych <= 'z') goto yy235;
+	goto yy225;
+yy228:
+	yych = *(marker = ++p);
+	if (yych <= 0x00) goto yy225;
+	if (yych <= 0x7F) goto yy238;
+	if (yych <= 0xC1) goto yy225;
+	if (yych <= 0xF4) goto yy238;
+	goto yy225;
+yy229:
+	yych = *(marker = ++p);
+	if (yych <= '.') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy225;
+			if (yych <= '\r') goto yy250;
+			goto yy225;
+		} else {
+			if (yych <= ' ') goto yy250;
+			if (yych == '-') goto yy250;
+			goto yy225;
+		}
+	} else {
+		if (yych <= '@') {
+			if (yych <= '9') goto yy250;
+			if (yych == '>') goto yy250;
+			goto yy225;
+		} else {
+			if (yych <= 'Z') goto yy250;
+			if (yych <= '`') goto yy225;
+			if (yych <= 'z') goto yy250;
+			goto yy225;
+		}
+	}
+yy230:
+	yych = *++p;
+	if (yych == '-') goto yy254;
+yy231:
+	p = marker;
+	goto yy225;
+yy232:
+	yych = *++p;
+	if (yybm[256+yych] & 32) {
+		goto yy232;
+	}
+	if (yych <= 0x08) goto yy231;
+	if (yych <= '\r') goto yy255;
+	if (yych == ' ') goto yy255;
+	goto yy231;
+yy234:
+	yych = *++p;
+	if (yych == 'C') goto yy257;
+	if (yych == 'c') goto yy257;
+	goto yy231;
+yy235:
+	yych = *++p;
+	if (yybm[256+yych] & 64) {
+		goto yy235;
+	}
+	if (yych <= 0x1F) {
+		if (yych <= 0x08) goto yy231;
+		if (yych <= '\r') goto yy258;
+		goto yy231;
+	} else {
+		if (yych <= ' ') goto yy258;
+		if (yych == '>') goto yy252;
+		goto yy231;
+	}
+yy237:
+	yych = *++p;
+yy238:
+	if (yybm[256+yych] & 128) {
+		goto yy237;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy231;
+			if (yych >= '@') goto yy231;
+		} else {
+			if (yych <= 0xDF) goto yy240;
+			if (yych <= 0xE0) goto yy241;
+			goto yy242;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy243;
+			if (yych <= 0xEF) goto yy242;
+			goto yy244;
+		} else {
+			if (yych <= 0xF3) goto yy245;
+			if (yych <= 0xF4) goto yy246;
+			goto yy231;
+		}
+	}
+	yych = *++p;
+	if (yych <= 0xE0) {
+		if (yych <= '>') {
+			if (yych <= 0x00) goto yy231;
+			if (yych <= '=') goto yy237;
+			goto yy252;
+		} else {
+			if (yych <= 0x7F) goto yy237;
+			if (yych <= 0xC1) goto yy231;
+			if (yych >= 0xE0) goto yy241;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy243;
+			goto yy242;
+		} else {
+			if (yych <= 0xF0) goto yy244;
+			if (yych <= 0xF3) goto yy245;
+			if (yych <= 0xF4) goto yy246;
+			goto yy231;
+		}
+	}
+yy240:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy237;
+	goto yy231;
+yy241:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy231;
+	if (yych <= 0xBF) goto yy240;
+	goto yy231;
+yy242:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy240;
+	goto yy231;
+yy243:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x9F) goto yy240;
+	goto yy231;
+yy244:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy231;
+	if (yych <= 0xBF) goto yy242;
+	goto yy231;
+yy245:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy242;
+	goto yy231;
+yy246:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x8F) goto yy242;
+	goto yy231;
+yy247:
+	yych = *++p;
+	if (yybm[0+yych] & 1) {
+		goto yy247;
+	}
+	if (yych <= '>') {
+		if (yych <= '9') {
+			if (yych == '/') goto yy251;
+			goto yy231;
+		} else {
+			if (yych <= ':') goto yy260;
+			if (yych <= '=') goto yy231;
+			goto yy252;
+		}
+	} else {
+		if (yych <= '^') {
+			if (yych <= '@') goto yy231;
+			if (yych <= 'Z') goto yy260;
+			goto yy231;
+		} else {
+			if (yych == '`') goto yy231;
+			if (yych <= 'z') goto yy260;
+			goto yy231;
+		}
+	}
+yy249:
+	yych = *++p;
+yy250:
+	if (yybm[0+yych] & 1) {
+		goto yy247;
+	}
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych == '-') goto yy249;
+			goto yy231;
+		} else {
+			if (yych <= '/') goto yy251;
+			if (yych <= '9') goto yy249;
+			goto yy231;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy252;
+			if (yych <= '@') goto yy231;
+			goto yy249;
+		} else {
+			if (yych <= '`') goto yy231;
+			if (yych <= 'z') goto yy249;
+			goto yy231;
+		}
+	}
+yy251:
+	yych = *++p;
+	if (yych != '>') goto yy231;
+yy252:
+	++p;
+	{ return (bufsize_t)(p - start); }
+yy254:
+	yych = *++p;
+	if (yych == '-') goto yy264;
+	if (yych == '>') goto yy231;
+	goto yy263;
+yy255:
+	yych = *++p;
+	if (yybm[0+yych] & 2) {
+		goto yy255;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy231;
+			if (yych <= '>') goto yy252;
+			goto yy231;
+		} else {
+			if (yych <= 0xDF) goto yy272;
+			if (yych <= 0xE0) goto yy273;
+			goto yy274;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy275;
+			if (yych <= 0xEF) goto yy274;
+			goto yy276;
+		} else {
+			if (yych <= 0xF3) goto yy277;
+			if (yych <= 0xF4) goto yy278;
+			goto yy231;
+		}
+	}
+yy257:
+	yych = *++p;
+	if (yych == 'D') goto yy279;
+	if (yych == 'd') goto yy279;
+	goto yy231;
+yy258:
+	yych = *++p;
+	if (yych <= 0x1F) {
+		if (yych <= 0x08) goto yy231;
+		if (yych <= '\r') goto yy258;
+		goto yy231;
+	} else {
+		if (yych <= ' ') goto yy258;
+		if (yych == '>') goto yy252;
+		goto yy231;
+	}
+yy260:
+	yych = *++p;
+	if (yybm[0+yych] & 4) {
+		goto yy260;
+	}
+	if (yych <= ',') {
+		if (yych <= '\r') {
+			if (yych <= 0x08) goto yy231;
+			goto yy280;
+		} else {
+			if (yych == ' ') goto yy280;
+			goto yy231;
+		}
+	} else {
+		if (yych <= '<') {
+			if (yych <= '/') goto yy251;
+			goto yy231;
+		} else {
+			if (yych <= '=') goto yy282;
+			if (yych <= '>') goto yy252;
+			goto yy231;
+		}
+	}
+yy262:
+	yych = *++p;
+yy263:
+	if (yybm[0+yych] & 8) {
+		goto yy262;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy231;
+			if (yych <= '-') goto yy284;
+			goto yy231;
+		} else {
+			if (yych <= 0xDF) goto yy265;
+			if (yych <= 0xE0) goto yy266;
+			goto yy267;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy268;
+			if (yych <= 0xEF) goto yy267;
+			goto yy269;
+		} else {
+			if (yych <= 0xF3) goto yy270;
+			if (yych <= 0xF4) goto yy271;
+			goto yy231;
+		}
+	}
+yy264:
+	yych = *++p;
+	if (yych == '-') goto yy251;
+	if (yych == '>') goto yy231;
+	goto yy263;
+yy265:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy262;
+	goto yy231;
+yy266:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy231;
+	if (yych <= 0xBF) goto yy265;
+	goto yy231;
+yy267:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy265;
+	goto yy231;
+yy268:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x9F) goto yy265;
+	goto yy231;
+yy269:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy231;
+	if (yych <= 0xBF) goto yy267;
+	goto yy231;
+yy270:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy267;
+	goto yy231;
+yy271:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x8F) goto yy267;
+	goto yy231;
+yy272:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy255;
+	goto yy231;
+yy273:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy231;
+	if (yych <= 0xBF) goto yy272;
+	goto yy231;
+yy274:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy272;
+	goto yy231;
+yy275:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x9F) goto yy272;
+	goto yy231;
+yy276:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy231;
+	if (yych <= 0xBF) goto yy274;
+	goto yy231;
+yy277:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy274;
+	goto yy231;
+yy278:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x8F) goto yy274;
+	goto yy231;
+yy279:
+	yych = *++p;
+	if (yych == 'A') goto yy285;
+	if (yych == 'a') goto yy285;
+	goto yy231;
+yy280:
+	yych = *++p;
+	if (yych <= '<') {
+		if (yych <= ' ') {
+			if (yych <= 0x08) goto yy231;
+			if (yych <= '\r') goto yy280;
+			if (yych <= 0x1F) goto yy231;
+			goto yy280;
+		} else {
+			if (yych <= '/') {
+				if (yych <= '.') goto yy231;
+				goto yy251;
+			} else {
+				if (yych == ':') goto yy260;
+				goto yy231;
+			}
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '=') goto yy282;
+			if (yych <= '>') goto yy252;
+			if (yych <= '@') goto yy231;
+			goto yy260;
+		} else {
+			if (yych <= '_') {
+				if (yych <= '^') goto yy231;
+				goto yy260;
+			} else {
+				if (yych <= '`') goto yy231;
+				if (yych <= 'z') goto yy260;
+				goto yy231;
+			}
+		}
+	}
+yy282:
+	yych = *++p;
+	if (yybm[0+yych] & 16) {
+		goto yy286;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '"') {
+			if (yych <= 0x00) goto yy231;
+			if (yych <= ' ') goto yy282;
+			goto yy288;
+		} else {
+			if (yych <= '\'') goto yy290;
+			if (yych <= 0xC1) goto yy231;
+			if (yych <= 0xDF) goto yy292;
+			goto yy293;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy295;
+			goto yy294;
+		} else {
+			if (yych <= 0xF0) goto yy296;
+			if (yych <= 0xF3) goto yy297;
+			if (yych <= 0xF4) goto yy298;
+			goto yy231;
+		}
+	}
+yy284:
+	yych = *++p;
+	if (yybm[0+yych] & 8) {
+		goto yy262;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy231;
+			if (yych <= '-') goto yy251;
+			goto yy231;
+		} else {
+			if (yych <= 0xDF) goto yy265;
+			if (yych <= 0xE0) goto yy266;
+			goto yy267;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy268;
+			if (yych <= 0xEF) goto yy267;
+			goto yy269;
+		} else {
+			if (yych <= 0xF3) goto yy270;
+			if (yych <= 0xF4) goto yy271;
+			goto yy231;
+		}
+	}
+yy285:
+	yych = *++p;
+	if (yych == 'T') goto yy299;
+	if (yych == 't') goto yy299;
+	goto yy231;
+yy286:
+	yych = *++p;
+	if (yybm[0+yych] & 16) {
+		goto yy286;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '=') {
+			if (yych <= 0x00) goto yy231;
+			if (yych <= ' ') goto yy247;
+			goto yy231;
+		} else {
+			if (yych <= '>') goto yy252;
+			if (yych <= 0xC1) goto yy231;
+			if (yych <= 0xDF) goto yy292;
+			goto yy293;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy295;
+			goto yy294;
+		} else {
+			if (yych <= 0xF0) goto yy296;
+			if (yych <= 0xF3) goto yy297;
+			if (yych <= 0xF4) goto yy298;
+			goto yy231;
+		}
+	}
+yy288:
+	yych = *++p;
+	if (yybm[0+yych] & 32) {
+		goto yy288;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy231;
+			if (yych <= '"') goto yy300;
+			goto yy231;
+		} else {
+			if (yych <= 0xDF) goto yy301;
+			if (yych <= 0xE0) goto yy302;
+			goto yy303;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy304;
+			if (yych <= 0xEF) goto yy303;
+			goto yy305;
+		} else {
+			if (yych <= 0xF3) goto yy306;
+			if (yych <= 0xF4) goto yy307;
+			goto yy231;
+		}
+	}
+yy290:
+	yych = *++p;
+	if (yybm[0+yych] & 64) {
+		goto yy290;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy231;
+			if (yych <= '\'') goto yy300;
+			goto yy231;
+		} else {
+			if (yych <= 0xDF) goto yy308;
+			if (yych <= 0xE0) goto yy309;
+			goto yy310;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy311;
+			if (yych <= 0xEF) goto yy310;
+			goto yy312;
+		} else {
+			if (yych <= 0xF3) goto yy313;
+			if (yych <= 0xF4) goto yy314;
+			goto yy231;
+		}
+	}
+yy292:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy286;
+	goto yy231;
+yy293:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy231;
+	if (yych <= 0xBF) goto yy292;
+	goto yy231;
+yy294:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy292;
+	goto yy231;
+yy295:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x9F) goto yy292;
+	goto yy231;
+yy296:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy231;
+	if (yych <= 0xBF) goto yy294;
+	goto yy231;
+yy297:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy294;
+	goto yy231;
+yy298:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x8F) goto yy294;
+	goto yy231;
+yy299:
+	yych = *++p;
+	if (yych == 'A') goto yy315;
+	if (yych == 'a') goto yy315;
+	goto yy231;
+yy300:
+	yych = *++p;
+	if (yybm[0+yych] & 1) {
+		goto yy247;
+	}
+	if (yych == '/') goto yy251;
+	if (yych == '>') goto yy252;
+	goto yy231;
+yy301:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy288;
+	goto yy231;
+yy302:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy231;
+	if (yych <= 0xBF) goto yy301;
+	goto yy231;
+yy303:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy301;
+	goto yy231;
+yy304:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x9F) goto yy301;
+	goto yy231;
+yy305:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy231;
+	if (yych <= 0xBF) goto yy303;
+	goto yy231;
+yy306:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy303;
+	goto yy231;
+yy307:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x8F) goto yy303;
+	goto yy231;
+yy308:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy290;
+	goto yy231;
+yy309:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy231;
+	if (yych <= 0xBF) goto yy308;
+	goto yy231;
+yy310:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy308;
+	goto yy231;
+yy311:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x9F) goto yy308;
+	goto yy231;
+yy312:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy231;
+	if (yych <= 0xBF) goto yy310;
+	goto yy231;
+yy313:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy310;
+	goto yy231;
+yy314:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x8F) goto yy310;
+	goto yy231;
+yy315:
+	yych = *++p;
+	if (yych != '[') goto yy231;
+yy316:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy316;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy231;
+			if (yych >= '^') goto yy231;
+		} else {
+			if (yych <= 0xDF) goto yy319;
+			if (yych <= 0xE0) goto yy320;
+			goto yy321;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy322;
+			if (yych <= 0xEF) goto yy321;
+			goto yy323;
+		} else {
+			if (yych <= 0xF3) goto yy324;
+			if (yych <= 0xF4) goto yy325;
+			goto yy231;
+		}
+	}
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy316;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy231;
+			if (yych <= ']') goto yy326;
+			goto yy231;
+		} else {
+			if (yych <= 0xDF) goto yy319;
+			if (yych <= 0xE0) goto yy320;
+			goto yy321;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy322;
+			if (yych <= 0xEF) goto yy321;
+			goto yy323;
+		} else {
+			if (yych <= 0xF3) goto yy324;
+			if (yych <= 0xF4) goto yy325;
+			goto yy231;
+		}
+	}
+yy319:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy316;
+	goto yy231;
+yy320:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy231;
+	if (yych <= 0xBF) goto yy319;
+	goto yy231;
+yy321:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy319;
+	goto yy231;
+yy322:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x9F) goto yy319;
+	goto yy231;
+yy323:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy231;
+	if (yych <= 0xBF) goto yy321;
+	goto yy231;
+yy324:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0xBF) goto yy321;
+	goto yy231;
+yy325:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy231;
+	if (yych <= 0x8F) goto yy321;
+	goto yy231;
+yy326:
+	yych = *++p;
+	if (yych <= 0xE0) {
+		if (yych <= '>') {
+			if (yych <= 0x00) goto yy231;
+			if (yych <= '=') goto yy316;
+			goto yy252;
+		} else {
+			if (yych <= 0x7F) goto yy316;
+			if (yych <= 0xC1) goto yy231;
+			if (yych <= 0xDF) goto yy319;
+			goto yy320;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy322;
+			goto yy321;
+		} else {
+			if (yych <= 0xF0) goto yy323;
+			if (yych <= 0xF3) goto yy324;
+			if (yych <= 0xF4) goto yy325;
+			goto yy231;
+		}
+	}
+}
+
+}
+
+// Try to (liberally) match an HTML tag after first <, returning num of chars matched.
+bufsize_t _scan_liberal_html_tag(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	unsigned int yyaccept = 0;
+	static const unsigned char yybm[] = {
+		  0,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,   0,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64, 128,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych <= 0xE0) {
+		if (yych <= '\n') {
+			if (yych <= 0x00) goto yy329;
+			if (yych <= '\t') goto yy331;
+		} else {
+			if (yych <= 0x7F) goto yy331;
+			if (yych <= 0xC1) goto yy329;
+			if (yych <= 0xDF) goto yy332;
+			goto yy333;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy335;
+			goto yy334;
+		} else {
+			if (yych <= 0xF0) goto yy336;
+			if (yych <= 0xF3) goto yy337;
+			if (yych <= 0xF4) goto yy338;
+		}
+	}
+yy329:
+	++p;
+yy330:
+	{ return 0; }
+yy331:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= '\n') {
+		if (yych <= 0x00) goto yy330;
+		if (yych <= '\t') goto yy340;
+		goto yy330;
+	} else {
+		if (yych <= 0x7F) goto yy340;
+		if (yych <= 0xC1) goto yy330;
+		if (yych <= 0xF4) goto yy340;
+		goto yy330;
+	}
+yy332:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy330;
+	if (yych <= 0xBF) goto yy339;
+	goto yy330;
+yy333:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x9F) goto yy330;
+	if (yych <= 0xBF) goto yy345;
+	goto yy330;
+yy334:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy330;
+	if (yych <= 0xBF) goto yy345;
+	goto yy330;
+yy335:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy330;
+	if (yych <= 0x9F) goto yy345;
+	goto yy330;
+yy336:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x8F) goto yy330;
+	if (yych <= 0xBF) goto yy347;
+	goto yy330;
+yy337:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy330;
+	if (yych <= 0xBF) goto yy347;
+	goto yy330;
+yy338:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy330;
+	if (yych <= 0x8F) goto yy347;
+	goto yy330;
+yy339:
+	yych = *++p;
+yy340:
+	if (yybm[0+yych] & 64) {
+		goto yy339;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy341;
+			if (yych <= '>') goto yy342;
+		} else {
+			if (yych <= 0xDF) goto yy345;
+			if (yych <= 0xE0) goto yy346;
+			goto yy347;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy348;
+			if (yych <= 0xEF) goto yy347;
+			goto yy349;
+		} else {
+			if (yych <= 0xF3) goto yy350;
+			if (yych <= 0xF4) goto yy351;
+		}
+	}
+yy341:
+	p = marker;
+	if (yyaccept == 0) {
+		goto yy330;
+	} else {
+		goto yy344;
+	}
+yy342:
+	yyaccept = 1;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 64) {
+		goto yy339;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy344;
+			if (yych <= '>') goto yy342;
+		} else {
+			if (yych <= 0xDF) goto yy345;
+			if (yych <= 0xE0) goto yy346;
+			goto yy347;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy348;
+			if (yych <= 0xEF) goto yy347;
+			goto yy349;
+		} else {
+			if (yych <= 0xF3) goto yy350;
+			if (yych <= 0xF4) goto yy351;
+		}
+	}
+yy344:
+	{ return (bufsize_t)(p - start); }
+yy345:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy341;
+	if (yych <= 0xBF) goto yy339;
+	goto yy341;
+yy346:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy341;
+	if (yych <= 0xBF) goto yy345;
+	goto yy341;
+yy347:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy341;
+	if (yych <= 0xBF) goto yy345;
+	goto yy341;
+yy348:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy341;
+	if (yych <= 0x9F) goto yy345;
+	goto yy341;
+yy349:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy341;
+	if (yych <= 0xBF) goto yy347;
+	goto yy341;
+yy350:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy341;
+	if (yych <= 0xBF) goto yy347;
+	goto yy341;
+yy351:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy341;
+	if (yych <= 0x8F) goto yy347;
+	goto yy341;
+}
+
+}
+
+// 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 yy356;
+	++p;
+yy355:
+	{ return 0; }
+yy356:
+	yych = *(marker = ++p);
+	switch (yych) {
+	case '!':	goto yy357;
+	case '/':	goto yy359;
+	case '?':	goto yy360;
+	case 'A':
+	case 'a':	goto yy362;
+	case 'B':
+	case 'b':	goto yy363;
+	case 'C':
+	case 'c':	goto yy364;
+	case 'D':
+	case 'd':	goto yy365;
+	case 'F':
+	case 'f':	goto yy366;
+	case 'H':
+	case 'h':	goto yy367;
+	case 'I':
+	case 'i':	goto yy368;
+	case 'L':
+	case 'l':	goto yy369;
+	case 'M':
+	case 'm':	goto yy370;
+	case 'N':
+	case 'n':	goto yy371;
+	case 'O':
+	case 'o':	goto yy372;
+	case 'P':
+	case 'p':	goto yy373;
+	case 'S':
+	case 's':	goto yy374;
+	case 'T':
+	case 't':	goto yy375;
+	case 'U':
+	case 'u':	goto yy376;
+	default:	goto yy355;
+	}
+yy357:
+	yych = *++p;
+	if (yych <= '@') {
+		if (yych == '-') goto yy377;
+	} else {
+		if (yych <= 'Z') goto yy378;
+		if (yych <= '[') goto yy380;
+	}
+yy358:
+	p = marker;
+	goto yy355;
+yy359:
+	yych = *++p;
+	switch (yych) {
+	case 'A':
+	case 'a':	goto yy362;
+	case 'B':
+	case 'b':	goto yy363;
+	case 'C':
+	case 'c':	goto yy364;
+	case 'D':
+	case 'd':	goto yy365;
+	case 'F':
+	case 'f':	goto yy366;
+	case 'H':
+	case 'h':	goto yy367;
+	case 'I':
+	case 'i':	goto yy368;
+	case 'L':
+	case 'l':	goto yy369;
+	case 'M':
+	case 'm':	goto yy370;
+	case 'N':
+	case 'n':	goto yy371;
+	case 'O':
+	case 'o':	goto yy372;
+	case 'P':
+	case 'p':	goto yy381;
+	case 'S':
+	case 's':	goto yy382;
+	case 'T':
+	case 't':	goto yy375;
+	case 'U':
+	case 'u':	goto yy376;
+	default:	goto yy358;
+	}
+yy360:
+	++p;
+	{ return 3; }
+yy362:
+	yych = *++p;
+	if (yych <= 'S') {
+		if (yych <= 'D') {
+			if (yych <= 'C') goto yy358;
+			goto yy383;
+		} else {
+			if (yych <= 'Q') goto yy358;
+			if (yych <= 'R') goto yy384;
+			goto yy385;
+		}
+	} else {
+		if (yych <= 'q') {
+			if (yych == 'd') goto yy383;
+			goto yy358;
+		} else {
+			if (yych <= 'r') goto yy384;
+			if (yych <= 's') goto yy385;
+			goto yy358;
+		}
+	}
+yy363:
+	yych = *++p;
+	if (yych <= 'O') {
+		if (yych <= 'K') {
+			if (yych == 'A') goto yy386;
+			goto yy358;
+		} else {
+			if (yych <= 'L') goto yy387;
+			if (yych <= 'N') goto yy358;
+			goto yy388;
+		}
+	} else {
+		if (yych <= 'k') {
+			if (yych == 'a') goto yy386;
+			goto yy358;
+		} else {
+			if (yych <= 'l') goto yy387;
+			if (yych == 'o') goto yy388;
+			goto yy358;
+		}
+	}
+yy364:
+	yych = *++p;
+	if (yych <= 'O') {
+		if (yych <= 'D') {
+			if (yych == 'A') goto yy389;
+			goto yy358;
+		} else {
+			if (yych <= 'E') goto yy390;
+			if (yych <= 'N') goto yy358;
+			goto yy391;
+		}
+	} else {
+		if (yych <= 'd') {
+			if (yych == 'a') goto yy389;
+			goto yy358;
+		} else {
+			if (yych <= 'e') goto yy390;
+			if (yych == 'o') goto yy391;
+			goto yy358;
+		}
+	}
+yy365:
+	yych = *++p;
+	switch (yych) {
+	case 'D':
+	case 'L':
+	case 'T':
+	case 'd':
+	case 'l':
+	case 't':	goto yy392;
+	case 'E':
+	case 'e':	goto yy393;
+	case 'I':
+	case 'i':	goto yy394;
+	default:	goto yy358;
+	}
+yy366:
+	yych = *++p;
+	if (yych <= 'R') {
+		if (yych <= 'N') {
+			if (yych == 'I') goto yy395;
+			goto yy358;
+		} else {
+			if (yych <= 'O') goto yy396;
+			if (yych <= 'Q') goto yy358;
+			goto yy397;
+		}
+	} else {
+		if (yych <= 'n') {
+			if (yych == 'i') goto yy395;
+			goto yy358;
+		} else {
+			if (yych <= 'o') goto yy396;
+			if (yych == 'r') goto yy397;
+			goto yy358;
+		}
+	}
+yy367:
+	yych = *++p;
+	if (yych <= 'S') {
+		if (yych <= 'D') {
+			if (yych <= '0') goto yy358;
+			if (yych <= '6') goto yy392;
+			goto yy358;
+		} else {
+			if (yych <= 'E') goto yy398;
+			if (yych == 'R') goto yy392;
+			goto yy358;
+		}
+	} else {
+		if (yych <= 'q') {
+			if (yych <= 'T') goto yy399;
+			if (yych == 'e') goto yy398;
+			goto yy358;
+		} else {
+			if (yych <= 'r') goto yy392;
+			if (yych == 't') goto yy399;
+			goto yy358;
+		}
+	}
+yy368:
+	yych = *++p;
+	if (yych == 'F') goto yy400;
+	if (yych == 'f') goto yy400;
+	goto yy358;
+yy369:
+	yych = *++p;
+	if (yych <= 'I') {
+		if (yych == 'E') goto yy401;
+		if (yych <= 'H') goto yy358;
+		goto yy402;
+	} else {
+		if (yych <= 'e') {
+			if (yych <= 'd') goto yy358;
+			goto yy401;
+		} else {
+			if (yych == 'i') goto yy402;
+			goto yy358;
+		}
+	}
+yy370:
+	yych = *++p;
+	if (yych <= 'E') {
+		if (yych == 'A') goto yy403;
+		if (yych <= 'D') goto yy358;
+		goto yy404;
+	} else {
+		if (yych <= 'a') {
+			if (yych <= '`') goto yy358;
+			goto yy403;
+		} else {
+			if (yych == 'e') goto yy404;
+			goto yy358;
+		}
+	}
+yy371:
+	yych = *++p;
+	if (yych <= 'O') {
+		if (yych == 'A') goto yy405;
+		if (yych <= 'N') goto yy358;
+		goto yy406;
+	} else {
+		if (yych <= 'a') {
+			if (yych <= '`') goto yy358;
+			goto yy405;
+		} else {
+			if (yych == 'o') goto yy406;
+			goto yy358;
+		}
+	}
+yy372:
+	yych = *++p;
+	if (yych <= 'P') {
+		if (yych == 'L') goto yy392;
+		if (yych <= 'O') goto yy358;
+		goto yy407;
+	} else {
+		if (yych <= 'l') {
+			if (yych <= 'k') goto yy358;
+			goto yy392;
+		} else {
+			if (yych == 'p') goto yy407;
+			goto yy358;
+		}
+	}
+yy373:
+	yych = *++p;
+	if (yych <= '>') {
+		if (yych <= ' ') {
+			if (yych <= 0x08) goto yy358;
+			if (yych <= '\r') goto yy408;
+			if (yych <= 0x1F) goto yy358;
+			goto yy408;
+		} else {
+			if (yych == '/') goto yy410;
+			if (yych <= '=') goto yy358;
+			goto yy408;
+		}
+	} else {
+		if (yych <= 'R') {
+			if (yych == 'A') goto yy411;
+			if (yych <= 'Q') goto yy358;
+			goto yy412;
+		} else {
+			if (yych <= 'a') {
+				if (yych <= '`') goto yy358;
+				goto yy411;
+			} else {
+				if (yych == 'r') goto yy412;
+				goto yy358;
+			}
+		}
+	}
+yy374:
+	yych = *++p;
+	switch (yych) {
+	case 'C':
+	case 'c':	goto yy413;
+	case 'E':
+	case 'e':	goto yy414;
+	case 'O':
+	case 'o':	goto yy415;
+	case 'T':
+	case 't':	goto yy416;
+	case 'U':
+	case 'u':	goto yy417;
+	default:	goto yy358;
+	}
+yy375:
+	yych = *++p;
+	switch (yych) {
+	case 'A':
+	case 'a':	goto yy418;
+	case 'B':
+	case 'b':	goto yy419;
+	case 'D':
+	case 'd':	goto yy392;
+	case 'F':
+	case 'f':	goto yy420;
+	case 'H':
+	case 'h':	goto yy421;
+	case 'I':
+	case 'i':	goto yy422;
+	case 'R':
+	case 'r':	goto yy423;
+	default:	goto yy358;
+	}
+yy376:
+	yych = *++p;
+	if (yych == 'L') goto yy392;
+	if (yych == 'l') goto yy392;
+	goto yy358;
+yy377:
+	yych = *++p;
+	if (yych == '-') goto yy424;
+	goto yy358;
+yy378:
+	++p;
+	{ return 4; }
+yy380:
+	yych = *++p;
+	if (yych == 'C') goto yy426;
+	if (yych == 'c') goto yy426;
+	goto yy358;
+yy381:
+	yych = *++p;
+	if (yych <= '/') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy358;
+			if (yych <= '\r') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= ' ') goto yy408;
+			if (yych <= '.') goto yy358;
+			goto yy410;
+		}
+	} else {
+		if (yych <= '@') {
+			if (yych == '>') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= 'A') goto yy411;
+			if (yych == 'a') goto yy411;
+			goto yy358;
+		}
+	}
+yy382:
+	yych = *++p;
+	if (yych <= 'U') {
+		if (yych <= 'N') {
+			if (yych == 'E') goto yy414;
+			goto yy358;
+		} else {
+			if (yych <= 'O') goto yy415;
+			if (yych <= 'T') goto yy358;
+			goto yy417;
+		}
+	} else {
+		if (yych <= 'n') {
+			if (yych == 'e') goto yy414;
+			goto yy358;
+		} else {
+			if (yych <= 'o') goto yy415;
+			if (yych == 'u') goto yy417;
+			goto yy358;
+		}
+	}
+yy383:
+	yych = *++p;
+	if (yych == 'D') goto yy427;
+	if (yych == 'd') goto yy427;
+	goto yy358;
+yy384:
+	yych = *++p;
+	if (yych == 'T') goto yy428;
+	if (yych == 't') goto yy428;
+	goto yy358;
+yy385:
+	yych = *++p;
+	if (yych == 'I') goto yy429;
+	if (yych == 'i') goto yy429;
+	goto yy358;
+yy386:
+	yych = *++p;
+	if (yych == 'S') goto yy430;
+	if (yych == 's') goto yy430;
+	goto yy358;
+yy387:
+	yych = *++p;
+	if (yych == 'O') goto yy431;
+	if (yych == 'o') goto yy431;
+	goto yy358;
+yy388:
+	yych = *++p;
+	if (yych == 'D') goto yy432;
+	if (yych == 'd') goto yy432;
+	goto yy358;
+yy389:
+	yych = *++p;
+	if (yych == 'P') goto yy433;
+	if (yych == 'p') goto yy433;
+	goto yy358;
+yy390:
+	yych = *++p;
+	if (yych == 'N') goto yy434;
+	if (yych == 'n') goto yy434;
+	goto yy358;
+yy391:
+	yych = *++p;
+	if (yych == 'L') goto yy435;
+	if (yych == 'l') goto yy435;
+	goto yy358;
+yy392:
+	yych = *++p;
+	if (yych <= ' ') {
+		if (yych <= 0x08) goto yy358;
+		if (yych <= '\r') goto yy408;
+		if (yych <= 0x1F) goto yy358;
+		goto yy408;
+	} else {
+		if (yych <= '/') {
+			if (yych <= '.') goto yy358;
+			goto yy410;
+		} else {
+			if (yych == '>') goto yy408;
+			goto yy358;
+		}
+	}
+yy393:
+	yych = *++p;
+	if (yych == 'T') goto yy436;
+	if (yych == 't') goto yy436;
+	goto yy358;
+yy394:
+	yych = *++p;
+	if (yych <= 'V') {
+		if (yych <= 'Q') {
+			if (yych == 'A') goto yy437;
+			goto yy358;
+		} else {
+			if (yych <= 'R') goto yy392;
+			if (yych <= 'U') goto yy358;
+			goto yy392;
+		}
+	} else {
+		if (yych <= 'q') {
+			if (yych == 'a') goto yy437;
+			goto yy358;
+		} else {
+			if (yych <= 'r') goto yy392;
+			if (yych == 'v') goto yy392;
+			goto yy358;
+		}
+	}
+yy395:
+	yych = *++p;
+	if (yych <= 'G') {
+		if (yych == 'E') goto yy438;
+		if (yych <= 'F') goto yy358;
+		goto yy439;
+	} else {
+		if (yych <= 'e') {
+			if (yych <= 'd') goto yy358;
+			goto yy438;
+		} else {
+			if (yych == 'g') goto yy439;
+			goto yy358;
+		}
+	}
+yy396:
+	yych = *++p;
+	if (yych <= 'R') {
+		if (yych == 'O') goto yy434;
+		if (yych <= 'Q') goto yy358;
+		goto yy440;
+	} else {
+		if (yych <= 'o') {
+			if (yych <= 'n') goto yy358;
+			goto yy434;
+		} else {
+			if (yych == 'r') goto yy440;
+			goto yy358;
+		}
+	}
+yy397:
+	yych = *++p;
+	if (yych == 'A') goto yy441;
+	if (yych == 'a') goto yy441;
+	goto yy358;
+yy398:
+	yych = *++p;
+	if (yych == 'A') goto yy442;
+	if (yych == 'a') goto yy442;
+	goto yy358;
+yy399:
+	yych = *++p;
+	if (yych == 'M') goto yy376;
+	if (yych == 'm') goto yy376;
+	goto yy358;
+yy400:
+	yych = *++p;
+	if (yych == 'R') goto yy443;
+	if (yych == 'r') goto yy443;
+	goto yy358;
+yy401:
+	yych = *++p;
+	if (yych == 'G') goto yy444;
+	if (yych == 'g') goto yy444;
+	goto yy358;
+yy402:
+	yych = *++p;
+	if (yych <= '/') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy358;
+			if (yych <= '\r') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= ' ') goto yy408;
+			if (yych <= '.') goto yy358;
+			goto yy410;
+		}
+	} else {
+		if (yych <= 'M') {
+			if (yych == '>') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= 'N') goto yy445;
+			if (yych == 'n') goto yy445;
+			goto yy358;
+		}
+	}
+yy403:
+	yych = *++p;
+	if (yych == 'I') goto yy446;
+	if (yych == 'i') goto yy446;
+	goto yy358;
+yy404:
+	yych = *++p;
+	if (yych == 'N') goto yy447;
+	if (yych == 'n') goto yy447;
+	goto yy358;
+yy405:
+	yych = *++p;
+	if (yych == 'V') goto yy392;
+	if (yych == 'v') goto yy392;
+	goto yy358;
+yy406:
+	yych = *++p;
+	if (yych == 'F') goto yy448;
+	if (yych == 'f') goto yy448;
+	goto yy358;
+yy407:
+	yych = *++p;
+	if (yych == 'T') goto yy449;
+	if (yych == 't') goto yy449;
+	goto yy358;
+yy408:
+	++p;
+	{ return 6; }
+yy410:
+	yych = *++p;
+	if (yych == '>') goto yy408;
+	goto yy358;
+yy411:
+	yych = *++p;
+	if (yych == 'R') goto yy450;
+	if (yych == 'r') goto yy450;
+	goto yy358;
+yy412:
+	yych = *++p;
+	if (yych == 'E') goto yy451;
+	if (yych == 'e') goto yy451;
+	goto yy358;
+yy413:
+	yych = *++p;
+	if (yych == 'R') goto yy452;
+	if (yych == 'r') goto yy452;
+	goto yy358;
+yy414:
+	yych = *++p;
+	if (yych == 'C') goto yy433;
+	if (yych == 'c') goto yy433;
+	goto yy358;
+yy415:
+	yych = *++p;
+	if (yych == 'U') goto yy453;
+	if (yych == 'u') goto yy453;
+	goto yy358;
+yy416:
+	yych = *++p;
+	if (yych == 'Y') goto yy454;
+	if (yych == 'y') goto yy454;
+	goto yy358;
+yy417:
+	yych = *++p;
+	if (yych == 'M') goto yy455;
+	if (yych == 'm') goto yy455;
+	goto yy358;
+yy418:
+	yych = *++p;
+	if (yych == 'B') goto yy456;
+	if (yych == 'b') goto yy456;
+	goto yy358;
+yy419:
+	yych = *++p;
+	if (yych == 'O') goto yy388;
+	if (yych == 'o') goto yy388;
+	goto yy358;
+yy420:
+	yych = *++p;
+	if (yych == 'O') goto yy457;
+	if (yych == 'o') goto yy457;
+	goto yy358;
+yy421:
+	yych = *++p;
+	if (yych <= '/') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy358;
+			if (yych <= '\r') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= ' ') goto yy408;
+			if (yych <= '.') goto yy358;
+			goto yy410;
+		}
+	} else {
+		if (yych <= 'D') {
+			if (yych == '>') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= 'E') goto yy458;
+			if (yych == 'e') goto yy458;
+			goto yy358;
+		}
+	}
+yy422:
+	yych = *++p;
+	if (yych == 'T') goto yy456;
+	if (yych == 't') goto yy456;
+	goto yy358;
+yy423:
+	yych = *++p;
+	if (yych <= '/') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy358;
+			if (yych <= '\r') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= ' ') goto yy408;
+			if (yych <= '.') goto yy358;
+			goto yy410;
+		}
+	} else {
+		if (yych <= '@') {
+			if (yych == '>') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= 'A') goto yy459;
+			if (yych == 'a') goto yy459;
+			goto yy358;
+		}
+	}
+yy424:
+	++p;
+	{ return 2; }
+yy426:
+	yych = *++p;
+	if (yych == 'D') goto yy460;
+	if (yych == 'd') goto yy460;
+	goto yy358;
+yy427:
+	yych = *++p;
+	if (yych == 'R') goto yy461;
+	if (yych == 'r') goto yy461;
+	goto yy358;
+yy428:
+	yych = *++p;
+	if (yych == 'I') goto yy462;
+	if (yych == 'i') goto yy462;
+	goto yy358;
+yy429:
+	yych = *++p;
+	if (yych == 'D') goto yy463;
+	if (yych == 'd') goto yy463;
+	goto yy358;
+yy430:
+	yych = *++p;
+	if (yych == 'E') goto yy464;
+	if (yych == 'e') goto yy464;
+	goto yy358;
+yy431:
+	yych = *++p;
+	if (yych == 'C') goto yy465;
+	if (yych == 'c') goto yy465;
+	goto yy358;
+yy432:
+	yych = *++p;
+	if (yych == 'Y') goto yy392;
+	if (yych == 'y') goto yy392;
+	goto yy358;
+yy433:
+	yych = *++p;
+	if (yych == 'T') goto yy466;
+	if (yych == 't') goto yy466;
+	goto yy358;
+yy434:
+	yych = *++p;
+	if (yych == 'T') goto yy467;
+	if (yych == 't') goto yy467;
+	goto yy358;
+yy435:
+	yych = *++p;
+	if (yych <= '/') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy358;
+			if (yych <= '\r') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= ' ') goto yy408;
+			if (yych <= '.') goto yy358;
+			goto yy410;
+		}
+	} else {
+		if (yych <= 'F') {
+			if (yych == '>') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= 'G') goto yy468;
+			if (yych == 'g') goto yy468;
+			goto yy358;
+		}
+	}
+yy436:
+	yych = *++p;
+	if (yych == 'A') goto yy469;
+	if (yych == 'a') goto yy469;
+	goto yy358;
+yy437:
+	yych = *++p;
+	if (yych == 'L') goto yy470;
+	if (yych == 'l') goto yy470;
+	goto yy358;
+yy438:
+	yych = *++p;
+	if (yych == 'L') goto yy471;
+	if (yych == 'l') goto yy471;
+	goto yy358;
+yy439:
+	yych = *++p;
+	if (yych <= 'U') {
+		if (yych == 'C') goto yy472;
+		if (yych <= 'T') goto yy358;
+		goto yy473;
+	} else {
+		if (yych <= 'c') {
+			if (yych <= 'b') goto yy358;
+			goto yy472;
+		} else {
+			if (yych == 'u') goto yy473;
+			goto yy358;
+		}
+	}
+yy440:
+	yych = *++p;
+	if (yych == 'M') goto yy392;
+	if (yych == 'm') goto yy392;
+	goto yy358;
+yy441:
+	yych = *++p;
+	if (yych == 'M') goto yy474;
+	if (yych == 'm') goto yy474;
+	goto yy358;
+yy442:
+	yych = *++p;
+	if (yych == 'D') goto yy475;
+	if (yych == 'd') goto yy475;
+	goto yy358;
+yy443:
+	yych = *++p;
+	if (yych == 'A') goto yy476;
+	if (yych == 'a') goto yy476;
+	goto yy358;
+yy444:
+	yych = *++p;
+	if (yych == 'E') goto yy477;
+	if (yych == 'e') goto yy477;
+	goto yy358;
+yy445:
+	yych = *++p;
+	if (yych == 'K') goto yy392;
+	if (yych == 'k') goto yy392;
+	goto yy358;
+yy446:
+	yych = *++p;
+	if (yych == 'N') goto yy392;
+	if (yych == 'n') goto yy392;
+	goto yy358;
+yy447:
+	yych = *++p;
+	if (yych == 'U') goto yy478;
+	if (yych == 'u') goto yy478;
+	goto yy358;
+yy448:
+	yych = *++p;
+	if (yych == 'R') goto yy479;
+	if (yych == 'r') goto yy479;
+	goto yy358;
+yy449:
+	yych = *++p;
+	if (yych <= 'I') {
+		if (yych == 'G') goto yy468;
+		if (yych <= 'H') goto yy358;
+		goto yy480;
+	} else {
+		if (yych <= 'g') {
+			if (yych <= 'f') goto yy358;
+			goto yy468;
+		} else {
+			if (yych == 'i') goto yy480;
+			goto yy358;
+		}
+	}
+yy450:
+	yych = *++p;
+	if (yych == 'A') goto yy440;
+	if (yych == 'a') goto yy440;
+	goto yy358;
+yy451:
+	yych = *++p;
+	if (yych <= 0x1F) {
+		if (yych <= 0x08) goto yy358;
+		if (yych <= '\r') goto yy481;
+		goto yy358;
+	} else {
+		if (yych <= ' ') goto yy481;
+		if (yych == '>') goto yy481;
+		goto yy358;
+	}
+yy452:
+	yych = *++p;
+	if (yych == 'I') goto yy483;
+	if (yych == 'i') goto yy483;
+	goto yy358;
+yy453:
+	yych = *++p;
+	if (yych == 'R') goto yy484;
+	if (yych == 'r') goto yy484;
+	goto yy358;
+yy454:
+	yych = *++p;
+	if (yych == 'L') goto yy412;
+	if (yych == 'l') goto yy412;
+	goto yy358;
+yy455:
+	yych = *++p;
+	if (yych == 'M') goto yy485;
+	if (yych == 'm') goto yy485;
+	goto yy358;
+yy456:
+	yych = *++p;
+	if (yych == 'L') goto yy463;
+	if (yych == 'l') goto yy463;
+	goto yy358;
+yy457:
+	yych = *++p;
+	if (yych == 'O') goto yy486;
+	if (yych == 'o') goto yy486;
+	goto yy358;
+yy458:
+	yych = *++p;
+	if (yych == 'A') goto yy487;
+	if (yych == 'a') goto yy487;
+	goto yy358;
+yy459:
+	yych = *++p;
+	if (yych == 'C') goto yy445;
+	if (yych == 'c') goto yy445;
+	goto yy358;
+yy460:
+	yych = *++p;
+	if (yych == 'A') goto yy488;
+	if (yych == 'a') goto yy488;
+	goto yy358;
+yy461:
+	yych = *++p;
+	if (yych == 'E') goto yy489;
+	if (yych == 'e') goto yy489;
+	goto yy358;
+yy462:
+	yych = *++p;
+	if (yych == 'C') goto yy456;
+	if (yych == 'c') goto yy456;
+	goto yy358;
+yy463:
+	yych = *++p;
+	if (yych == 'E') goto yy392;
+	if (yych == 'e') goto yy392;
+	goto yy358;
+yy464:
+	yych = *++p;
+	if (yych <= '/') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy358;
+			if (yych <= '\r') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= ' ') goto yy408;
+			if (yych <= '.') goto yy358;
+			goto yy410;
+		}
+	} else {
+		if (yych <= 'E') {
+			if (yych == '>') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= 'F') goto yy490;
+			if (yych == 'f') goto yy490;
+			goto yy358;
+		}
+	}
+yy465:
+	yych = *++p;
+	if (yych == 'K') goto yy491;
+	if (yych == 'k') goto yy491;
+	goto yy358;
+yy466:
+	yych = *++p;
+	if (yych == 'I') goto yy480;
+	if (yych == 'i') goto yy480;
+	goto yy358;
+yy467:
+	yych = *++p;
+	if (yych == 'E') goto yy492;
+	if (yych == 'e') goto yy492;
+	goto yy358;
+yy468:
+	yych = *++p;
+	if (yych == 'R') goto yy493;
+	if (yych == 'r') goto yy493;
+	goto yy358;
+yy469:
+	yych = *++p;
+	if (yych == 'I') goto yy494;
+	if (yych == 'i') goto yy494;
+	goto yy358;
+yy470:
+	yych = *++p;
+	if (yych == 'O') goto yy495;
+	if (yych == 'o') goto yy495;
+	goto yy358;
+yy471:
+	yych = *++p;
+	if (yych == 'D') goto yy496;
+	if (yych == 'd') goto yy496;
+	goto yy358;
+yy472:
+	yych = *++p;
+	if (yych == 'A') goto yy389;
+	if (yych == 'a') goto yy389;
+	goto yy358;
+yy473:
+	yych = *++p;
+	if (yych == 'R') goto yy463;
+	if (yych == 'r') goto yy463;
+	goto yy358;
+yy474:
+	yych = *++p;
+	if (yych == 'E') goto yy497;
+	if (yych == 'e') goto yy497;
+	goto yy358;
+yy475:
+	yych = *++p;
+	if (yych <= '/') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy358;
+			if (yych <= '\r') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= ' ') goto yy408;
+			if (yych <= '.') goto yy358;
+			goto yy410;
+		}
+	} else {
+		if (yych <= 'D') {
+			if (yych == '>') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= 'E') goto yy492;
+			if (yych == 'e') goto yy492;
+			goto yy358;
+		}
+	}
+yy476:
+	yych = *++p;
+	if (yych == 'M') goto yy463;
+	if (yych == 'm') goto yy463;
+	goto yy358;
+yy477:
+	yych = *++p;
+	if (yych == 'N') goto yy487;
+	if (yych == 'n') goto yy487;
+	goto yy358;
+yy478:
+	yych = *++p;
+	if (yych <= '/') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy358;
+			if (yych <= '\r') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= ' ') goto yy408;
+			if (yych <= '.') goto yy358;
+			goto yy410;
+		}
+	} else {
+		if (yych <= 'H') {
+			if (yych == '>') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= 'I') goto yy498;
+			if (yych == 'i') goto yy498;
+			goto yy358;
+		}
+	}
+yy479:
+	yych = *++p;
+	if (yych == 'A') goto yy499;
+	if (yych == 'a') goto yy499;
+	goto yy358;
+yy480:
+	yych = *++p;
+	if (yych == 'O') goto yy446;
+	if (yych == 'o') goto yy446;
+	goto yy358;
+yy481:
+	++p;
+	{ return 1; }
+yy483:
+	yych = *++p;
+	if (yych == 'P') goto yy500;
+	if (yych == 'p') goto yy500;
+	goto yy358;
+yy484:
+	yych = *++p;
+	if (yych == 'C') goto yy463;
+	if (yych == 'c') goto yy463;
+	goto yy358;
+yy485:
+	yych = *++p;
+	if (yych == 'A') goto yy501;
+	if (yych == 'a') goto yy501;
+	goto yy358;
+yy486:
+	yych = *++p;
+	if (yych == 'T') goto yy392;
+	if (yych == 't') goto yy392;
+	goto yy358;
+yy487:
+	yych = *++p;
+	if (yych == 'D') goto yy392;
+	if (yych == 'd') goto yy392;
+	goto yy358;
+yy488:
+	yych = *++p;
+	if (yych == 'T') goto yy502;
+	if (yych == 't') goto yy502;
+	goto yy358;
+yy489:
+	yych = *++p;
+	if (yych == 'S') goto yy503;
+	if (yych == 's') goto yy503;
+	goto yy358;
+yy490:
+	yych = *++p;
+	if (yych == 'O') goto yy504;
+	if (yych == 'o') goto yy504;
+	goto yy358;
+yy491:
+	yych = *++p;
+	if (yych == 'Q') goto yy505;
+	if (yych == 'q') goto yy505;
+	goto yy358;
+yy492:
+	yych = *++p;
+	if (yych == 'R') goto yy392;
+	if (yych == 'r') goto yy392;
+	goto yy358;
+yy493:
+	yych = *++p;
+	if (yych == 'O') goto yy506;
+	if (yych == 'o') goto yy506;
+	goto yy358;
+yy494:
+	yych = *++p;
+	if (yych == 'L') goto yy503;
+	if (yych == 'l') goto yy503;
+	goto yy358;
+yy495:
+	yych = *++p;
+	if (yych == 'G') goto yy392;
+	if (yych == 'g') goto yy392;
+	goto yy358;
+yy496:
+	yych = *++p;
+	if (yych == 'S') goto yy507;
+	if (yych == 's') goto yy507;
+	goto yy358;
+yy497:
+	yych = *++p;
+	if (yych <= '/') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy358;
+			if (yych <= '\r') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= ' ') goto yy408;
+			if (yych <= '.') goto yy358;
+			goto yy410;
+		}
+	} else {
+		if (yych <= 'R') {
+			if (yych == '>') goto yy408;
+			goto yy358;
+		} else {
+			if (yych <= 'S') goto yy507;
+			if (yych == 's') goto yy507;
+			goto yy358;
+		}
+	}
+yy498:
+	yych = *++p;
+	if (yych == 'T') goto yy508;
+	if (yych == 't') goto yy508;
+	goto yy358;
+yy499:
+	yych = *++p;
+	if (yych == 'M') goto yy509;
+	if (yych == 'm') goto yy509;
+	goto yy358;
+yy500:
+	yych = *++p;
+	if (yych == 'T') goto yy451;
+	if (yych == 't') goto yy451;
+	goto yy358;
+yy501:
+	yych = *++p;
+	if (yych == 'R') goto yy432;
+	if (yych == 'r') goto yy432;
+	goto yy358;
+yy502:
+	yych = *++p;
+	if (yych == 'A') goto yy510;
+	if (yych == 'a') goto yy510;
+	goto yy358;
+yy503:
+	yych = *++p;
+	if (yych == 'S') goto yy392;
+	if (yych == 's') goto yy392;
+	goto yy358;
+yy504:
+	yych = *++p;
+	if (yych == 'N') goto yy486;
+	if (yych == 'n') goto yy486;
+	goto yy358;
+yy505:
+	yych = *++p;
+	if (yych == 'U') goto yy511;
+	if (yych == 'u') goto yy511;
+	goto yy358;
+yy506:
+	yych = *++p;
+	if (yych == 'U') goto yy512;
+	if (yych == 'u') goto yy512;
+	goto yy358;
+yy507:
+	yych = *++p;
+	if (yych == 'E') goto yy486;
+	if (yych == 'e') goto yy486;
+	goto yy358;
+yy508:
+	yych = *++p;
+	if (yych == 'E') goto yy440;
+	if (yych == 'e') goto yy440;
+	goto yy358;
+yy509:
+	yych = *++p;
+	if (yych == 'E') goto yy503;
+	if (yych == 'e') goto yy503;
+	goto yy358;
+yy510:
+	yych = *++p;
+	if (yych == '[') goto yy513;
+	goto yy358;
+yy511:
+	yych = *++p;
+	if (yych == 'O') goto yy515;
+	if (yych == 'o') goto yy515;
+	goto yy358;
+yy512:
+	yych = *++p;
+	if (yych == 'P') goto yy392;
+	if (yych == 'p') goto yy392;
+	goto yy358;
+yy513:
+	++p;
+	{ return 5; }
+yy515:
+	yych = *++p;
+	if (yych == 'T') goto yy463;
+	if (yych == 't') goto yy463;
+	goto yy358;
+}
+
+}
+
+// Try to match an HTML block tag start line of type 7, returning
+// 7 if successful, 0 if not.
+bufsize_t _scan_html_block_start_7(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+
+{
+	unsigned char yych;
+	unsigned int yyaccept = 0;
+	static const unsigned char yybm[] = {
+		  0, 224, 224, 224, 224, 224, 224, 224, 
+		224, 198, 210, 194, 198, 194, 224, 224, 
+		224, 224, 224, 224, 224, 224, 224, 224, 
+		224, 224, 224, 224, 224, 224, 224, 224, 
+		198, 224, 128, 224, 224, 224, 224,  64, 
+		224, 224, 224, 224, 224, 233, 232, 224, 
+		233, 233, 233, 233, 233, 233, 233, 233, 
+		233, 233, 232, 224, 192, 192, 192, 224, 
+		224, 233, 233, 233, 233, 233, 233, 233, 
+		233, 233, 233, 233, 233, 233, 233, 233, 
+		233, 233, 233, 233, 233, 233, 233, 233, 
+		233, 233, 233, 224, 224, 224, 224, 232, 
+		192, 233, 233, 233, 233, 233, 233, 233, 
+		233, 233, 233, 233, 233, 233, 233, 233, 
+		233, 233, 233, 233, 233, 233, 233, 233, 
+		233, 233, 233, 224, 224, 224, 224, 224, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych == '<') goto yy520;
+	++p;
+yy519:
+	{ return 0; }
+yy520:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= '@') {
+		if (yych != '/') goto yy519;
+	} else {
+		if (yych <= 'Z') goto yy523;
+		if (yych <= '`') goto yy519;
+		if (yych <= 'z') goto yy523;
+		goto yy519;
+	}
+	yych = *++p;
+	if (yych <= '@') goto yy522;
+	if (yych <= 'Z') goto yy525;
+	if (yych <= '`') goto yy522;
+	if (yych <= 'z') goto yy525;
+yy522:
+	p = marker;
+	if (yyaccept == 0) {
+		goto yy519;
+	} else {
+		goto yy538;
+	}
+yy523:
+	yych = *++p;
+	if (yybm[0+yych] & 2) {
+		goto yy527;
+	}
+	if (yych <= '=') {
+		if (yych <= '.') {
+			if (yych == '-') goto yy523;
+			goto yy522;
+		} else {
+			if (yych <= '/') goto yy529;
+			if (yych <= '9') goto yy523;
+			goto yy522;
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '>') goto yy530;
+			if (yych <= '@') goto yy522;
+			goto yy523;
+		} else {
+			if (yych <= '`') goto yy522;
+			if (yych <= 'z') goto yy523;
+			goto yy522;
+		}
+	}
+yy525:
+	yych = *++p;
+	if (yych <= '/') {
+		if (yych <= 0x1F) {
+			if (yych <= 0x08) goto yy522;
+			if (yych <= '\r') goto yy532;
+			goto yy522;
+		} else {
+			if (yych <= ' ') goto yy532;
+			if (yych == '-') goto yy525;
+			goto yy522;
+		}
+	} else {
+		if (yych <= '@') {
+			if (yych <= '9') goto yy525;
+			if (yych == '>') goto yy530;
+			goto yy522;
+		} else {
+			if (yych <= 'Z') goto yy525;
+			if (yych <= '`') goto yy522;
+			if (yych <= 'z') goto yy525;
+			goto yy522;
+		}
+	}
+yy527:
+	yych = *++p;
+	if (yybm[0+yych] & 2) {
+		goto yy527;
+	}
+	if (yych <= '>') {
+		if (yych <= '9') {
+			if (yych != '/') goto yy522;
+		} else {
+			if (yych <= ':') goto yy534;
+			if (yych <= '=') goto yy522;
+			goto yy530;
+		}
+	} else {
+		if (yych <= '^') {
+			if (yych <= '@') goto yy522;
+			if (yych <= 'Z') goto yy534;
+			goto yy522;
+		} else {
+			if (yych == '`') goto yy522;
+			if (yych <= 'z') goto yy534;
+			goto yy522;
+		}
+	}
+yy529:
+	yych = *++p;
+	if (yych != '>') goto yy522;
+yy530:
+	yych = *++p;
+	if (yybm[0+yych] & 4) {
+		goto yy530;
+	}
+	if (yych <= 0x08) goto yy522;
+	if (yych <= '\n') goto yy536;
+	if (yych <= '\v') goto yy522;
+	if (yych <= '\r') goto yy539;
+	goto yy522;
+yy532:
+	yych = *++p;
+	if (yych <= 0x1F) {
+		if (yych <= 0x08) goto yy522;
+		if (yych <= '\r') goto yy532;
+		goto yy522;
+	} else {
+		if (yych <= ' ') goto yy532;
+		if (yych == '>') goto yy530;
+		goto yy522;
+	}
+yy534:
+	yych = *++p;
+	if (yybm[0+yych] & 8) {
+		goto yy534;
+	}
+	if (yych <= ',') {
+		if (yych <= '\r') {
+			if (yych <= 0x08) goto yy522;
+			goto yy540;
+		} else {
+			if (yych == ' ') goto yy540;
+			goto yy522;
+		}
+	} else {
+		if (yych <= '<') {
+			if (yych <= '/') goto yy529;
+			goto yy522;
+		} else {
+			if (yych <= '=') goto yy542;
+			if (yych <= '>') goto yy530;
+			goto yy522;
+		}
+	}
+yy536:
+	yyaccept = 1;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 4) {
+		goto yy530;
+	}
+	if (yych <= 0x08) goto yy538;
+	if (yych <= '\n') goto yy536;
+	if (yych <= '\v') goto yy538;
+	if (yych <= '\r') goto yy539;
+yy538:
+	{ return 7; }
+yy539:
+	++p;
+	goto yy538;
+yy540:
+	yych = *++p;
+	if (yych <= '<') {
+		if (yych <= ' ') {
+			if (yych <= 0x08) goto yy522;
+			if (yych <= '\r') goto yy540;
+			if (yych <= 0x1F) goto yy522;
+			goto yy540;
+		} else {
+			if (yych <= '/') {
+				if (yych <= '.') goto yy522;
+				goto yy529;
+			} else {
+				if (yych == ':') goto yy534;
+				goto yy522;
+			}
+		}
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '=') goto yy542;
+			if (yych <= '>') goto yy530;
+			if (yych <= '@') goto yy522;
+			goto yy534;
+		} else {
+			if (yych <= '_') {
+				if (yych <= '^') goto yy522;
+				goto yy534;
+			} else {
+				if (yych <= '`') goto yy522;
+				if (yych <= 'z') goto yy534;
+				goto yy522;
+			}
+		}
+	}
+yy542:
+	yych = *++p;
+	if (yybm[0+yych] & 32) {
+		goto yy544;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '"') {
+			if (yych <= 0x00) goto yy522;
+			if (yych <= ' ') goto yy542;
+			goto yy546;
+		} else {
+			if (yych <= '\'') goto yy548;
+			if (yych <= 0xC1) goto yy522;
+			if (yych <= 0xDF) goto yy550;
+			goto yy551;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy553;
+			goto yy552;
+		} else {
+			if (yych <= 0xF0) goto yy554;
+			if (yych <= 0xF3) goto yy555;
+			if (yych <= 0xF4) goto yy556;
+			goto yy522;
+		}
+	}
+yy544:
+	yych = *++p;
+	if (yybm[0+yych] & 32) {
+		goto yy544;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '=') {
+			if (yych <= 0x00) goto yy522;
+			if (yych <= ' ') goto yy527;
+			goto yy522;
+		} else {
+			if (yych <= '>') goto yy530;
+			if (yych <= 0xC1) goto yy522;
+			if (yych <= 0xDF) goto yy550;
+			goto yy551;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy553;
+			goto yy552;
+		} else {
+			if (yych <= 0xF0) goto yy554;
+			if (yych <= 0xF3) goto yy555;
+			if (yych <= 0xF4) goto yy556;
+			goto yy522;
+		}
+	}
+yy546:
+	yych = *++p;
+	if (yybm[0+yych] & 64) {
+		goto yy546;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy522;
+			if (yych <= '"') goto yy557;
+			goto yy522;
+		} else {
+			if (yych <= 0xDF) goto yy558;
+			if (yych <= 0xE0) goto yy559;
+			goto yy560;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy561;
+			if (yych <= 0xEF) goto yy560;
+			goto yy562;
+		} else {
+			if (yych <= 0xF3) goto yy563;
+			if (yych <= 0xF4) goto yy564;
+			goto yy522;
+		}
+	}
+yy548:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy548;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy522;
+			if (yych <= '\'') goto yy557;
+			goto yy522;
+		} else {
+			if (yych <= 0xDF) goto yy565;
+			if (yych <= 0xE0) goto yy566;
+			goto yy567;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy568;
+			if (yych <= 0xEF) goto yy567;
+			goto yy569;
+		} else {
+			if (yych <= 0xF3) goto yy570;
+			if (yych <= 0xF4) goto yy571;
+			goto yy522;
+		}
+	}
+yy550:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0xBF) goto yy544;
+	goto yy522;
+yy551:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy522;
+	if (yych <= 0xBF) goto yy550;
+	goto yy522;
+yy552:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0xBF) goto yy550;
+	goto yy522;
+yy553:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0x9F) goto yy550;
+	goto yy522;
+yy554:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy522;
+	if (yych <= 0xBF) goto yy552;
+	goto yy522;
+yy555:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0xBF) goto yy552;
+	goto yy522;
+yy556:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0x8F) goto yy552;
+	goto yy522;
+yy557:
+	yych = *++p;
+	if (yybm[0+yych] & 2) {
+		goto yy527;
+	}
+	if (yych == '/') goto yy529;
+	if (yych == '>') goto yy530;
+	goto yy522;
+yy558:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0xBF) goto yy546;
+	goto yy522;
+yy559:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy522;
+	if (yych <= 0xBF) goto yy558;
+	goto yy522;
+yy560:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0xBF) goto yy558;
+	goto yy522;
+yy561:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0x9F) goto yy558;
+	goto yy522;
+yy562:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy522;
+	if (yych <= 0xBF) goto yy560;
+	goto yy522;
+yy563:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0xBF) goto yy560;
+	goto yy522;
+yy564:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0x8F) goto yy560;
+	goto yy522;
+yy565:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0xBF) goto yy548;
+	goto yy522;
+yy566:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy522;
+	if (yych <= 0xBF) goto yy565;
+	goto yy522;
+yy567:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0xBF) goto yy565;
+	goto yy522;
+yy568:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0x9F) goto yy565;
+	goto yy522;
+yy569:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy522;
+	if (yych <= 0xBF) goto yy567;
+	goto yy522;
+yy570:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0xBF) goto yy567;
+	goto yy522;
+yy571:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy522;
+	if (yych <= 0x8F) goto yy567;
+	goto yy522;
+}
+
+}
+
+// Try to match an HTML block end line of type 1
+bufsize_t _scan_html_block_end_1(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	unsigned int yyaccept = 0;
+	static const unsigned char yybm[] = {
+		  0,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,   0,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64, 128,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych <= 0xDF) {
+		if (yych <= ';') {
+			if (yych <= 0x00) goto yy574;
+			if (yych != '\n') goto yy576;
+		} else {
+			if (yych <= '<') goto yy577;
+			if (yych <= 0x7F) goto yy576;
+			if (yych >= 0xC2) goto yy578;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) goto yy579;
+			if (yych == 0xED) goto yy581;
+			goto yy580;
+		} else {
+			if (yych <= 0xF0) goto yy582;
+			if (yych <= 0xF3) goto yy583;
+			if (yych <= 0xF4) goto yy584;
+		}
+	}
+yy574:
+	++p;
+yy575:
+	{ return 0; }
+yy576:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= '\n') {
+		if (yych <= 0x00) goto yy575;
+		if (yych <= '\t') goto yy586;
+		goto yy575;
+	} else {
+		if (yych <= 0x7F) goto yy586;
+		if (yych <= 0xC1) goto yy575;
+		if (yych <= 0xF4) goto yy586;
+		goto yy575;
+	}
+yy577:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= '.') {
+		if (yych <= 0x00) goto yy575;
+		if (yych == '\n') goto yy575;
+		goto yy586;
+	} else {
+		if (yych <= 0x7F) {
+			if (yych <= '/') goto yy597;
+			goto yy586;
+		} else {
+			if (yych <= 0xC1) goto yy575;
+			if (yych <= 0xF4) goto yy586;
+			goto yy575;
+		}
+	}
+yy578:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy575;
+	if (yych <= 0xBF) goto yy585;
+	goto yy575;
+yy579:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x9F) goto yy575;
+	if (yych <= 0xBF) goto yy590;
+	goto yy575;
+yy580:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy575;
+	if (yych <= 0xBF) goto yy590;
+	goto yy575;
+yy581:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy575;
+	if (yych <= 0x9F) goto yy590;
+	goto yy575;
+yy582:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x8F) goto yy575;
+	if (yych <= 0xBF) goto yy592;
+	goto yy575;
+yy583:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy575;
+	if (yych <= 0xBF) goto yy592;
+	goto yy575;
+yy584:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy575;
+	if (yych <= 0x8F) goto yy592;
+	goto yy575;
+yy585:
+	yych = *++p;
+yy586:
+	if (yybm[0+yych] & 64) {
+		goto yy585;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy587;
+			if (yych <= '<') goto yy588;
+		} else {
+			if (yych <= 0xDF) goto yy590;
+			if (yych <= 0xE0) goto yy591;
+			goto yy592;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy593;
+			if (yych <= 0xEF) goto yy592;
+			goto yy594;
+		} else {
+			if (yych <= 0xF3) goto yy595;
+			if (yych <= 0xF4) goto yy596;
+		}
+	}
+yy587:
+	p = marker;
+	if (yyaccept == 0) {
+		goto yy575;
+	} else {
+		goto yy607;
+	}
+yy588:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 0xDF) {
+		if (yych <= '.') {
+			if (yych <= 0x00) goto yy587;
+			if (yych == '\n') goto yy587;
+			goto yy585;
+		} else {
+			if (yych <= '/') goto yy597;
+			if (yych <= 0x7F) goto yy585;
+			if (yych <= 0xC1) goto yy587;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) goto yy591;
+			if (yych == 0xED) goto yy593;
+			goto yy592;
+		} else {
+			if (yych <= 0xF0) goto yy594;
+			if (yych <= 0xF3) goto yy595;
+			if (yych <= 0xF4) goto yy596;
+			goto yy587;
+		}
+	}
+yy590:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy587;
+	if (yych <= 0xBF) goto yy585;
+	goto yy587;
+yy591:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy587;
+	if (yych <= 0xBF) goto yy590;
+	goto yy587;
+yy592:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy587;
+	if (yych <= 0xBF) goto yy590;
+	goto yy587;
+yy593:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy587;
+	if (yych <= 0x9F) goto yy590;
+	goto yy587;
+yy594:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy587;
+	if (yych <= 0xBF) goto yy592;
+	goto yy587;
+yy595:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy587;
+	if (yych <= 0xBF) goto yy592;
+	goto yy587;
+yy596:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy587;
+	if (yych <= 0x8F) goto yy592;
+	goto yy587;
+yy597:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 's') {
+		if (yych <= 'P') {
+			if (yych <= '\t') {
+				if (yych <= 0x00) goto yy587;
+				goto yy585;
+			} else {
+				if (yych <= '\n') goto yy587;
+				if (yych <= 'O') goto yy585;
+			}
+		} else {
+			if (yych <= 'o') {
+				if (yych == 'S') goto yy599;
+				goto yy585;
+			} else {
+				if (yych <= 'p') goto yy598;
+				if (yych <= 'r') goto yy585;
+				goto yy599;
+			}
+		}
+	} else {
+		if (yych <= 0xEC) {
+			if (yych <= 0xC1) {
+				if (yych <= 0x7F) goto yy585;
+				goto yy587;
+			} else {
+				if (yych <= 0xDF) goto yy590;
+				if (yych <= 0xE0) goto yy591;
+				goto yy592;
+			}
+		} else {
+			if (yych <= 0xF0) {
+				if (yych <= 0xED) goto yy593;
+				if (yych <= 0xEF) goto yy592;
+				goto yy594;
+			} else {
+				if (yych <= 0xF3) goto yy595;
+				if (yych <= 0xF4) goto yy596;
+				goto yy587;
+			}
+		}
+	}
+yy598:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 0xC1) {
+		if (yych <= 'Q') {
+			if (yych <= 0x00) goto yy587;
+			if (yych == '\n') goto yy587;
+			goto yy585;
+		} else {
+			if (yych <= 'q') {
+				if (yych <= 'R') goto yy600;
+				goto yy585;
+			} else {
+				if (yych <= 'r') goto yy600;
+				if (yych <= 0x7F) goto yy585;
+				goto yy587;
+			}
+		}
+	} else {
+		if (yych <= 0xED) {
+			if (yych <= 0xDF) goto yy590;
+			if (yych <= 0xE0) goto yy591;
+			if (yych <= 0xEC) goto yy592;
+			goto yy593;
+		} else {
+			if (yych <= 0xF0) {
+				if (yych <= 0xEF) goto yy592;
+				goto yy594;
+			} else {
+				if (yych <= 0xF3) goto yy595;
+				if (yych <= 0xF4) goto yy596;
+				goto yy587;
+			}
+		}
+	}
+yy599:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 't') {
+		if (yych <= 'C') {
+			if (yych <= '\t') {
+				if (yych <= 0x00) goto yy587;
+				goto yy585;
+			} else {
+				if (yych <= '\n') goto yy587;
+				if (yych <= 'B') goto yy585;
+				goto yy601;
+			}
+		} else {
+			if (yych <= 'b') {
+				if (yych == 'T') goto yy602;
+				goto yy585;
+			} else {
+				if (yych <= 'c') goto yy601;
+				if (yych <= 's') goto yy585;
+				goto yy602;
+			}
+		}
+	} else {
+		if (yych <= 0xEC) {
+			if (yych <= 0xC1) {
+				if (yych <= 0x7F) goto yy585;
+				goto yy587;
+			} else {
+				if (yych <= 0xDF) goto yy590;
+				if (yych <= 0xE0) goto yy591;
+				goto yy592;
+			}
+		} else {
+			if (yych <= 0xF0) {
+				if (yych <= 0xED) goto yy593;
+				if (yych <= 0xEF) goto yy592;
+				goto yy594;
+			} else {
+				if (yych <= 0xF3) goto yy595;
+				if (yych <= 0xF4) goto yy596;
+				goto yy587;
+			}
+		}
+	}
+yy600:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 0xC1) {
+		if (yych <= 'D') {
+			if (yych <= 0x00) goto yy587;
+			if (yych == '\n') goto yy587;
+			goto yy585;
+		} else {
+			if (yych <= 'd') {
+				if (yych <= 'E') goto yy603;
+				goto yy585;
+			} else {
+				if (yych <= 'e') goto yy603;
+				if (yych <= 0x7F) goto yy585;
+				goto yy587;
+			}
+		}
+	} else {
+		if (yych <= 0xED) {
+			if (yych <= 0xDF) goto yy590;
+			if (yych <= 0xE0) goto yy591;
+			if (yych <= 0xEC) goto yy592;
+			goto yy593;
+		} else {
+			if (yych <= 0xF0) {
+				if (yych <= 0xEF) goto yy592;
+				goto yy594;
+			} else {
+				if (yych <= 0xF3) goto yy595;
+				if (yych <= 0xF4) goto yy596;
+				goto yy587;
+			}
+		}
+	}
+yy601:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 0xC1) {
+		if (yych <= 'Q') {
+			if (yych <= 0x00) goto yy587;
+			if (yych == '\n') goto yy587;
+			goto yy585;
+		} else {
+			if (yych <= 'q') {
+				if (yych <= 'R') goto yy604;
+				goto yy585;
+			} else {
+				if (yych <= 'r') goto yy604;
+				if (yych <= 0x7F) goto yy585;
+				goto yy587;
+			}
+		}
+	} else {
+		if (yych <= 0xED) {
+			if (yych <= 0xDF) goto yy590;
+			if (yych <= 0xE0) goto yy591;
+			if (yych <= 0xEC) goto yy592;
+			goto yy593;
+		} else {
+			if (yych <= 0xF0) {
+				if (yych <= 0xEF) goto yy592;
+				goto yy594;
+			} else {
+				if (yych <= 0xF3) goto yy595;
+				if (yych <= 0xF4) goto yy596;
+				goto yy587;
+			}
+		}
+	}
+yy602:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 0xC1) {
+		if (yych <= 'X') {
+			if (yych <= 0x00) goto yy587;
+			if (yych == '\n') goto yy587;
+			goto yy585;
+		} else {
+			if (yych <= 'x') {
+				if (yych <= 'Y') goto yy605;
+				goto yy585;
+			} else {
+				if (yych <= 'y') goto yy605;
+				if (yych <= 0x7F) goto yy585;
+				goto yy587;
+			}
+		}
+	} else {
+		if (yych <= 0xED) {
+			if (yych <= 0xDF) goto yy590;
+			if (yych <= 0xE0) goto yy591;
+			if (yych <= 0xEC) goto yy592;
+			goto yy593;
+		} else {
+			if (yych <= 0xF0) {
+				if (yych <= 0xEF) goto yy592;
+				goto yy594;
+			} else {
+				if (yych <= 0xF3) goto yy595;
+				if (yych <= 0xF4) goto yy596;
+				goto yy587;
+			}
+		}
+	}
+yy603:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 0xDF) {
+		if (yych <= '=') {
+			if (yych <= 0x00) goto yy587;
+			if (yych == '\n') goto yy587;
+			goto yy585;
+		} else {
+			if (yych <= '>') goto yy606;
+			if (yych <= 0x7F) goto yy585;
+			if (yych <= 0xC1) goto yy587;
+			goto yy590;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) goto yy591;
+			if (yych == 0xED) goto yy593;
+			goto yy592;
+		} else {
+			if (yych <= 0xF0) goto yy594;
+			if (yych <= 0xF3) goto yy595;
+			if (yych <= 0xF4) goto yy596;
+			goto yy587;
+		}
+	}
+yy604:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 0xC1) {
+		if (yych <= 'H') {
+			if (yych <= 0x00) goto yy587;
+			if (yych == '\n') goto yy587;
+			goto yy585;
+		} else {
+			if (yych <= 'h') {
+				if (yych <= 'I') goto yy608;
+				goto yy585;
+			} else {
+				if (yych <= 'i') goto yy608;
+				if (yych <= 0x7F) goto yy585;
+				goto yy587;
+			}
+		}
+	} else {
+		if (yych <= 0xED) {
+			if (yych <= 0xDF) goto yy590;
+			if (yych <= 0xE0) goto yy591;
+			if (yych <= 0xEC) goto yy592;
+			goto yy593;
+		} else {
+			if (yych <= 0xF0) {
+				if (yych <= 0xEF) goto yy592;
+				goto yy594;
+			} else {
+				if (yych <= 0xF3) goto yy595;
+				if (yych <= 0xF4) goto yy596;
+				goto yy587;
+			}
+		}
+	}
+yy605:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 0xC1) {
+		if (yych <= 'K') {
+			if (yych <= 0x00) goto yy587;
+			if (yych == '\n') goto yy587;
+			goto yy585;
+		} else {
+			if (yych <= 'k') {
+				if (yych <= 'L') goto yy600;
+				goto yy585;
+			} else {
+				if (yych <= 'l') goto yy600;
+				if (yych <= 0x7F) goto yy585;
+				goto yy587;
+			}
+		}
+	} else {
+		if (yych <= 0xED) {
+			if (yych <= 0xDF) goto yy590;
+			if (yych <= 0xE0) goto yy591;
+			if (yych <= 0xEC) goto yy592;
+			goto yy593;
+		} else {
+			if (yych <= 0xF0) {
+				if (yych <= 0xEF) goto yy592;
+				goto yy594;
+			} else {
+				if (yych <= 0xF3) goto yy595;
+				if (yych <= 0xF4) goto yy596;
+				goto yy587;
+			}
+		}
+	}
+yy606:
+	yyaccept = 1;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 64) {
+		goto yy585;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy607;
+			if (yych <= '<') goto yy588;
+		} else {
+			if (yych <= 0xDF) goto yy590;
+			if (yych <= 0xE0) goto yy591;
+			goto yy592;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy593;
+			if (yych <= 0xEF) goto yy592;
+			goto yy594;
+		} else {
+			if (yych <= 0xF3) goto yy595;
+			if (yych <= 0xF4) goto yy596;
+		}
+	}
+yy607:
+	{ return (bufsize_t)(p - start); }
+yy608:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 0xC1) {
+		if (yych <= 'O') {
+			if (yych <= 0x00) goto yy587;
+			if (yych == '\n') goto yy587;
+			goto yy585;
+		} else {
+			if (yych <= 'o') {
+				if (yych >= 'Q') goto yy585;
+			} else {
+				if (yych <= 'p') goto yy609;
+				if (yych <= 0x7F) goto yy585;
+				goto yy587;
+			}
+		}
+	} else {
+		if (yych <= 0xED) {
+			if (yych <= 0xDF) goto yy590;
+			if (yych <= 0xE0) goto yy591;
+			if (yych <= 0xEC) goto yy592;
+			goto yy593;
+		} else {
+			if (yych <= 0xF0) {
+				if (yych <= 0xEF) goto yy592;
+				goto yy594;
+			} else {
+				if (yych <= 0xF3) goto yy595;
+				if (yych <= 0xF4) goto yy596;
+				goto yy587;
+			}
+		}
+	}
+yy609:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy588;
+	}
+	if (yych <= 0xC1) {
+		if (yych <= 'S') {
+			if (yych <= 0x00) goto yy587;
+			if (yych == '\n') goto yy587;
+			goto yy585;
+		} else {
+			if (yych <= 's') {
+				if (yych <= 'T') goto yy603;
+				goto yy585;
+			} else {
+				if (yych <= 't') goto yy603;
+				if (yych <= 0x7F) goto yy585;
+				goto yy587;
+			}
+		}
+	} else {
+		if (yych <= 0xED) {
+			if (yych <= 0xDF) goto yy590;
+			if (yych <= 0xE0) goto yy591;
+			if (yych <= 0xEC) goto yy592;
+			goto yy593;
+		} else {
+			if (yych <= 0xF0) {
+				if (yych <= 0xEF) goto yy592;
+				goto yy594;
+			} else {
+				if (yych <= 0xF3) goto yy595;
+				if (yych <= 0xF4) goto yy596;
+				goto yy587;
+			}
+		}
+	}
+}
+
+}
+
+// Try to match an HTML block end line of type 2
+bufsize_t _scan_html_block_end_2(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	unsigned int yyaccept = 0;
+	static const unsigned char yybm[] = {
+		  0,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,   0,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64, 128,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych <= 0xDF) {
+		if (yych <= ',') {
+			if (yych <= 0x00) goto yy612;
+			if (yych != '\n') goto yy614;
+		} else {
+			if (yych <= '-') goto yy615;
+			if (yych <= 0x7F) goto yy614;
+			if (yych >= 0xC2) goto yy616;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) goto yy617;
+			if (yych == 0xED) goto yy619;
+			goto yy618;
+		} else {
+			if (yych <= 0xF0) goto yy620;
+			if (yych <= 0xF3) goto yy621;
+			if (yych <= 0xF4) goto yy622;
+		}
+	}
+yy612:
+	++p;
+yy613:
+	{ return 0; }
+yy614:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= '\n') {
+		if (yych <= 0x00) goto yy613;
+		if (yych <= '\t') goto yy624;
+		goto yy613;
+	} else {
+		if (yych <= 0x7F) goto yy624;
+		if (yych <= 0xC1) goto yy613;
+		if (yych <= 0xF4) goto yy624;
+		goto yy613;
+	}
+yy615:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 128) {
+		goto yy634;
+	}
+	if (yych <= '\n') {
+		if (yych <= 0x00) goto yy613;
+		if (yych <= '\t') goto yy624;
+		goto yy613;
+	} else {
+		if (yych <= 0x7F) goto yy624;
+		if (yych <= 0xC1) goto yy613;
+		if (yych <= 0xF4) goto yy624;
+		goto yy613;
+	}
+yy616:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy613;
+	if (yych <= 0xBF) goto yy623;
+	goto yy613;
+yy617:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x9F) goto yy613;
+	if (yych <= 0xBF) goto yy627;
+	goto yy613;
+yy618:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy613;
+	if (yych <= 0xBF) goto yy627;
+	goto yy613;
+yy619:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy613;
+	if (yych <= 0x9F) goto yy627;
+	goto yy613;
+yy620:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x8F) goto yy613;
+	if (yych <= 0xBF) goto yy629;
+	goto yy613;
+yy621:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy613;
+	if (yych <= 0xBF) goto yy629;
+	goto yy613;
+yy622:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy613;
+	if (yych <= 0x8F) goto yy629;
+	goto yy613;
+yy623:
+	yych = *++p;
+yy624:
+	if (yybm[0+yych] & 64) {
+		goto yy623;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy625;
+			if (yych <= '-') goto yy626;
+		} else {
+			if (yych <= 0xDF) goto yy627;
+			if (yych <= 0xE0) goto yy628;
+			goto yy629;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy630;
+			if (yych <= 0xEF) goto yy629;
+			goto yy631;
+		} else {
+			if (yych <= 0xF3) goto yy632;
+			if (yych <= 0xF4) goto yy633;
+		}
+	}
+yy625:
+	p = marker;
+	if (yyaccept == 0) {
+		goto yy613;
+	} else {
+		goto yy637;
+	}
+yy626:
+	yych = *++p;
+	if (yybm[0+yych] & 64) {
+		goto yy623;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy625;
+			if (yych <= '-') goto yy634;
+			goto yy625;
+		} else {
+			if (yych <= 0xDF) goto yy627;
+			if (yych <= 0xE0) goto yy628;
+			goto yy629;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy630;
+			if (yych <= 0xEF) goto yy629;
+			goto yy631;
+		} else {
+			if (yych <= 0xF3) goto yy632;
+			if (yych <= 0xF4) goto yy633;
+			goto yy625;
+		}
+	}
+yy627:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy625;
+	if (yych <= 0xBF) goto yy623;
+	goto yy625;
+yy628:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy625;
+	if (yych <= 0xBF) goto yy627;
+	goto yy625;
+yy629:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy625;
+	if (yych <= 0xBF) goto yy627;
+	goto yy625;
+yy630:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy625;
+	if (yych <= 0x9F) goto yy627;
+	goto yy625;
+yy631:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy625;
+	if (yych <= 0xBF) goto yy629;
+	goto yy625;
+yy632:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy625;
+	if (yych <= 0xBF) goto yy629;
+	goto yy625;
+yy633:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy625;
+	if (yych <= 0x8F) goto yy629;
+	goto yy625;
+yy634:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy634;
+	}
+	if (yych <= 0xDF) {
+		if (yych <= '=') {
+			if (yych <= 0x00) goto yy625;
+			if (yych == '\n') goto yy625;
+			goto yy623;
+		} else {
+			if (yych <= '>') goto yy636;
+			if (yych <= 0x7F) goto yy623;
+			if (yych <= 0xC1) goto yy625;
+			goto yy627;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) goto yy628;
+			if (yych == 0xED) goto yy630;
+			goto yy629;
+		} else {
+			if (yych <= 0xF0) goto yy631;
+			if (yych <= 0xF3) goto yy632;
+			if (yych <= 0xF4) goto yy633;
+			goto yy625;
+		}
+	}
+yy636:
+	yyaccept = 1;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 64) {
+		goto yy623;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy637;
+			if (yych <= '-') goto yy626;
+		} else {
+			if (yych <= 0xDF) goto yy627;
+			if (yych <= 0xE0) goto yy628;
+			goto yy629;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy630;
+			if (yych <= 0xEF) goto yy629;
+			goto yy631;
+		} else {
+			if (yych <= 0xF3) goto yy632;
+			if (yych <= 0xF4) goto yy633;
+		}
+	}
+yy637:
+	{ return (bufsize_t)(p - start); }
+}
+
+}
+
+// Try to match an HTML block end line of type 3
+bufsize_t _scan_html_block_end_3(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	unsigned int yyaccept = 0;
+	static const unsigned char yybm[] = {
+		  0,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,   0,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64, 128, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych <= 0xDF) {
+		if (yych <= '>') {
+			if (yych <= 0x00) goto yy640;
+			if (yych != '\n') goto yy642;
+		} else {
+			if (yych <= '?') goto yy643;
+			if (yych <= 0x7F) goto yy642;
+			if (yych >= 0xC2) goto yy644;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) goto yy645;
+			if (yych == 0xED) goto yy647;
+			goto yy646;
+		} else {
+			if (yych <= 0xF0) goto yy648;
+			if (yych <= 0xF3) goto yy649;
+			if (yych <= 0xF4) goto yy650;
+		}
+	}
+yy640:
+	++p;
+yy641:
+	{ return 0; }
+yy642:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= '\n') {
+		if (yych <= 0x00) goto yy641;
+		if (yych <= '\t') goto yy652;
+		goto yy641;
+	} else {
+		if (yych <= 0x7F) goto yy652;
+		if (yych <= 0xC1) goto yy641;
+		if (yych <= 0xF4) goto yy652;
+		goto yy641;
+	}
+yy643:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= '=') {
+		if (yych <= 0x00) goto yy641;
+		if (yych == '\n') goto yy641;
+		goto yy652;
+	} else {
+		if (yych <= 0x7F) {
+			if (yych <= '>') goto yy663;
+			goto yy652;
+		} else {
+			if (yych <= 0xC1) goto yy641;
+			if (yych <= 0xF4) goto yy652;
+			goto yy641;
+		}
+	}
+yy644:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy641;
+	if (yych <= 0xBF) goto yy651;
+	goto yy641;
+yy645:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x9F) goto yy641;
+	if (yych <= 0xBF) goto yy656;
+	goto yy641;
+yy646:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy641;
+	if (yych <= 0xBF) goto yy656;
+	goto yy641;
+yy647:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy641;
+	if (yych <= 0x9F) goto yy656;
+	goto yy641;
+yy648:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x8F) goto yy641;
+	if (yych <= 0xBF) goto yy658;
+	goto yy641;
+yy649:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy641;
+	if (yych <= 0xBF) goto yy658;
+	goto yy641;
+yy650:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy641;
+	if (yych <= 0x8F) goto yy658;
+	goto yy641;
+yy651:
+	yych = *++p;
+yy652:
+	if (yybm[0+yych] & 64) {
+		goto yy651;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy653;
+			if (yych <= '?') goto yy654;
+		} else {
+			if (yych <= 0xDF) goto yy656;
+			if (yych <= 0xE0) goto yy657;
+			goto yy658;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy659;
+			if (yych <= 0xEF) goto yy658;
+			goto yy660;
+		} else {
+			if (yych <= 0xF3) goto yy661;
+			if (yych <= 0xF4) goto yy662;
+		}
+	}
+yy653:
+	p = marker;
+	if (yyaccept == 0) {
+		goto yy641;
+	} else {
+		goto yy664;
+	}
+yy654:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy654;
+	}
+	if (yych <= 0xDF) {
+		if (yych <= '=') {
+			if (yych <= 0x00) goto yy653;
+			if (yych == '\n') goto yy653;
+			goto yy651;
+		} else {
+			if (yych <= '>') goto yy663;
+			if (yych <= 0x7F) goto yy651;
+			if (yych <= 0xC1) goto yy653;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) goto yy657;
+			if (yych == 0xED) goto yy659;
+			goto yy658;
+		} else {
+			if (yych <= 0xF0) goto yy660;
+			if (yych <= 0xF3) goto yy661;
+			if (yych <= 0xF4) goto yy662;
+			goto yy653;
+		}
+	}
+yy656:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy653;
+	if (yych <= 0xBF) goto yy651;
+	goto yy653;
+yy657:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy653;
+	if (yych <= 0xBF) goto yy656;
+	goto yy653;
+yy658:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy653;
+	if (yych <= 0xBF) goto yy656;
+	goto yy653;
+yy659:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy653;
+	if (yych <= 0x9F) goto yy656;
+	goto yy653;
+yy660:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy653;
+	if (yych <= 0xBF) goto yy658;
+	goto yy653;
+yy661:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy653;
+	if (yych <= 0xBF) goto yy658;
+	goto yy653;
+yy662:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy653;
+	if (yych <= 0x8F) goto yy658;
+	goto yy653;
+yy663:
+	yyaccept = 1;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 64) {
+		goto yy651;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy664;
+			if (yych <= '?') goto yy654;
+		} else {
+			if (yych <= 0xDF) goto yy656;
+			if (yych <= 0xE0) goto yy657;
+			goto yy658;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy659;
+			if (yych <= 0xEF) goto yy658;
+			goto yy660;
+		} else {
+			if (yych <= 0xF3) goto yy661;
+			if (yych <= 0xF4) goto yy662;
+		}
+	}
+yy664:
+	{ return (bufsize_t)(p - start); }
+}
+
+}
+
+// Try to match an HTML block end line of type 4
+bufsize_t _scan_html_block_end_4(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	unsigned int yyaccept = 0;
+	static const unsigned char yybm[] = {
+		  0, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128,   0, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128,  64, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		128, 128, 128, 128, 128, 128, 128, 128, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yybm[0+yych] & 64) {
+		goto yy670;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '\n') {
+			if (yych <= 0x00) goto yy667;
+			if (yych <= '\t') goto yy669;
+		} else {
+			if (yych <= 0x7F) goto yy669;
+			if (yych <= 0xC1) goto yy667;
+			if (yych <= 0xDF) goto yy673;
+			goto yy674;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy676;
+			goto yy675;
+		} else {
+			if (yych <= 0xF0) goto yy677;
+			if (yych <= 0xF3) goto yy678;
+			if (yych <= 0xF4) goto yy679;
+		}
+	}
+yy667:
+	++p;
+yy668:
+	{ return 0; }
+yy669:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= '\n') {
+		if (yych <= 0x00) goto yy668;
+		if (yych <= '\t') goto yy681;
+		goto yy668;
+	} else {
+		if (yych <= 0x7F) goto yy681;
+		if (yych <= 0xC1) goto yy668;
+		if (yych <= 0xF4) goto yy681;
+		goto yy668;
+	}
+yy670:
+	yyaccept = 1;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 128) {
+		goto yy680;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy672;
+			if (yych <= '>') goto yy670;
+		} else {
+			if (yych <= 0xDF) goto yy683;
+			if (yych <= 0xE0) goto yy684;
+			goto yy685;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy686;
+			if (yych <= 0xEF) goto yy685;
+			goto yy687;
+		} else {
+			if (yych <= 0xF3) goto yy688;
+			if (yych <= 0xF4) goto yy689;
+		}
+	}
+yy672:
+	{ return (bufsize_t)(p - start); }
+yy673:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy668;
+	if (yych <= 0xBF) goto yy680;
+	goto yy668;
+yy674:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x9F) goto yy668;
+	if (yych <= 0xBF) goto yy683;
+	goto yy668;
+yy675:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy668;
+	if (yych <= 0xBF) goto yy683;
+	goto yy668;
+yy676:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy668;
+	if (yych <= 0x9F) goto yy683;
+	goto yy668;
+yy677:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x8F) goto yy668;
+	if (yych <= 0xBF) goto yy685;
+	goto yy668;
+yy678:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy668;
+	if (yych <= 0xBF) goto yy685;
+	goto yy668;
+yy679:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy668;
+	if (yych <= 0x8F) goto yy685;
+	goto yy668;
+yy680:
+	yych = *++p;
+yy681:
+	if (yybm[0+yych] & 128) {
+		goto yy680;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy682;
+			if (yych <= '>') goto yy670;
+		} else {
+			if (yych <= 0xDF) goto yy683;
+			if (yych <= 0xE0) goto yy684;
+			goto yy685;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy686;
+			if (yych <= 0xEF) goto yy685;
+			goto yy687;
+		} else {
+			if (yych <= 0xF3) goto yy688;
+			if (yych <= 0xF4) goto yy689;
+		}
+	}
+yy682:
+	p = marker;
+	if (yyaccept == 0) {
+		goto yy668;
+	} else {
+		goto yy672;
+	}
+yy683:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy682;
+	if (yych <= 0xBF) goto yy680;
+	goto yy682;
+yy684:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy682;
+	if (yych <= 0xBF) goto yy683;
+	goto yy682;
+yy685:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy682;
+	if (yych <= 0xBF) goto yy683;
+	goto yy682;
+yy686:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy682;
+	if (yych <= 0x9F) goto yy683;
+	goto yy682;
+yy687:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy682;
+	if (yych <= 0xBF) goto yy685;
+	goto yy682;
+yy688:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy682;
+	if (yych <= 0xBF) goto yy685;
+	goto yy682;
+yy689:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy682;
+	if (yych <= 0x8F) goto yy685;
+	goto yy682;
+}
+
+}
+
+// Try to match an HTML block end line of type 5
+bufsize_t _scan_html_block_end_5(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	unsigned int yyaccept = 0;
+	static const unsigned char yybm[] = {
+		  0,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,   0,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64, 128,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		 64,  64,  64,  64,  64,  64,  64,  64, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych <= 0xDF) {
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy692;
+			if (yych != '\n') goto yy694;
+		} else {
+			if (yych <= ']') goto yy695;
+			if (yych <= 0x7F) goto yy694;
+			if (yych >= 0xC2) goto yy696;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) goto yy697;
+			if (yych == 0xED) goto yy699;
+			goto yy698;
+		} else {
+			if (yych <= 0xF0) goto yy700;
+			if (yych <= 0xF3) goto yy701;
+			if (yych <= 0xF4) goto yy702;
+		}
+	}
+yy692:
+	++p;
+yy693:
+	{ return 0; }
+yy694:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= '\n') {
+		if (yych <= 0x00) goto yy693;
+		if (yych <= '\t') goto yy704;
+		goto yy693;
+	} else {
+		if (yych <= 0x7F) goto yy704;
+		if (yych <= 0xC1) goto yy693;
+		if (yych <= 0xF4) goto yy704;
+		goto yy693;
+	}
+yy695:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 128) {
+		goto yy714;
+	}
+	if (yych <= '\n') {
+		if (yych <= 0x00) goto yy693;
+		if (yych <= '\t') goto yy704;
+		goto yy693;
+	} else {
+		if (yych <= 0x7F) goto yy704;
+		if (yych <= 0xC1) goto yy693;
+		if (yych <= 0xF4) goto yy704;
+		goto yy693;
+	}
+yy696:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy693;
+	if (yych <= 0xBF) goto yy703;
+	goto yy693;
+yy697:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x9F) goto yy693;
+	if (yych <= 0xBF) goto yy707;
+	goto yy693;
+yy698:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy693;
+	if (yych <= 0xBF) goto yy707;
+	goto yy693;
+yy699:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy693;
+	if (yych <= 0x9F) goto yy707;
+	goto yy693;
+yy700:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x8F) goto yy693;
+	if (yych <= 0xBF) goto yy709;
+	goto yy693;
+yy701:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy693;
+	if (yych <= 0xBF) goto yy709;
+	goto yy693;
+yy702:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x7F) goto yy693;
+	if (yych <= 0x8F) goto yy709;
+	goto yy693;
+yy703:
+	yych = *++p;
+yy704:
+	if (yybm[0+yych] & 64) {
+		goto yy703;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy705;
+			if (yych <= ']') goto yy706;
+		} else {
+			if (yych <= 0xDF) goto yy707;
+			if (yych <= 0xE0) goto yy708;
+			goto yy709;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy710;
+			if (yych <= 0xEF) goto yy709;
+			goto yy711;
+		} else {
+			if (yych <= 0xF3) goto yy712;
+			if (yych <= 0xF4) goto yy713;
+		}
+	}
+yy705:
+	p = marker;
+	if (yyaccept == 0) {
+		goto yy693;
+	} else {
+		goto yy717;
+	}
+yy706:
+	yych = *++p;
+	if (yybm[0+yych] & 64) {
+		goto yy703;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy705;
+			if (yych <= ']') goto yy714;
+			goto yy705;
+		} else {
+			if (yych <= 0xDF) goto yy707;
+			if (yych <= 0xE0) goto yy708;
+			goto yy709;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy710;
+			if (yych <= 0xEF) goto yy709;
+			goto yy711;
+		} else {
+			if (yych <= 0xF3) goto yy712;
+			if (yych <= 0xF4) goto yy713;
+			goto yy705;
+		}
+	}
+yy707:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy705;
+	if (yych <= 0xBF) goto yy703;
+	goto yy705;
+yy708:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy705;
+	if (yych <= 0xBF) goto yy707;
+	goto yy705;
+yy709:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy705;
+	if (yych <= 0xBF) goto yy707;
+	goto yy705;
+yy710:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy705;
+	if (yych <= 0x9F) goto yy707;
+	goto yy705;
+yy711:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy705;
+	if (yych <= 0xBF) goto yy709;
+	goto yy705;
+yy712:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy705;
+	if (yych <= 0xBF) goto yy709;
+	goto yy705;
+yy713:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy705;
+	if (yych <= 0x8F) goto yy709;
+	goto yy705;
+yy714:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy714;
+	}
+	if (yych <= 0xDF) {
+		if (yych <= '=') {
+			if (yych <= 0x00) goto yy705;
+			if (yych == '\n') goto yy705;
+			goto yy703;
+		} else {
+			if (yych <= '>') goto yy716;
+			if (yych <= 0x7F) goto yy703;
+			if (yych <= 0xC1) goto yy705;
+			goto yy707;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) goto yy708;
+			if (yych == 0xED) goto yy710;
+			goto yy709;
+		} else {
+			if (yych <= 0xF0) goto yy711;
+			if (yych <= 0xF3) goto yy712;
+			if (yych <= 0xF4) goto yy713;
+			goto yy705;
+		}
+	}
+yy716:
+	yyaccept = 1;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 64) {
+		goto yy703;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= '\n') goto yy717;
+			if (yych <= ']') goto yy706;
+		} else {
+			if (yych <= 0xDF) goto yy707;
+			if (yych <= 0xE0) goto yy708;
+			goto yy709;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy710;
+			if (yych <= 0xEF) goto yy709;
+			goto yy711;
+		} else {
+			if (yych <= 0xF3) goto yy712;
+			if (yych <= 0xF4) goto yy713;
+		}
+	}
+yy717:
+	{ 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, 
+		208,  80, 208, 208, 208, 208, 208, 208, 
+		208, 208, 208, 208, 208, 208, 208, 208, 
+		208, 208, 208, 208, 208, 208, 208, 208, 
+		208, 208, 208, 208, 208, 208, 208, 208, 
+		208, 208, 208, 208, 208, 208, 208, 208, 
+		208, 208, 208, 208, 208, 208, 208, 208, 
+		208, 208, 208, 208,  32, 208, 208, 208, 
+		208, 208, 208, 208, 208, 208, 208, 208, 
+		208, 208, 208, 208, 208, 208, 208, 208, 
+		208, 208, 208, 208, 208, 208, 208, 208, 
+		208, 208, 208, 208, 208, 208, 208, 208, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych <= '&') {
+		if (yych == '"') goto yy722;
+	} else {
+		if (yych <= '\'') goto yy723;
+		if (yych <= '(') goto yy724;
+	}
+	++p;
+yy721:
+	{ return 0; }
+yy722:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x00) goto yy721;
+	if (yych <= 0x7F) goto yy726;
+	if (yych <= 0xC1) goto yy721;
+	if (yych <= 0xF4) goto yy726;
+	goto yy721;
+yy723:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x00) goto yy721;
+	if (yych <= 0x7F) goto yy740;
+	if (yych <= 0xC1) goto yy721;
+	if (yych <= 0xF4) goto yy740;
+	goto yy721;
+yy724:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych <= 0x00) goto yy721;
+	if (yych <= 0x7F) goto yy753;
+	if (yych <= 0xC1) goto yy721;
+	if (yych <= 0xF4) goto yy753;
+	goto yy721;
+yy725:
+	yych = *++p;
+yy726:
+	if (yybm[0+yych] & 16) {
+		goto yy725;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy727;
+			if (yych <= '"') goto yy728;
+			goto yy730;
+		} else {
+			if (yych <= 0xC1) goto yy727;
+			if (yych <= 0xDF) goto yy732;
+			goto yy733;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy735;
+			goto yy734;
+		} else {
+			if (yych <= 0xF0) goto yy736;
+			if (yych <= 0xF3) goto yy737;
+			if (yych <= 0xF4) goto yy738;
+		}
+	}
+yy727:
+	p = marker;
+	if (yyaccept <= 1) {
+		if (yyaccept == 0) {
+			goto yy721;
+		} else {
+			goto yy729;
+		}
+	} else {
+		if (yyaccept == 2) {
+			goto yy742;
+		} else {
+			goto yy755;
+		}
+	}
+yy728:
+	++p;
+yy729:
+	{ return (bufsize_t)(p - start); }
+yy730:
+	yych = *++p;
+	if (yybm[0+yych] & 16) {
+		goto yy725;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy727;
+			if (yych <= '"') goto yy765;
+			goto yy730;
+		} else {
+			if (yych <= 0xC1) goto yy727;
+			if (yych >= 0xE0) goto yy733;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy735;
+			goto yy734;
+		} else {
+			if (yych <= 0xF0) goto yy736;
+			if (yych <= 0xF3) goto yy737;
+			if (yych <= 0xF4) goto yy738;
+			goto yy727;
+		}
+	}
+yy732:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0xBF) goto yy725;
+	goto yy727;
+yy733:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy727;
+	if (yych <= 0xBF) goto yy732;
+	goto yy727;
+yy734:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0xBF) goto yy732;
+	goto yy727;
+yy735:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0x9F) goto yy732;
+	goto yy727;
+yy736:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy727;
+	if (yych <= 0xBF) goto yy734;
+	goto yy727;
+yy737:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0xBF) goto yy734;
+	goto yy727;
+yy738:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0x8F) goto yy734;
+	goto yy727;
+yy739:
+	yych = *++p;
+yy740:
+	if (yybm[0+yych] & 64) {
+		goto yy739;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy727;
+			if (yych >= '(') goto yy743;
+		} else {
+			if (yych <= 0xC1) goto yy727;
+			if (yych <= 0xDF) goto yy745;
+			goto yy746;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy748;
+			goto yy747;
+		} else {
+			if (yych <= 0xF0) goto yy749;
+			if (yych <= 0xF3) goto yy750;
+			if (yych <= 0xF4) goto yy751;
+			goto yy727;
+		}
+	}
+yy741:
+	++p;
+yy742:
+	{ return (bufsize_t)(p - start); }
+yy743:
+	yych = *++p;
+	if (yybm[0+yych] & 64) {
+		goto yy739;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy727;
+			if (yych <= '\'') goto yy766;
+			goto yy743;
+		} else {
+			if (yych <= 0xC1) goto yy727;
+			if (yych >= 0xE0) goto yy746;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy748;
+			goto yy747;
+		} else {
+			if (yych <= 0xF0) goto yy749;
+			if (yych <= 0xF3) goto yy750;
+			if (yych <= 0xF4) goto yy751;
+			goto yy727;
+		}
+	}
+yy745:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0xBF) goto yy739;
+	goto yy727;
+yy746:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy727;
+	if (yych <= 0xBF) goto yy745;
+	goto yy727;
+yy747:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0xBF) goto yy745;
+	goto yy727;
+yy748:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0x9F) goto yy745;
+	goto yy727;
+yy749:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy727;
+	if (yych <= 0xBF) goto yy747;
+	goto yy727;
+yy750:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0xBF) goto yy747;
+	goto yy727;
+yy751:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0x8F) goto yy747;
+	goto yy727;
+yy752:
+	yych = *++p;
+yy753:
+	if (yybm[0+yych] & 128) {
+		goto yy752;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy727;
+			if (yych >= '*') goto yy756;
+		} else {
+			if (yych <= 0xC1) goto yy727;
+			if (yych <= 0xDF) goto yy758;
+			goto yy759;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy761;
+			goto yy760;
+		} else {
+			if (yych <= 0xF0) goto yy762;
+			if (yych <= 0xF3) goto yy763;
+			if (yych <= 0xF4) goto yy764;
+			goto yy727;
+		}
+	}
+yy754:
+	++p;
+yy755:
+	{ return (bufsize_t)(p - start); }
+yy756:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy752;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy727;
+			if (yych <= ')') goto yy767;
+			goto yy756;
+		} else {
+			if (yych <= 0xC1) goto yy727;
+			if (yych >= 0xE0) goto yy759;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy761;
+			goto yy760;
+		} else {
+			if (yych <= 0xF0) goto yy762;
+			if (yych <= 0xF3) goto yy763;
+			if (yych <= 0xF4) goto yy764;
+			goto yy727;
+		}
+	}
+yy758:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0xBF) goto yy752;
+	goto yy727;
+yy759:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy727;
+	if (yych <= 0xBF) goto yy758;
+	goto yy727;
+yy760:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0xBF) goto yy758;
+	goto yy727;
+yy761:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0x9F) goto yy758;
+	goto yy727;
+yy762:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy727;
+	if (yych <= 0xBF) goto yy760;
+	goto yy727;
+yy763:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0xBF) goto yy760;
+	goto yy727;
+yy764:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy727;
+	if (yych <= 0x8F) goto yy760;
+	goto yy727;
+yy765:
+	yyaccept = 1;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 16) {
+		goto yy725;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy729;
+			if (yych <= '"') goto yy728;
+			goto yy730;
+		} else {
+			if (yych <= 0xC1) goto yy729;
+			if (yych <= 0xDF) goto yy732;
+			goto yy733;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy735;
+			goto yy734;
+		} else {
+			if (yych <= 0xF0) goto yy736;
+			if (yych <= 0xF3) goto yy737;
+			if (yych <= 0xF4) goto yy738;
+			goto yy729;
+		}
+	}
+yy766:
+	yyaccept = 2;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 64) {
+		goto yy739;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy742;
+			if (yych <= '\'') goto yy741;
+			goto yy743;
+		} else {
+			if (yych <= 0xC1) goto yy742;
+			if (yych <= 0xDF) goto yy745;
+			goto yy746;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy748;
+			goto yy747;
+		} else {
+			if (yych <= 0xF0) goto yy749;
+			if (yych <= 0xF3) goto yy750;
+			if (yych <= 0xF4) goto yy751;
+			goto yy742;
+		}
+	}
+yy767:
+	yyaccept = 3;
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 128) {
+		goto yy752;
+	}
+	if (yych <= 0xE0) {
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy755;
+			if (yych <= ')') goto yy754;
+			goto yy756;
+		} else {
+			if (yych <= 0xC1) goto yy755;
+			if (yych <= 0xDF) goto yy758;
+			goto yy759;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych == 0xED) goto yy761;
+			goto yy760;
+		} else {
+			if (yych <= 0xF0) goto yy762;
+			if (yych <= 0xF3) goto yy763;
+			if (yych <= 0xF4) goto yy764;
+			goto yy755;
+		}
+	}
+}
+
+}
+
+// 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 yy772;
+	}
+	++p;
+	{ return 0; }
+yy772:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy772;
+	}
+	{ 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 yy779;
+	++p;
+yy778:
+	{ return 0; }
+yy779:
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 128) {
+		goto yy780;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy778;
+		if (yych <= '\n') goto yy783;
+		goto yy778;
+	} else {
+		if (yych <= '\r') goto yy783;
+		if (yych == '#') goto yy784;
+		goto yy778;
+	}
+yy780:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy780;
+	}
+yy782:
+	{ return (bufsize_t)(p - start); }
+yy783:
+	++p;
+	goto yy782;
+yy784:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy780;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy785;
+		if (yych <= '\n') goto yy783;
+	} else {
+		if (yych <= '\r') goto yy783;
+		if (yych == '#') goto yy786;
+	}
+yy785:
+	p = marker;
+	goto yy778;
+yy786:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy780;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy785;
+		if (yych <= '\n') goto yy783;
+		goto yy785;
+	} else {
+		if (yych <= '\r') goto yy783;
+		if (yych != '#') goto yy785;
+	}
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy780;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy785;
+		if (yych <= '\n') goto yy783;
+		goto yy785;
+	} else {
+		if (yych <= '\r') goto yy783;
+		if (yych != '#') goto yy785;
+	}
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy780;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy785;
+		if (yych <= '\n') goto yy783;
+		goto yy785;
+	} else {
+		if (yych <= '\r') goto yy783;
+		if (yych != '#') goto yy785;
+	}
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy780;
+	}
+	if (yych <= 0x08) goto yy785;
+	if (yych <= '\n') goto yy783;
+	if (yych == '\r') goto yy783;
+	goto yy785;
+}
+
+}
+
+// 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 yy794;
+	if (yych == '=') goto yy795;
+	++p;
+yy793:
+	{ return 0; }
+yy794:
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 64) {
+		goto yy801;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy793;
+		if (yych <= '\n') goto yy797;
+		goto yy793;
+	} else {
+		if (yych <= '\r') goto yy797;
+		if (yych == ' ') goto yy797;
+		goto yy793;
+	}
+yy795:
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 128) {
+		goto yy807;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy793;
+		if (yych <= '\n') goto yy804;
+		goto yy793;
+	} else {
+		if (yych <= '\r') goto yy804;
+		if (yych == ' ') goto yy804;
+		goto yy793;
+	}
+yy796:
+	yych = *++p;
+yy797:
+	if (yybm[0+yych] & 32) {
+		goto yy796;
+	}
+	if (yych <= 0x08) goto yy798;
+	if (yych <= '\n') goto yy799;
+	if (yych == '\r') goto yy799;
+yy798:
+	p = marker;
+	goto yy793;
+yy799:
+	++p;
+	{ return 2; }
+yy801:
+	yych = *++p;
+	if (yybm[0+yych] & 32) {
+		goto yy796;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy798;
+		if (yych <= '\n') goto yy799;
+		goto yy798;
+	} else {
+		if (yych <= '\r') goto yy799;
+		if (yych == '-') goto yy801;
+		goto yy798;
+	}
+yy803:
+	yych = *++p;
+yy804:
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy798;
+		if (yych <= '\t') goto yy803;
+		if (yych >= '\v') goto yy798;
+	} else {
+		if (yych <= '\r') goto yy805;
+		if (yych == ' ') goto yy803;
+		goto yy798;
+	}
+yy805:
+	++p;
+	{ return 1; }
+yy807:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy807;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy798;
+		if (yych <= '\t') goto yy803;
+		if (yych <= '\n') goto yy805;
+		goto yy798;
+	} else {
+		if (yych <= '\r') goto yy805;
+		if (yych == ' ') goto yy803;
+		goto yy798;
+	}
+}
+
+}
+
+// Scan a thematic break line: "...three or more hyphens, asterisks,
+// or underscores on a line by themselves. If you wish, you may use
+// spaces between the hyphens or asterisks."
+bufsize_t _scan_thematic_break(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	static const unsigned char yybm[] = {
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0, 240,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		240,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,  32,   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, 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, 
+	};
+	yych = *p;
+	if (yych <= ',') {
+		if (yych == '*') goto yy813;
+	} else {
+		if (yych <= '-') goto yy814;
+		if (yych == '_') goto yy815;
+	}
+	++p;
+yy812:
+	{ return 0; }
+yy813:
+	yych = *(marker = ++p);
+	if (yybm[0+yych] & 16) {
+		goto yy816;
+	}
+	if (yych == '*') goto yy819;
+	goto yy812;
+yy814:
+	yych = *(marker = ++p);
+	if (yych <= 0x1F) {
+		if (yych == '\t') goto yy821;
+		goto yy812;
+	} else {
+		if (yych <= ' ') goto yy821;
+		if (yych == '-') goto yy823;
+		goto yy812;
+	}
+yy815:
+	yych = *(marker = ++p);
+	if (yych <= 0x1F) {
+		if (yych == '\t') goto yy825;
+		goto yy812;
+	} else {
+		if (yych <= ' ') goto yy825;
+		if (yych == '_') goto yy827;
+		goto yy812;
+	}
+yy816:
+	yych = *++p;
+	if (yybm[0+yych] & 16) {
+		goto yy816;
+	}
+	if (yych == '*') goto yy819;
+yy818:
+	p = marker;
+	goto yy812;
+yy819:
+	yych = *++p;
+	if (yych <= 0x1F) {
+		if (yych == '\t') goto yy819;
+		goto yy818;
+	} else {
+		if (yych <= ' ') goto yy819;
+		if (yych == '*') goto yy829;
+		goto yy818;
+	}
+yy821:
+	yych = *++p;
+	if (yych <= 0x1F) {
+		if (yych == '\t') goto yy821;
+		goto yy818;
+	} else {
+		if (yych <= ' ') goto yy821;
+		if (yych != '-') goto yy818;
+	}
+yy823:
+	yych = *++p;
+	if (yych <= 0x1F) {
+		if (yych == '\t') goto yy823;
+		goto yy818;
+	} else {
+		if (yych <= ' ') goto yy823;
+		if (yych == '-') goto yy831;
+		goto yy818;
+	}
+yy825:
+	yych = *++p;
+	if (yych <= 0x1F) {
+		if (yych == '\t') goto yy825;
+		goto yy818;
+	} else {
+		if (yych <= ' ') goto yy825;
+		if (yych != '_') goto yy818;
+	}
+yy827:
+	yych = *++p;
+	if (yych <= 0x1F) {
+		if (yych == '\t') goto yy827;
+		goto yy818;
+	} else {
+		if (yych <= ' ') goto yy827;
+		if (yych == '_') goto yy833;
+		goto yy818;
+	}
+yy829:
+	yych = *++p;
+	if (yybm[0+yych] & 32) {
+		goto yy829;
+	}
+	if (yych <= 0x08) goto yy818;
+	if (yych <= '\n') goto yy835;
+	if (yych == '\r') goto yy835;
+	goto yy818;
+yy831:
+	yych = *++p;
+	if (yybm[0+yych] & 64) {
+		goto yy831;
+	}
+	if (yych <= 0x08) goto yy818;
+	if (yych <= '\n') goto yy837;
+	if (yych == '\r') goto yy837;
+	goto yy818;
+yy833:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy833;
+	}
+	if (yych <= 0x08) goto yy818;
+	if (yych <= '\n') goto yy839;
+	if (yych == '\r') goto yy839;
+	goto yy818;
+yy835:
+	++p;
+	{ return (bufsize_t)(p - start); }
+yy837:
+	++p;
+	{ return (bufsize_t)(p - start); }
+yy839:
+	++p;
+	{ return (bufsize_t)(p - start); }
+}
+
+}
+
+// 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,  96, 192, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+	};
+	yych = *p;
+	if (yych == '`') goto yy845;
+	if (yych == '~') goto yy846;
+	++p;
+yy844:
+	{ return 0; }
+yy845:
+	yych = *(marker = ++p);
+	if (yych == '`') goto yy847;
+	goto yy844;
+yy846:
+	yych = *(marker = ++p);
+	if (yych == '~') goto yy849;
+	goto yy844;
+yy847:
+	yych = *++p;
+	if (yybm[0+yych] & 16) {
+		goto yy850;
+	}
+yy848:
+	p = marker;
+	goto yy844;
+yy849:
+	yych = *++p;
+	if (yybm[0+yych] & 32) {
+		goto yy852;
+	}
+	goto yy848;
+yy850:
+	yych = *++p;
+	if (yybm[0+yych] & 16) {
+		goto yy850;
+	}
+	if (yych <= 0xDF) {
+		if (yych <= '\f') {
+			if (yych <= 0x00) goto yy848;
+			if (yych == '\n') {
+				marker = p;
+				goto yy856;
+			}
+			marker = p;
+			goto yy854;
+		} else {
+			if (yych <= '\r') {
+				marker = p;
+				goto yy856;
+			}
+			if (yych <= 0x7F) {
+				marker = p;
+				goto yy854;
+			}
+			if (yych <= 0xC1) goto yy848;
+			marker = p;
+			goto yy858;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) {
+				marker = p;
+				goto yy859;
+			}
+			if (yych == 0xED) {
+				marker = p;
+				goto yy861;
+			}
+			marker = p;
+			goto yy860;
+		} else {
+			if (yych <= 0xF0) {
+				marker = p;
+				goto yy862;
+			}
+			if (yych <= 0xF3) {
+				marker = p;
+				goto yy863;
+			}
+			if (yych <= 0xF4) {
+				marker = p;
+				goto yy864;
+			}
+			goto yy848;
+		}
+	}
+yy852:
+	yych = *++p;
+	if (yybm[0+yych] & 32) {
+		goto yy852;
+	}
+	if (yych <= 0xDF) {
+		if (yych <= '\f') {
+			if (yych <= 0x00) goto yy848;
+			if (yych == '\n') {
+				marker = p;
+				goto yy867;
+			}
+			marker = p;
+			goto yy865;
+		} else {
+			if (yych <= '\r') {
+				marker = p;
+				goto yy867;
+			}
+			if (yych <= 0x7F) {
+				marker = p;
+				goto yy865;
+			}
+			if (yych <= 0xC1) goto yy848;
+			marker = p;
+			goto yy869;
+		}
+	} else {
+		if (yych <= 0xEF) {
+			if (yych <= 0xE0) {
+				marker = p;
+				goto yy870;
+			}
+			if (yych == 0xED) {
+				marker = p;
+				goto yy872;
+			}
+			marker = p;
+			goto yy871;
+		} else {
+			if (yych <= 0xF0) {
+				marker = p;
+				goto yy873;
+			}
+			if (yych <= 0xF3) {
+				marker = p;
+				goto yy874;
+			}
+			if (yych <= 0xF4) {
+				marker = p;
+				goto yy875;
+			}
+			goto yy848;
+		}
+	}
+yy854:
+	yych = *++p;
+	if (yybm[0+yych] & 64) {
+		goto yy854;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy848;
+			if (yych >= 0x0E) goto yy848;
+		} else {
+			if (yych <= 0xDF) goto yy858;
+			if (yych <= 0xE0) goto yy859;
+			goto yy860;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy861;
+			if (yych <= 0xEF) goto yy860;
+			goto yy862;
+		} else {
+			if (yych <= 0xF3) goto yy863;
+			if (yych <= 0xF4) goto yy864;
+			goto yy848;
+		}
+	}
+yy856:
+	++p;
+	p = marker;
+	{ return (bufsize_t)(p - start); }
+yy858:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy848;
+	if (yych <= 0xBF) goto yy854;
+	goto yy848;
+yy859:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy848;
+	if (yych <= 0xBF) goto yy858;
+	goto yy848;
+yy860:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy848;
+	if (yych <= 0xBF) goto yy858;
+	goto yy848;
+yy861:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy848;
+	if (yych <= 0x9F) goto yy858;
+	goto yy848;
+yy862:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy848;
+	if (yych <= 0xBF) goto yy860;
+	goto yy848;
+yy863:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy848;
+	if (yych <= 0xBF) goto yy860;
+	goto yy848;
+yy864:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy848;
+	if (yych <= 0x8F) goto yy860;
+	goto yy848;
+yy865:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy865;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= 0x00) goto yy848;
+			if (yych >= 0x0E) goto yy848;
+		} else {
+			if (yych <= 0xDF) goto yy869;
+			if (yych <= 0xE0) goto yy870;
+			goto yy871;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy872;
+			if (yych <= 0xEF) goto yy871;
+			goto yy873;
+		} else {
+			if (yych <= 0xF3) goto yy874;
+			if (yych <= 0xF4) goto yy875;
+			goto yy848;
+		}
+	}
+yy867:
+	++p;
+	p = marker;
+	{ return (bufsize_t)(p - start); }
+yy869:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy848;
+	if (yych <= 0xBF) goto yy865;
+	goto yy848;
+yy870:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy848;
+	if (yych <= 0xBF) goto yy869;
+	goto yy848;
+yy871:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy848;
+	if (yych <= 0xBF) goto yy869;
+	goto yy848;
+yy872:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy848;
+	if (yych <= 0x9F) goto yy869;
+	goto yy848;
+yy873:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy848;
+	if (yych <= 0xBF) goto yy871;
+	goto yy848;
+yy874:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy848;
+	if (yych <= 0xBF) goto yy871;
+	goto yy848;
+yy875:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy848;
+	if (yych <= 0x8F) goto yy871;
+	goto yy848;
+}
+
+}
+
+// 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 yy880;
+	if (yych == '~') goto yy881;
+	++p;
+yy879:
+	{ return 0; }
+yy880:
+	yych = *(marker = ++p);
+	if (yych == '`') goto yy882;
+	goto yy879;
+yy881:
+	yych = *(marker = ++p);
+	if (yych == '~') goto yy884;
+	goto yy879;
+yy882:
+	yych = *++p;
+	if (yybm[0+yych] & 32) {
+		goto yy885;
+	}
+yy883:
+	p = marker;
+	goto yy879;
+yy884:
+	yych = *++p;
+	if (yybm[0+yych] & 64) {
+		goto yy887;
+	}
+	goto yy883;
+yy885:
+	yych = *++p;
+	if (yybm[0+yych] & 32) {
+		goto yy885;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy883;
+		if (yych <= '\t') {
+			marker = p;
+			goto yy889;
+		}
+		if (yych <= '\n') {
+			marker = p;
+			goto yy891;
+		}
+		goto yy883;
+	} else {
+		if (yych <= '\r') {
+			marker = p;
+			goto yy891;
+		}
+		if (yych == ' ') {
+			marker = p;
+			goto yy889;
+		}
+		goto yy883;
+	}
+yy887:
+	yych = *++p;
+	if (yybm[0+yych] & 64) {
+		goto yy887;
+	}
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy883;
+		if (yych <= '\t') {
+			marker = p;
+			goto yy893;
+		}
+		if (yych <= '\n') {
+			marker = p;
+			goto yy895;
+		}
+		goto yy883;
+	} else {
+		if (yych <= '\r') {
+			marker = p;
+			goto yy895;
+		}
+		if (yych == ' ') {
+			marker = p;
+			goto yy893;
+		}
+		goto yy883;
+	}
+yy889:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy889;
+	}
+	if (yych <= 0x08) goto yy883;
+	if (yych <= '\n') goto yy891;
+	if (yych != '\r') goto yy883;
+yy891:
+	++p;
+	p = marker;
+	{ return (bufsize_t)(p - start); }
+yy893:
+	yych = *++p;
+	if (yych <= '\f') {
+		if (yych <= 0x08) goto yy883;
+		if (yych <= '\t') goto yy893;
+		if (yych >= '\v') goto yy883;
+	} else {
+		if (yych <= '\r') goto yy895;
+		if (yych == ' ') goto yy893;
+		goto yy883;
+	}
+yy895:
+	++p;
+	p = marker;
+	{ return (bufsize_t)(p - start); }
+}
+
+}
+
+// Scans an entity.
+// Returns number of chars matched.
+bufsize_t _scan_entity(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	yych = *p;
+	if (yych == '&') goto yy901;
+	++p;
+yy900:
+	{ return 0; }
+yy901:
+	yych = *(marker = ++p);
+	if (yych <= '@') {
+		if (yych != '#') goto yy900;
+	} else {
+		if (yych <= 'Z') goto yy904;
+		if (yych <= '`') goto yy900;
+		if (yych <= 'z') goto yy904;
+		goto yy900;
+	}
+	yych = *++p;
+	if (yych <= 'W') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy905;
+	} else {
+		if (yych <= 'X') goto yy906;
+		if (yych == 'x') goto yy906;
+	}
+yy903:
+	p = marker;
+	goto yy900;
+yy904:
+	yych = *++p;
+	if (yych <= '@') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy907;
+		goto yy903;
+	} else {
+		if (yych <= 'Z') goto yy907;
+		if (yych <= '`') goto yy903;
+		if (yych <= 'z') goto yy907;
+		goto yy903;
+	}
+yy905:
+	yych = *++p;
+	if (yych <= '/') goto yy903;
+	if (yych <= '9') goto yy908;
+	if (yych == ';') goto yy909;
+	goto yy903;
+yy906:
+	yych = *++p;
+	if (yych <= '@') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy911;
+		goto yy903;
+	} else {
+		if (yych <= 'F') goto yy911;
+		if (yych <= '`') goto yy903;
+		if (yych <= 'f') goto yy911;
+		goto yy903;
+	}
+yy907:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy912;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+			goto yy912;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'z') goto yy912;
+			goto yy903;
+		}
+	}
+yy908:
+	yych = *++p;
+	if (yych <= '/') goto yy903;
+	if (yych <= '9') goto yy913;
+	if (yych != ';') goto yy903;
+yy909:
+	++p;
+	{ return (bufsize_t)(p - start); }
+yy911:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy914;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'F') {
+			if (yych <= '@') goto yy903;
+			goto yy914;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'f') goto yy914;
+			goto yy903;
+		}
+	}
+yy912:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy915;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+			goto yy915;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'z') goto yy915;
+			goto yy903;
+		}
+	}
+yy913:
+	yych = *++p;
+	if (yych <= '/') goto yy903;
+	if (yych <= '9') goto yy916;
+	if (yych == ';') goto yy909;
+	goto yy903;
+yy914:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy917;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'F') {
+			if (yych <= '@') goto yy903;
+			goto yy917;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'f') goto yy917;
+			goto yy903;
+		}
+	}
+yy915:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy918;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+			goto yy918;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'z') goto yy918;
+			goto yy903;
+		}
+	}
+yy916:
+	yych = *++p;
+	if (yych <= '/') goto yy903;
+	if (yych <= '9') goto yy919;
+	if (yych == ';') goto yy909;
+	goto yy903;
+yy917:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy920;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'F') {
+			if (yych <= '@') goto yy903;
+			goto yy920;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'f') goto yy920;
+			goto yy903;
+		}
+	}
+yy918:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy921;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+			goto yy921;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'z') goto yy921;
+			goto yy903;
+		}
+	}
+yy919:
+	yych = *++p;
+	if (yych <= '/') goto yy903;
+	if (yych <= '9') goto yy922;
+	if (yych == ';') goto yy909;
+	goto yy903;
+yy920:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy923;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'F') {
+			if (yych <= '@') goto yy903;
+			goto yy923;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'f') goto yy923;
+			goto yy903;
+		}
+	}
+yy921:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy924;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+			goto yy924;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'z') goto yy924;
+			goto yy903;
+		}
+	}
+yy922:
+	yych = *++p;
+	if (yych <= '/') goto yy903;
+	if (yych <= '9') goto yy925;
+	if (yych == ';') goto yy909;
+	goto yy903;
+yy923:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy925;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'F') {
+			if (yych <= '@') goto yy903;
+			goto yy925;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'f') goto yy925;
+			goto yy903;
+		}
+	}
+yy924:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy926;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+			goto yy926;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'z') goto yy926;
+			goto yy903;
+		}
+	}
+yy925:
+	yych = *++p;
+	if (yych == ';') goto yy909;
+	goto yy903;
+yy926:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy927;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy927:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy928;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy928:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy929;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy929:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy930;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy930:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy931;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy931:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy932;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy932:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy933;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy933:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy934;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy934:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy935;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy935:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy936;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy936:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy937;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy937:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy938;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy938:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy939;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy939:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy940;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy940:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy941;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy941:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy942;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy942:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy943;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy943:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy944;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy944:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy945;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy945:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy946;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy946:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy947;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy947:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy948;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy948:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy949;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych >= '{') goto yy903;
+		}
+	}
+yy949:
+	yych = *++p;
+	if (yych <= ';') {
+		if (yych <= '/') goto yy903;
+		if (yych <= '9') goto yy925;
+		if (yych <= ':') goto yy903;
+		goto yy909;
+	} else {
+		if (yych <= 'Z') {
+			if (yych <= '@') goto yy903;
+			goto yy925;
+		} else {
+			if (yych <= '`') goto yy903;
+			if (yych <= 'z') goto yy925;
+			goto yy903;
+		}
+	}
+}
+
+}
+
+// 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 yy954;
+			if (yych >= 'F') goto yy955;
+		} else {
+			if (yych == 'J') goto yy956;
+			if (yych >= 'V') goto yy957;
+		}
+	} else {
+		if (yych <= 'f') {
+			if (yych == 'd') goto yy954;
+			if (yych >= 'f') goto yy955;
+		} else {
+			if (yych <= 'j') {
+				if (yych >= 'j') goto yy956;
+			} else {
+				if (yych == 'v') goto yy957;
+			}
+		}
+	}
+	++p;
+yy953:
+	{ return 0; }
+yy954:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych == 'A') goto yy958;
+	if (yych == 'a') goto yy958;
+	goto yy953;
+yy955:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych == 'I') goto yy960;
+	if (yych == 'i') goto yy960;
+	goto yy953;
+yy956:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych == 'A') goto yy961;
+	if (yych == 'a') goto yy961;
+	goto yy953;
+yy957:
+	yyaccept = 0;
+	yych = *(marker = ++p);
+	if (yych == 'B') goto yy962;
+	if (yych == 'b') goto yy962;
+	goto yy953;
+yy958:
+	yych = *++p;
+	if (yych == 'T') goto yy963;
+	if (yych == 't') goto yy963;
+yy959:
+	p = marker;
+	if (yyaccept == 0) {
+		goto yy953;
+	} else {
+		goto yy971;
+	}
+yy960:
+	yych = *++p;
+	if (yych == 'L') goto yy964;
+	if (yych == 'l') goto yy964;
+	goto yy959;
+yy961:
+	yych = *++p;
+	if (yych == 'V') goto yy965;
+	if (yych == 'v') goto yy965;
+	goto yy959;
+yy962:
+	yych = *++p;
+	if (yych == 'S') goto yy966;
+	if (yych == 's') goto yy966;
+	goto yy959;
+yy963:
+	yych = *++p;
+	if (yych == 'A') goto yy967;
+	if (yych == 'a') goto yy967;
+	goto yy959;
+yy964:
+	yych = *++p;
+	if (yych == 'E') goto yy968;
+	if (yych == 'e') goto yy968;
+	goto yy959;
+yy965:
+	yych = *++p;
+	if (yych == 'A') goto yy962;
+	if (yych == 'a') goto yy962;
+	goto yy959;
+yy966:
+	yych = *++p;
+	if (yych == 'C') goto yy969;
+	if (yych == 'c') goto yy969;
+	goto yy959;
+yy967:
+	yych = *++p;
+	if (yych == ':') goto yy970;
+	goto yy959;
+yy968:
+	yych = *++p;
+	if (yych == ':') goto yy972;
+	goto yy959;
+yy969:
+	yych = *++p;
+	if (yych == 'R') goto yy973;
+	if (yych == 'r') goto yy973;
+	goto yy959;
+yy970:
+	yyaccept = 1;
+	yych = *(marker = ++p);
+	if (yych == 'I') goto yy974;
+	if (yych == 'i') goto yy974;
+yy971:
+	{ return (bufsize_t)(p - start); }
+yy972:
+	++p;
+	goto yy971;
+yy973:
+	yych = *++p;
+	if (yych == 'I') goto yy975;
+	if (yych == 'i') goto yy975;
+	goto yy959;
+yy974:
+	yych = *++p;
+	if (yych == 'M') goto yy976;
+	if (yych == 'm') goto yy976;
+	goto yy959;
+yy975:
+	yych = *++p;
+	if (yych == 'P') goto yy977;
+	if (yych == 'p') goto yy977;
+	goto yy959;
+yy976:
+	yych = *++p;
+	if (yych == 'A') goto yy978;
+	if (yych == 'a') goto yy978;
+	goto yy959;
+yy977:
+	yych = *++p;
+	if (yych == 'T') goto yy968;
+	if (yych == 't') goto yy968;
+	goto yy959;
+yy978:
+	yych = *++p;
+	if (yych == 'G') goto yy979;
+	if (yych != 'g') goto yy959;
+yy979:
+	yych = *++p;
+	if (yych == 'E') goto yy980;
+	if (yych != 'e') goto yy959;
+yy980:
+	yych = *++p;
+	if (yych != '/') goto yy959;
+	yych = *++p;
+	if (yych <= 'W') {
+		if (yych <= 'J') {
+			if (yych == 'G') goto yy982;
+			if (yych <= 'I') goto yy959;
+			goto yy983;
+		} else {
+			if (yych == 'P') goto yy984;
+			if (yych <= 'V') goto yy959;
+			goto yy985;
+		}
+	} else {
+		if (yych <= 'j') {
+			if (yych == 'g') goto yy982;
+			if (yych <= 'i') goto yy959;
+			goto yy983;
+		} else {
+			if (yych <= 'p') {
+				if (yych <= 'o') goto yy959;
+				goto yy984;
+			} else {
+				if (yych == 'w') goto yy985;
+				goto yy959;
+			}
+		}
+	}
+yy982:
+	yych = *++p;
+	if (yych == 'I') goto yy986;
+	if (yych == 'i') goto yy986;
+	goto yy959;
+yy983:
+	yych = *++p;
+	if (yych == 'P') goto yy987;
+	if (yych == 'p') goto yy987;
+	goto yy959;
+yy984:
+	yych = *++p;
+	if (yych == 'N') goto yy988;
+	if (yych == 'n') goto yy988;
+	goto yy959;
+yy985:
+	yych = *++p;
+	if (yych == 'E') goto yy989;
+	if (yych == 'e') goto yy989;
+	goto yy959;
+yy986:
+	yych = *++p;
+	if (yych == 'F') goto yy990;
+	if (yych == 'f') goto yy990;
+	goto yy959;
+yy987:
+	yych = *++p;
+	if (yych == 'E') goto yy988;
+	if (yych != 'e') goto yy959;
+yy988:
+	yych = *++p;
+	if (yych == 'G') goto yy990;
+	if (yych == 'g') goto yy990;
+	goto yy959;
+yy989:
+	yych = *++p;
+	if (yych == 'B') goto yy992;
+	if (yych == 'b') goto yy992;
+	goto yy959;
+yy990:
+	++p;
+	{ return 0; }
+yy992:
+	yych = *++p;
+	if (yych == 'P') goto yy990;
+	if (yych == 'p') goto yy990;
+	goto yy959;
+}
+
+}
+
+// Scans a footnote definition opening.
+bufsize_t _scan_footnote_definition(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+{
+	unsigned char yych;
+	static const unsigned char yybm[] = {
+		  0,  64,  64,  64,  64,  64,  64,  64, 
+		 64, 128,   0,  64,  64,   0,  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,   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, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  0,   0,   0,   0,   0,   0,   0,   0, 
+		  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 yy997;
+	++p;
+yy996:
+	{ return 0; }
+yy997:
+	yych = *(marker = ++p);
+	if (yych != '^') goto yy996;
+	yych = *++p;
+	if (yych != ']') goto yy1001;
+yy999:
+	p = marker;
+	goto yy996;
+yy1000:
+	yych = *++p;
+yy1001:
+	if (yybm[0+yych] & 64) {
+		goto yy1000;
+	}
+	if (yych <= 0xEC) {
+		if (yych <= 0xC1) {
+			if (yych <= ' ') goto yy999;
+			if (yych <= ']') goto yy1009;
+			goto yy999;
+		} else {
+			if (yych <= 0xDF) goto yy1002;
+			if (yych <= 0xE0) goto yy1003;
+			goto yy1004;
+		}
+	} else {
+		if (yych <= 0xF0) {
+			if (yych <= 0xED) goto yy1005;
+			if (yych <= 0xEF) goto yy1004;
+			goto yy1006;
+		} else {
+			if (yych <= 0xF3) goto yy1007;
+			if (yych <= 0xF4) goto yy1008;
+			goto yy999;
+		}
+	}
+yy1002:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy999;
+	if (yych <= 0xBF) goto yy1000;
+	goto yy999;
+yy1003:
+	yych = *++p;
+	if (yych <= 0x9F) goto yy999;
+	if (yych <= 0xBF) goto yy1002;
+	goto yy999;
+yy1004:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy999;
+	if (yych <= 0xBF) goto yy1002;
+	goto yy999;
+yy1005:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy999;
+	if (yych <= 0x9F) goto yy1002;
+	goto yy999;
+yy1006:
+	yych = *++p;
+	if (yych <= 0x8F) goto yy999;
+	if (yych <= 0xBF) goto yy1004;
+	goto yy999;
+yy1007:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy999;
+	if (yych <= 0xBF) goto yy1004;
+	goto yy999;
+yy1008:
+	yych = *++p;
+	if (yych <= 0x7F) goto yy999;
+	if (yych <= 0x8F) goto yy1004;
+	goto yy999;
+yy1009:
+	yych = *++p;
+	if (yych != ':') goto yy999;
+yy1010:
+	yych = *++p;
+	if (yybm[0+yych] & 128) {
+		goto yy1010;
+	}
+	{ return (bufsize_t)(p - start); }
+}
+
 }
diff --git a/cbits/scanners.h b/cbits/scanners.h
--- a/cbits/scanners.h
+++ b/cbits/scanners.h
@@ -1,7 +1,7 @@
 #ifndef CMARK_SCANNERS_H
 #define CMARK_SCANNERS_H
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "chunk.h"
 
 #ifdef __cplusplus
@@ -31,6 +31,7 @@
 bufsize_t _scan_close_code_fence(const unsigned char *p);
 bufsize_t _scan_entity(const unsigned char *p);
 bufsize_t _scan_dangerous_url(const unsigned char *p);
+bufsize_t _scan_footnote_definition(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)
@@ -54,6 +55,7 @@
 #define scan_close_code_fence(c, n) _scan_at(&_scan_close_code_fence, c, n)
 #define scan_entity(c, n) _scan_at(&_scan_entity, c, n)
 #define scan_dangerous_url(c, n) _scan_at(&_scan_dangerous_url, c, n)
+#define scan_footnote_definition(c, n) _scan_at(&_scan_footnote_definition, c, n)
 
 #ifdef __cplusplus
 }
diff --git a/cbits/strikethrough.c b/cbits/strikethrough.c
--- a/cbits/strikethrough.c
+++ b/cbits/strikethrough.c
@@ -1,5 +1,6 @@
 #include "strikethrough.h"
 #include <parser.h>
+#include <render.h>
 
 cmark_node_type CMARK_NODE_STRIKETHROUGH;
 
@@ -26,7 +27,8 @@
   res->start_line = res->end_line = cmark_inline_parser_get_line(inline_parser);
   res->start_column = cmark_inline_parser_get_column(inline_parser) - delims;
 
-  if (left_flanking || right_flanking) {
+  if ((left_flanking || right_flanking) &&
+      (!(parser->options & CMARK_OPT_STRIKETHROUGH_DOUBLE_TILDE) || delims == 2)) {
     cmark_inline_parser_push_delimiter(inline_parser, character, left_flanking,
                                        right_flanking, res);
   }
@@ -49,7 +51,6 @@
 
   cmark_node_set_syntax_extension(strikethrough, self);
 
-  cmark_node_set_string_content(strikethrough, "~");
   tmp = cmark_node_next(opener->inl_text);
 
   while (tmp) {
@@ -92,7 +93,7 @@
 static void commonmark_render(cmark_syntax_extension *extension,
                               cmark_renderer *renderer, cmark_node *node,
                               cmark_event_type ev_type, int options) {
-  renderer->out(renderer, node, cmark_node_get_string_content(node), false, LITERAL);
+  renderer->out(renderer, node, "~~", false, LITERAL);
 }
 
 static void latex_render(cmark_syntax_extension *extension,
@@ -131,6 +132,12 @@
   }
 }
 
+static void plaintext_render(cmark_syntax_extension *extension,
+                             cmark_renderer *renderer, cmark_node *node,
+                             cmark_event_type ev_type, int options) {
+  renderer->out(renderer, node, "~", false, LITERAL);
+}
+
 cmark_syntax_extension *create_strikethrough_extension(void) {
   cmark_syntax_extension *ext = cmark_syntax_extension_new("strikethrough");
   cmark_llist *special_chars = NULL;
@@ -141,6 +148,7 @@
   cmark_syntax_extension_set_latex_render_func(ext, latex_render);
   cmark_syntax_extension_set_man_render_func(ext, man_render);
   cmark_syntax_extension_set_html_render_func(ext, html_render);
+  cmark_syntax_extension_set_plaintext_render_func(ext, plaintext_render);
   CMARK_NODE_STRIKETHROUGH = cmark_syntax_extension_add_node(1);
 
   cmark_syntax_extension_set_match_inline_func(ext, match);
@@ -149,6 +157,8 @@
   cmark_mem *mem = cmark_get_default_mem_allocator();
   special_chars = cmark_llist_append(mem, special_chars, (void *)'~');
   cmark_syntax_extension_set_special_inline_chars(ext, special_chars);
+
+  cmark_syntax_extension_set_emphasis(ext, 1);
 
   return ext;
 }
diff --git a/cbits/strikethrough.h b/cbits/strikethrough.h
--- a/cbits/strikethrough.h
+++ b/cbits/strikethrough.h
@@ -1,7 +1,7 @@
-#ifndef STRIKETHROUGH_H
-#define STRIKETHROUGH_H
+#ifndef CMARK_GFM_STRIKETHROUGH_H
+#define CMARK_GFM_STRIKETHROUGH_H
 
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 
 extern cmark_node_type CMARK_NODE_STRIKETHROUGH;
 cmark_syntax_extension *create_strikethrough_extension(void);
diff --git a/cbits/syntax_extension.c b/cbits/syntax_extension.c
--- a/cbits/syntax_extension.c
+++ b/cbits/syntax_extension.c
@@ -1,6 +1,7 @@
 #include <stdlib.h>
+#include <assert.h>
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "syntax_extension.h"
 #include "buffer.h"
 
@@ -34,6 +35,11 @@
   }
 
   return *ref = (cmark_node_type) ((int) *ref + 1);
+}
+
+void cmark_syntax_extension_set_emphasis(cmark_syntax_extension *extension,
+                                         int emphasis) {
+  extension->emphasis = emphasis == 1;
 }
 
 void cmark_syntax_extension_set_open_block_func(cmark_syntax_extension *extension,
diff --git a/cbits/syntax_extension.h b/cbits/syntax_extension.h
--- a/cbits/syntax_extension.h
+++ b/cbits/syntax_extension.h
@@ -1,8 +1,9 @@
 #ifndef CMARK_SYNTAX_EXTENSION_H
 #define CMARK_SYNTAX_EXTENSION_H
 
-#include "cmark.h"
-#include "cmark_extension_api.h"
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
+#include "config.h"
 
 struct cmark_syntax_extension {
   cmark_match_block_func          last_block_matches;
@@ -12,6 +13,7 @@
   cmark_llist                   * special_inline_chars;
   char                          * name;
   void                          * priv;
+  bool                            emphasis;
   cmark_free_func                 free_function;
   cmark_get_type_string_func      get_type_string_func;
   cmark_can_contain_func          can_contain_func;
diff --git a/cbits/table.c b/cbits/table.c
--- a/cbits/table.c
+++ b/cbits/table.c
@@ -1,9 +1,10 @@
-#include <cmark_extension_api.h>
+#include <cmark-gfm-extension_api.h>
 #include <html.h>
 #include <inlines.h>
 #include <parser.h>
 #include <references.h>
 #include <string.h>
+#include <render.h>
 
 #include "ext_scanners.h"
 #include "strikethrough.h"
@@ -541,6 +542,18 @@
   }
 }
 
+static void html_table_add_align(cmark_strbuf* html, const char* align, int options) {
+  if (options & CMARK_OPT_TABLE_PREFER_STYLE_ATTRIBUTES) {
+    cmark_strbuf_puts(html, " style=\"text-align: ");
+    cmark_strbuf_puts(html, align);
+    cmark_strbuf_puts(html, "\"");
+  } else {
+    cmark_strbuf_puts(html, " align=\"");
+    cmark_strbuf_puts(html, align);
+    cmark_strbuf_puts(html, "\"");
+  }
+}
+
 struct html_table_state {
   unsigned need_closing_table_body : 1;
   unsigned in_table_header : 1;
@@ -565,10 +578,15 @@
       cmark_strbuf_putc(html, '>');
       table_state->need_closing_table_body = false;
     } else {
-      if (table_state->need_closing_table_body)
+      if (table_state->need_closing_table_body) {
+        cmark_html_render_cr(html);
         cmark_strbuf_puts(html, "</tbody>");
+        cmark_html_render_cr(html);
+      }
       table_state->need_closing_table_body = false;
-      cmark_strbuf_puts(html, "</table>\n");
+      cmark_html_render_cr(html);
+      cmark_strbuf_puts(html, "</table>");
+      cmark_html_render_cr(html);
     }
   } else if (node->type == CMARK_NODE_TABLE_ROW) {
     if (entering) {
@@ -577,6 +595,10 @@
         table_state->in_table_header = 1;
         cmark_strbuf_puts(html, "<thead>");
         cmark_html_render_cr(html);
+      } else if (!table_state->need_closing_table_body) {
+        cmark_strbuf_puts(html, "<tbody>");
+        cmark_html_render_cr(html);
+        table_state->need_closing_table_body = 1;
       }
       cmark_strbuf_puts(html, "<tr");
       cmark_html_render_sourcepos(node, html, options);
@@ -587,9 +609,6 @@
       if (((node_table_row *)node->as.opaque)->is_header) {
         cmark_html_render_cr(html);
         cmark_strbuf_puts(html, "</thead>");
-        cmark_html_render_cr(html);
-        cmark_strbuf_puts(html, "<tbody>");
-        table_state->need_closing_table_body = 1;
         table_state->in_table_header = false;
       }
     }
@@ -609,9 +628,9 @@
           break;
 
       switch (alignments[i]) {
-      case 'l': cmark_strbuf_puts(html, " align=\"left\""); break;
-      case 'c': cmark_strbuf_puts(html, " align=\"center\""); break;
-      case 'r': cmark_strbuf_puts(html, " align=\"right\""); break;
+      case 'l': html_table_add_align(html, "left", options); break;
+      case 'c': html_table_add_align(html, "center", options); break;
+      case 'r': html_table_add_align(html, "right", options); break;
       }
 
       cmark_html_render_sourcepos(node, html, options);
@@ -666,14 +685,14 @@
   return self;
 }
 
-uint16_t cmarkextensions_get_table_columns(cmark_node *node) {
+uint16_t cmark_gfm_extensions_get_table_columns(cmark_node *node) {
   if (node->type != CMARK_NODE_TABLE)
     return 0;
 
   return ((node_table *)node->as.opaque)->n_columns;
 }
 
-uint8_t *cmarkextensions_get_table_alignments(cmark_node *node) {
+uint8_t *cmark_gfm_extensions_get_table_alignments(cmark_node *node) {
   if (node->type != CMARK_NODE_TABLE)
     return 0;
 
diff --git a/cbits/table.h b/cbits/table.h
--- a/cbits/table.h
+++ b/cbits/table.h
@@ -1,7 +1,11 @@
-#ifndef TABLE_H
-#define TABLE_H
+#ifndef CMARK_GFM_TABLE_H
+#define CMARK_GFM_TABLE_H
 
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
+
+
+extern cmark_node_type CMARK_NODE_TABLE, CMARK_NODE_TABLE_ROW,
+    CMARK_NODE_TABLE_CELL;
 
 cmark_syntax_extension *create_table_extension(void);
 
diff --git a/cbits/tagfilter.h b/cbits/tagfilter.h
--- a/cbits/tagfilter.h
+++ b/cbits/tagfilter.h
@@ -1,7 +1,7 @@
-#ifndef TAGFILTER_H
-#define TAGFILTER_H
+#ifndef CMARK_GFM_TAGFILTER_H
+#define CMARK_GFM_TAGFILTER_H
 
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 
 cmark_syntax_extension *create_tagfilter_extension(void);
 
diff --git a/cbits/utf8.h b/cbits/utf8.h
--- a/cbits/utf8.h
+++ b/cbits/utf8.h
@@ -8,24 +8,24 @@
 extern "C" {
 #endif
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str,
                               bufsize_t len);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_utf8proc_check(cmark_strbuf *dest, const uint8_t *line,
                           bufsize_t size);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_utf8proc_is_space(int32_t uc);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_utf8proc_is_punctuation(int32_t uc);
 
 #ifdef __cplusplus
diff --git a/cbits/xml.c b/cbits/xml.c
--- a/cbits/xml.c
+++ b/cbits/xml.c
@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "houdini.h"
diff --git a/changelog b/changelog
--- a/changelog
+++ b/changelog
@@ -1,3 +1,8 @@
+cmark-gfm 0.1.5 (21 Aug 2018)
+
+  * Update to cmark-gfm 0.28.3.gfm.15.
+  * Fix build with system cmark-gfm (Felix Yan, #9).
+
 cmark-gfm 0.1.4 (2 Jul 2018)
 
   * Extensions work correctly on big-endian systems (Ilias Tsitsimpis).
diff --git a/cmark-gfm.cabal b/cmark-gfm.cabal
--- a/cmark-gfm.cabal
+++ b/cmark-gfm.cabal
@@ -1,5 +1,5 @@
 name:                cmark-gfm
-version:             0.1.4
+version:             0.1.5
 synopsis:            Fast, accurate GitHub Flavored Markdown parser and renderer
 description:
   This package provides Haskell bindings for
@@ -21,15 +21,15 @@
 extra-source-files:  README.md
                      changelog
                      cbits/chunk.h
-                     cbits/cmark_export.h
+                     cbits/cmark-gfm_export.h
                      cbits/debug.h
                      cbits/inlines.h
-                     cbits/cmark.h
+                     cbits/cmark-gfm.h
                      cbits/houdini.h
                      cbits/references.h
                      cbits/utf8.h
                      cbits/parser.h
-                     cbits/cmark_version.h
+                     cbits/cmark-gfm_version.h
                      cbits/html_unescape.h
                      cbits/iterator.h
                      cbits/node.h
@@ -40,18 +40,20 @@
                      cbits/scanners.h
                      cbits/case_fold_switch.inc
                      cbits/entities.inc
-                     cbits/cmark_extension_api.h
+                     cbits/cmark-gfm-extension_api.h
                      cbits/html.h
                      cbits/plugin.h
                      cbits/registry.h
                      cbits/syntax_extension.h
                      cbits/autolink.h
-                     cbits/core-extensions.h
+                     cbits/cmark-gfm-core-extensions.h
                      cbits/ext_scanners.h
                      cbits/strikethrough.h
                      cbits/table.h
                      cbits/tagfilter.h
-                     cbits/cmarkextensions_export.h
+                     cbits/cmark-gfm-extensions_export.h
+                     cbits/map.h
+                     cbits/footnotes.h
                      bench/sample.md
                      bench/full-sample.md
 cabal-version:       >=1.14
@@ -74,11 +76,11 @@
   default-language:    Haskell2010
   ghc-options:         -Wall -fno-warn-unused-do-bind
   if flag(pkgconfig)
-    pkgconfig-depends: libcmark-gfm
+    Extra-Libraries: cmark-gfm cmark-gfmextensions
   else
     cc-options:        -Wall -std=c99
     Include-dirs:      cbits
-    Includes:          cmark.h
+    Includes:          cmark-gfm.h
     c-sources:         cbits/houdini_html_u.c
                        cbits/references.c
                        cbits/utf8.c
@@ -110,6 +112,8 @@
                        cbits/strikethrough.c
                        cbits/table.c
                        cbits/tagfilter.c
+                       cbits/footnotes.c
+                       cbits/map.c
 
 benchmark bench-cmark-gfm
   type:             exitcode-stdio-1.0
diff --git a/test/test-cmark.hs b/test/test-cmark.hs
--- a/test/test-cmark.hs
+++ b/test/test-cmark.hs
@@ -28,7 +28,7 @@
   , "<p>www.google.com</p>\n" ~=? commonmarkToHtml [] [] "www.google.com"
   , "<p><a href=\"http://www.google.com\">www.google.com</a></p>\n" ~=? commonmarkToHtml [] [extAutolink] "www.google.com"
   , "<p>| a |\n| --- |\n| b |</p>\n" ~=? commonmarkToHtml [] [] "| a |\n| --- |\n| b |\n"
-  , "<table>\n<thead>\n<tr>\n<th>a</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>b</td>\n</tr></tbody></table>\n" ~=? commonmarkToHtml [] [extTable] "| a |\n| --- |\n| b |\n"
+  , "<table>\n<thead>\n<tr>\n<th>a</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>b</td>\n</tr>\n</tbody>\n</table>\n" ~=? commonmarkToHtml [] [extTable] "| a |\n| --- |\n| b |\n"
   , Node (Just (PosInfo {startLine = 1, startColumn = 1, endLine = 3, endColumn = 17})) DOCUMENT [Node (Just (PosInfo {startLine = 1, startColumn = 1, endLine = 3, endColumn = 17})) (TABLE [LeftAligned,CenterAligned,NoAlignment,RightAligned]) [Node (Just (PosInfo {startLine = 1, startColumn = 1, endLine = 1, endColumn = 17})) TABLE_ROW [Node (Just (PosInfo {startLine = 1, startColumn = 2, endLine = 1, endColumn = 4})) TABLE_CELL [Node (Just (PosInfo {startLine = 1, startColumn = 3, endLine = 1, endColumn = 3})) (TEXT "a") []],Node (Just (PosInfo {startLine = 1, startColumn = 6, endLine = 1, endColumn = 8})) TABLE_CELL [Node (Just (PosInfo {startLine = 1, startColumn = 7, endLine = 1, endColumn = 7})) (TEXT "b") []],Node (Just (PosInfo {startLine = 1, startColumn = 10, endLine = 1, endColumn = 12})) TABLE_CELL [Node (Just (PosInfo {startLine = 1, startColumn = 11, endLine = 1, endColumn = 11})) (TEXT "c") []],Node (Just (PosInfo {startLine = 1, startColumn = 14, endLine = 1, endColumn = 16})) TABLE_CELL [Node (Just (PosInfo {startLine = 1, startColumn = 15, endLine = 1, endColumn = 15})) (TEXT "d") []]],Node (Just (PosInfo {startLine = 3, startColumn = 1, endLine = 3, endColumn = 17})) TABLE_ROW [Node (Just (PosInfo {startLine = 3, startColumn = 2, endLine = 3, endColumn = 4})) TABLE_CELL [Node (Just (PosInfo {startLine = 3, startColumn = 3, endLine = 3, endColumn = 3})) (TEXT "y") []],Node (Just (PosInfo {startLine = 3, startColumn = 6, endLine = 3, endColumn = 8})) TABLE_CELL [Node (Just (PosInfo {startLine = 3, startColumn = 7, endLine = 3, endColumn = 7})) (TEXT "o") []],Node (Just (PosInfo {startLine = 3, startColumn = 10, endLine = 3, endColumn = 12})) TABLE_CELL [Node (Just (PosInfo {startLine = 3, startColumn = 11, endLine = 3, endColumn = 11})) (TEXT "s") []],Node (Just (PosInfo {startLine = 3, startColumn = 14, endLine = 3, endColumn = 16})) TABLE_CELL [Node (Just (PosInfo {startLine = 3, startColumn = 15, endLine = 3, endColumn = 15})) (TEXT "h") []]]]] ~=? commonmarkToNode [] [extTable] "| a | b | c | d |\n| :-- | :-: | --- | --: |\n| y | o | s | h |"
   , "<xmp>\n" ~=? commonmarkToHtml [] [] "<xmp>"
   , "&lt;xmp>\n" ~=? commonmarkToHtml [] [extTagfilter] "<xmp>"